diff --git a/.github/workflows/compilation.yml b/.github/workflows/compilation.yml index 5cfb53f..35c0f8c 100644 --- a/.github/workflows/compilation.yml +++ b/.github/workflows/compilation.yml @@ -19,4 +19,4 @@ jobs: - name: Compile orbislib run: | - make clean all install + ./build.sh diff --git a/Makefile b/Makefile deleted file mode 100644 index 70196e9..0000000 --- a/Makefile +++ /dev/null @@ -1,43 +0,0 @@ -ifndef ORBISDEV -$(error ORBISDEV, is not set) -endif - -target := ps4_lib -OutPath := lib -TargetFile := liborbis -AllTarget = $(OutPath)/$(TargetFile).a - -include $(ORBISDEV)/make/ps4sdklib.mk -CompilerFlags += -DHAVE_CONFIG_H -D_U_="__attribute__((unused))" -DNDEBUG -D__PS4__ -D_BSD_SOURCE -D__ORBIS__ -CompilerFlagsCpp += -DHAVE_CONFIG_H -D_U_="__attribute__((unused))" -DNDEBUG -D__PS4__ -D_BSD_SOURCE -D__ORBIS__ -IncludePath += -I$(ORBISDEV)/usr/include -Iinclude/nfsc - - -$(OutPath)/$(TargetFile).a: $(ObjectFiles) - $(dirp) - $(archive) - -install: - @cp $(OutPath)/$(TargetFile).a $(ORBISDEV)/usr/lib - @cp include/debugnet.h $(ORBISDEV)/usr/include/orbis - @mkdir -p $(ORBISDEV)/usr/include/orbis/nfsc - @cp include/nfsc/*.h $(ORBISDEV)/usr/include/orbis/nfsc - @cp include/orbisNfs.h $(ORBISDEV)/usr/include/orbis - @cp include/orbisPad.h $(ORBISDEV)/usr/include/orbis - @cp include/orbisKeyboard.h $(ORBISDEV)/usr/include/orbis - @cp include/kb.h $(ORBISDEV)/usr/include/orbis - @cp include/orbisAudio.h $(ORBISDEV)/usr/include/orbis - @cp include/modplayer.h $(ORBISDEV)/usr/include/orbis - @cp include/pl_ini.h $(ORBISDEV)/usr/include/orbis - @cp include/orbislink.h $(ORBISDEV)/usr/include/orbis - @cp include/png.h $(ORBISDEV)/usr/include/orbis - @cp include/pngconf.h $(ORBISDEV)/usr/include/orbis - @cp include/pnglibconf.h $(ORBISDEV)/usr/include/orbis - @cp include/pngstruct.h $(ORBISDEV)/usr/include/orbis - @cp include/pnginfo.h $(ORBISDEV)/usr/include/orbis - @cp include/zlib.h $(ORBISDEV)/usr/include/orbis - @cp include/zconf.h $(ORBISDEV)/usr/include/orbis - @cp include/sxmlc.h $(ORBISDEV)/usr/include/orbis - @cp include/sxmlsearch.h $(ORBISDEV)/usr/include/orbis - @echo "$(TargetFile) Installed!" - diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..a391a4e --- /dev/null +++ b/build.sh @@ -0,0 +1,22 @@ +#!/bin/bash -x +SUBDIRS="orbisdev-utils orbisdev-libkernelUtil orbisdev-libdebugnet orbisdev-libz orbisdev-liborbisPad orbisdev-liborbisAudio orbisdev-liborbisNfs orbisdev-liborbisKeyboard orbisdev-libmod orbisdev-libSQLite orbisdev-liborbisLink" +PROC_NR=$(getconf _NPROCESSORS_ONLN) + +## Download the source code. +for dir in $SUBDIRS +do + echo $dir + if test ! -d "$dir/.git"; then + git clone https://github.com/orbisdev/$dir && cd $dir || exit 1 + else + cd $dir && + git pull && git fetch origin && + git reset --hard origin/master || exit 1 + fi + make --quiet -j $PROC_NR clean || { exit 1; } + make --quiet -j $PROC_NR || { exit 1; } + make --quiet -j $PROC_NR install || { exit 1; } + make --quiet -j $PROC_NR clean || { exit 1; } + cd .. +done + diff --git a/include/config.h b/include/config.h deleted file mode 100644 index 8a3182d..0000000 --- a/include/config.h +++ /dev/null @@ -1,156 +0,0 @@ -/* config.h. Generated from config.h.in by configure. */ -/* config.h.in. Generated from configure.ac by autoheader. */ - -/* Define to 1 if you have the header file. */ -#define HAVE_ARPA_INET_H 1 - -/* Whether we have clock_gettime */ -/* #undef HAVE_CLOCK_GETTIME */ - -/* Define to 1 if you have the header file. */ -#define HAVE_DLFCN_H 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_FUSE_H */ - -/* Whether we have getpwnam() */ -//#define HAVE_GETPWNAM 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_INTTYPES_H 1 - -/* Define to 1 if you have the `nsl' library (-lnsl). */ -/* #undef HAVE_LIBNSL */ - -/* Define to 1 if you have the `socket' library (-lsocket). */ -/* #undef HAVE_LIBSOCKET */ - -/* Define to 1 if you have the header file. */ -#define HAVE_MEMORY_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NETDB_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NETINET_IN_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NETINET_TCP_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_NET_IF_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_POLL_H 1 - -/* Whether sockaddr struct has sa_len */ -#define HAVE_SOCKADDR_LEN 1 - -/* Whether we have sockaddr_Storage */ -#define HAVE_SOCKADDR_STORAGE 1 - -/* Whether our sockets support SO_BINDTODEVICE */ -/* #undef HAVE_SO_BINDTODEVICE */ - -/* Define to 1 if you have the header file. */ -#define HAVE_STDINT_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STDLIB_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRINGS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_STRING_H 1 - -/* Define to 1 if `st_mtim.tv_nsec' is a member of `struct stat'. */ -#define HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYS_FILIO_H */ - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_IOCTL_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_SOCKET_H 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYS_SOCKIO_H */ - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_STATVFS_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_STAT_H 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYS_SYSMACROS_H */ - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_TIME_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_SYS_TYPES_H 1 - -/* Define to 1 if you have the header file. */ -/* #undef HAVE_SYS_VFS_H */ - -/* Whether we have talloc nad tevent support */ -/* #undef HAVE_TALLOC_TEVENT */ - -/* Define to 1 if you have the header file. */ -#define HAVE_UNISTD_H 1 - -/* Define to 1 if you have the header file. */ -#define HAVE_UTIME_H 1 - -/* Define to the sub-directory where libtool stores uninstalled libraries. */ -#define LT_OBJDIR ".libs/" - -/* Define to 1 if `major', `minor', and `makedev' are declared in . - */ -/* #undef MAJOR_IN_MKDEV */ - -/* Define to 1 if `major', `minor', and `makedev' are declared in - . */ -/* #undef MAJOR_IN_SYSMACROS */ - -/* Name of package */ -#define PACKAGE "libnfs" - -/* Define to the address where bug reports for this package should be sent. */ -#define PACKAGE_BUGREPORT "ronniesahlberg@gmail.com" - -/* Define to the full name of this package. */ -#define PACKAGE_NAME "libnfs" - -/* Define to the full name and version of this package. */ -#define PACKAGE_STRING "libnfs 4.0.0" - -/* Define to the one symbol short name of this package. */ -#define PACKAGE_TARNAME "libnfs" - -/* Define to the home page for this package. */ -#define PACKAGE_URL "" - -/* Define to the version of this package. */ -#define PACKAGE_VERSION "4.0.0" - -/* Define to 1 if you have the ANSI C header files. */ -#define STDC_HEADERS 1 - -/* Version number of package */ -#define VERSION "4.0.0" - -/* Enable large inode numbers on Mac OS X 10.5. */ -#ifndef _DARWIN_USE_64_BIT_INODE -# define _DARWIN_USE_64_BIT_INODE 1 -#endif - -/* Number of bits in a file offset, on hosts where this is settable. */ -/* #undef _FILE_OFFSET_BITS */ - -/* Define for large files, on AIX-style hosts. */ -/* #undef _LARGE_FILES */ diff --git a/include/crc32.h b/include/crc32.h deleted file mode 100644 index 5de49bc..0000000 --- a/include/crc32.h +++ /dev/null @@ -1,441 +0,0 @@ -/* crc32.h -- tables for rapid CRC calculation - * Generated automatically by crc32.c - */ - -local const unsigned long FAR crc_table[TBLS][256] = -{ - { - 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, - 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, - 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, - 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, - 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, - 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, - 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, - 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, - 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, - 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, - 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, - 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, - 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, - 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, - 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, - 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, - 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, - 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, - 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, - 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, - 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, - 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, - 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, - 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, - 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, - 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, - 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, - 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, - 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, - 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, - 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, - 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, - 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, - 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, - 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, - 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, - 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, - 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, - 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, - 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, - 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, - 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, - 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, - 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, - 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, - 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, - 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, - 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, - 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, - 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, - 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, - 0x2d02ef8dUL -#ifdef BYFOUR - }, - { - 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, - 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, - 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, - 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, - 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, - 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, - 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, - 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, - 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, - 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, - 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, - 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, - 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, - 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, - 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, - 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, - 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, - 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, - 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, - 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, - 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, - 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, - 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, - 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, - 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, - 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, - 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, - 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, - 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, - 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, - 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, - 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, - 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, - 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, - 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, - 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, - 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, - 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, - 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, - 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, - 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, - 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, - 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, - 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, - 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, - 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, - 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, - 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, - 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, - 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, - 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, - 0x9324fd72UL - }, - { - 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, - 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, - 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, - 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, - 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, - 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, - 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, - 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, - 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, - 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, - 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, - 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, - 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, - 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, - 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, - 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, - 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, - 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, - 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, - 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, - 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, - 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, - 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, - 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, - 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, - 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, - 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, - 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, - 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, - 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, - 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, - 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, - 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, - 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, - 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, - 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, - 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, - 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, - 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, - 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, - 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, - 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, - 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, - 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, - 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, - 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, - 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, - 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, - 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, - 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, - 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, - 0xbe9834edUL - }, - { - 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, - 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, - 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, - 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, - 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, - 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, - 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, - 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, - 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, - 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, - 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, - 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, - 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, - 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, - 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, - 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, - 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, - 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, - 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, - 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, - 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, - 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, - 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, - 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, - 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, - 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, - 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, - 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, - 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, - 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, - 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, - 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, - 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, - 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, - 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, - 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, - 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, - 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, - 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, - 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, - 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, - 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, - 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, - 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, - 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, - 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, - 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, - 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, - 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, - 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, - 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, - 0xde0506f1UL - }, - { - 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, - 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, - 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, - 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, - 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, - 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, - 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, - 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, - 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, - 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, - 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, - 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, - 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, - 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, - 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, - 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, - 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, - 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, - 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, - 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, - 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, - 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, - 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, - 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, - 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, - 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, - 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, - 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, - 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, - 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, - 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, - 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, - 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, - 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, - 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, - 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, - 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, - 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, - 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, - 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, - 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, - 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, - 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, - 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, - 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, - 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, - 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, - 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, - 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, - 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, - 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, - 0x8def022dUL - }, - { - 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, - 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, - 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, - 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, - 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, - 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, - 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, - 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, - 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, - 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, - 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, - 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, - 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, - 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, - 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, - 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, - 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, - 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, - 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, - 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, - 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, - 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, - 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, - 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, - 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, - 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, - 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, - 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, - 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, - 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, - 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, - 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, - 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, - 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, - 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, - 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, - 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, - 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, - 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, - 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, - 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, - 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, - 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, - 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, - 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, - 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, - 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, - 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, - 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, - 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, - 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, - 0x72fd2493UL - }, - { - 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, - 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, - 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, - 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, - 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, - 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, - 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, - 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, - 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, - 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, - 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, - 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, - 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, - 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, - 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, - 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, - 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, - 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, - 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, - 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, - 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, - 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, - 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, - 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, - 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, - 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, - 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, - 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, - 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, - 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, - 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, - 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, - 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, - 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, - 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, - 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, - 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, - 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, - 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, - 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, - 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, - 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, - 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, - 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, - 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, - 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, - 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, - 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, - 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, - 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, - 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, - 0xed3498beUL - }, - { - 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, - 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, - 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, - 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, - 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, - 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, - 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, - 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, - 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, - 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, - 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, - 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, - 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, - 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, - 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, - 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, - 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, - 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, - 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, - 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, - 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, - 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, - 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, - 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, - 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, - 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, - 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, - 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, - 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, - 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, - 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, - 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, - 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, - 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, - 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, - 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, - 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, - 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, - 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, - 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, - 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, - 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, - 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, - 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, - 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, - 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, - 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, - 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, - 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, - 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, - 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, - 0xf10605deUL -#endif - } -}; diff --git a/include/debugnet.h b/include/debugnet.h deleted file mode 100644 index ab006f1..0000000 --- a/include/debugnet.h +++ /dev/null @@ -1,44 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#ifndef _ORBIS_DEBUGNET_H_ -#define _ORBIS_DEBUGNET_H_ - -#ifdef __cplusplus -extern "C" { -#endif - -#define DEBUGNET_NONE 0 -#define DEBUGNET_INFO 1 -#define DEBUGNET_ERROR 2 -#define DEBUGNET_DEBUG 3 - -typedef struct debugNetConfiguration -{ - int debugnet_initialized; - int SocketFD; - int logLevel; -} debugNetConfiguration; - -int debugNetInit(char *serverIp, int port, int level); -int debugNetInitWithConf(debugNetConfiguration *conf); -debugNetConfiguration *debugNetGetConf(void); -int debugNetSetConf(debugNetConfiguration *conf); -void debugNetFinish(void); -void debugNetPrintf(int level, char* format, ...); -void debugNetSetLogLevel(int level); -int debugNetCreateConf(void); - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/deflate.h b/include/deflate.h deleted file mode 100644 index e9044c1..0000000 --- a/include/deflate.h +++ /dev/null @@ -1,342 +0,0 @@ -/* deflate.h -- internal compression state - * Copyright (C) 1995-2010 Jean-loup Gailly - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* @(#) $Id$ */ - -#ifndef DEFLATE_H -#define DEFLATE_H - -#include "zutil.h" - -/* define NO_GZIP when compiling if you want to disable gzip header and - trailer creation by deflate(). NO_GZIP would be used to avoid linking in - the crc code when it is not needed. For shared libraries, gzip encoding - should be left enabled. */ -#ifndef NO_GZIP -# define GZIP -#endif - -/* =========================================================================== - * Internal compression state. - */ - -#define LENGTH_CODES 29 -/* number of length codes, not counting the special END_BLOCK code */ - -#define LITERALS 256 -/* number of literal bytes 0..255 */ - -#define L_CODES (LITERALS+1+LENGTH_CODES) -/* number of Literal or Length codes, including the END_BLOCK code */ - -#define D_CODES 30 -/* number of distance codes */ - -#define BL_CODES 19 -/* number of codes used to transfer the bit lengths */ - -#define HEAP_SIZE (2*L_CODES+1) -/* maximum heap size */ - -#define MAX_BITS 15 -/* All codes must not exceed MAX_BITS bits */ - -#define INIT_STATE 42 -#define EXTRA_STATE 69 -#define NAME_STATE 73 -#define COMMENT_STATE 91 -#define HCRC_STATE 103 -#define BUSY_STATE 113 -#define FINISH_STATE 666 -/* Stream status */ - - -/* Data structure describing a single value and its code string. */ -typedef struct ct_data_s { - union { - ush freq; /* frequency count */ - ush code; /* bit string */ - } fc; - union { - ush dad; /* father node in Huffman tree */ - ush len; /* length of bit string */ - } dl; -} FAR ct_data; - -#define Freq fc.freq -#define Code fc.code -#define Dad dl.dad -#define Len dl.len - -typedef struct static_tree_desc_s static_tree_desc; - -typedef struct tree_desc_s { - ct_data *dyn_tree; /* the dynamic tree */ - int max_code; /* largest code with non zero frequency */ - static_tree_desc *stat_desc; /* the corresponding static tree */ -} FAR tree_desc; - -typedef ush Pos; -typedef Pos FAR Posf; -typedef unsigned IPos; - -/* A Pos is an index in the character window. We use short instead of int to - * save space in the various tables. IPos is used only for parameter passing. - */ - -typedef struct internal_state { - z_streamp strm; /* pointer back to this zlib stream */ - int status; /* as the name implies */ - Bytef *pending_buf; /* output still pending */ - ulg pending_buf_size; /* size of pending_buf */ - Bytef *pending_out; /* next pending byte to output to the stream */ - uInt pending; /* nb of bytes in the pending buffer */ - int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ - gz_headerp gzhead; /* gzip header information to write */ - uInt gzindex; /* where in extra, name, or comment */ - Byte method; /* STORED (for zip only) or DEFLATED */ - int last_flush; /* value of flush param for previous deflate call */ - - /* used by deflate.c: */ - - uInt w_size; /* LZ77 window size (32K by default) */ - uInt w_bits; /* log2(w_size) (8..16) */ - uInt w_mask; /* w_size - 1 */ - - Bytef *window; - /* Sliding window. Input bytes are read into the second half of the window, - * and move to the first half later to keep a dictionary of at least wSize - * bytes. With this organization, matches are limited to a distance of - * wSize-MAX_MATCH bytes, but this ensures that IO is always - * performed with a length multiple of the block size. Also, it limits - * the window size to 64K, which is quite useful on MSDOS. - * To do: use the user input buffer as sliding window. - */ - - ulg window_size; - /* Actual size of window: 2*wSize, except when the user input buffer - * is directly used as sliding window. - */ - - Posf *prev; - /* Link to older string with same hash index. To limit the size of this - * array to 64K, this link is maintained only for the last 32K strings. - * An index in this array is thus a window index modulo 32K. - */ - - Posf *head; /* Heads of the hash chains or NIL. */ - - uInt ins_h; /* hash index of string to be inserted */ - uInt hash_size; /* number of elements in hash table */ - uInt hash_bits; /* log2(hash_size) */ - uInt hash_mask; /* hash_size-1 */ - - uInt hash_shift; - /* Number of bits by which ins_h must be shifted at each input - * step. It must be such that after MIN_MATCH steps, the oldest - * byte no longer takes part in the hash key, that is: - * hash_shift * MIN_MATCH >= hash_bits - */ - - long block_start; - /* Window position at the beginning of the current output block. Gets - * negative when the window is moved backwards. - */ - - uInt match_length; /* length of best match */ - IPos prev_match; /* previous match */ - int match_available; /* set if previous match exists */ - uInt strstart; /* start of string to insert */ - uInt match_start; /* start of matching string */ - uInt lookahead; /* number of valid bytes ahead in window */ - - uInt prev_length; - /* Length of the best match at previous step. Matches not greater than this - * are discarded. This is used in the lazy match evaluation. - */ - - uInt max_chain_length; - /* To speed up deflation, hash chains are never searched beyond this - * length. A higher limit improves compression ratio but degrades the - * speed. - */ - - uInt max_lazy_match; - /* Attempt to find a better match only when the current match is strictly - * smaller than this value. This mechanism is used only for compression - * levels >= 4. - */ -# define max_insert_length max_lazy_match - /* Insert new strings in the hash table only if the match length is not - * greater than this length. This saves time but degrades compression. - * max_insert_length is used only for compression levels <= 3. - */ - - int level; /* compression level (1..9) */ - int strategy; /* favor or force Huffman coding*/ - - uInt good_match; - /* Use a faster search when the previous match is longer than this */ - - int nice_match; /* Stop searching when current match exceeds this */ - - /* used by trees.c: */ - /* Didn't use ct_data typedef below to supress compiler warning */ - struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ - struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ - struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ - - struct tree_desc_s l_desc; /* desc. for literal tree */ - struct tree_desc_s d_desc; /* desc. for distance tree */ - struct tree_desc_s bl_desc; /* desc. for bit length tree */ - - ush bl_count[MAX_BITS+1]; - /* number of codes at each bit length for an optimal tree */ - - int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ - int heap_len; /* number of elements in the heap */ - int heap_max; /* element of largest frequency */ - /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. - * The same heap array is used to build all trees. - */ - - uch depth[2*L_CODES+1]; - /* Depth of each subtree used as tie breaker for trees of equal frequency - */ - - uchf *l_buf; /* buffer for literals or lengths */ - - uInt lit_bufsize; - /* Size of match buffer for literals/lengths. There are 4 reasons for - * limiting lit_bufsize to 64K: - * - frequencies can be kept in 16 bit counters - * - if compression is not successful for the first block, all input - * data is still in the window so we can still emit a stored block even - * when input comes from standard input. (This can also be done for - * all blocks if lit_bufsize is not greater than 32K.) - * - if compression is not successful for a file smaller than 64K, we can - * even emit a stored file instead of a stored block (saving 5 bytes). - * This is applicable only for zip (not gzip or zlib). - * - creating new Huffman trees less frequently may not provide fast - * adaptation to changes in the input data statistics. (Take for - * example a binary file with poorly compressible code followed by - * a highly compressible string table.) Smaller buffer sizes give - * fast adaptation but have of course the overhead of transmitting - * trees more frequently. - * - I can't count above 4 - */ - - uInt last_lit; /* running index in l_buf */ - - ushf *d_buf; - /* Buffer for distances. To simplify the code, d_buf and l_buf have - * the same number of elements. To use different lengths, an extra flag - * array would be necessary. - */ - - ulg opt_len; /* bit length of current block with optimal trees */ - ulg static_len; /* bit length of current block with static trees */ - uInt matches; /* number of string matches in current block */ - int last_eob_len; /* bit length of EOB code for last block */ - -#ifdef DEBUG - ulg compressed_len; /* total bit length of compressed file mod 2^32 */ - ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ -#endif - - ush bi_buf; - /* Output buffer. bits are inserted starting at the bottom (least - * significant bits). - */ - int bi_valid; - /* Number of valid bits in bi_buf. All bits above the last valid bit - * are always zero. - */ - - ulg high_water; - /* High water mark offset in window for initialized bytes -- bytes above - * this are set to zero in order to avoid memory check warnings when - * longest match routines access bytes past the input. This is then - * updated to the new high water mark. - */ - -} FAR deflate_state; - -/* Output a byte on the stream. - * IN assertion: there is enough room in pending_buf. - */ -#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} - - -#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) -/* Minimum amount of lookahead, except at the end of the input file. - * See deflate.c for comments about the MIN_MATCH+1. - */ - -#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) -/* In order to simplify the code, particularly on 16 bit machines, match - * distances are limited to MAX_DIST instead of WSIZE. - */ - -#define WIN_INIT MAX_MATCH -/* Number of bytes after end of data in window to initialize in order to avoid - memory checker errors from longest match routines */ - - /* in trees.c */ -void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); -int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); -void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, - ulg stored_len, int last)); -void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); -void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, - ulg stored_len, int last)); - -#define d_code(dist) \ - ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) -/* Mapping from a distance to a distance code. dist is the distance - 1 and - * must not have side effects. _dist_code[256] and _dist_code[257] are never - * used. - */ - -#ifndef DEBUG -/* Inline versions of _tr_tally for speed: */ - -#if defined(GEN_TREES_H) || !defined(STDC) - extern uch ZLIB_INTERNAL _length_code[]; - extern uch ZLIB_INTERNAL _dist_code[]; -#else - extern const uch ZLIB_INTERNAL _length_code[]; - extern const uch ZLIB_INTERNAL _dist_code[]; -#endif - -# define _tr_tally_lit(s, c, flush) \ - { uch cc = (c); \ - s->d_buf[s->last_lit] = 0; \ - s->l_buf[s->last_lit++] = cc; \ - s->dyn_ltree[cc].Freq++; \ - flush = (s->last_lit == s->lit_bufsize-1); \ - } -# define _tr_tally_dist(s, distance, length, flush) \ - { uch len = (length); \ - ush dist = (distance); \ - s->d_buf[s->last_lit] = dist; \ - s->l_buf[s->last_lit++] = len; \ - dist--; \ - s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ - s->dyn_dtree[d_code(dist)].Freq++; \ - flush = (s->last_lit == s->lit_bufsize-1); \ - } -#else -# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) -# define _tr_tally_dist(s, distance, length, flush) \ - flush = _tr_tally(s, distance, length) -#endif - -#endif /* DEFLATE_H */ diff --git a/include/inffast.h b/include/inffast.h deleted file mode 100644 index e1e6db4..0000000 --- a/include/inffast.h +++ /dev/null @@ -1,11 +0,0 @@ -/* inffast.h -- header to use inffast.c - * Copyright (C) 1995-2003, 2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); diff --git a/include/inffixed.h b/include/inffixed.h deleted file mode 100644 index 423d5c5..0000000 --- a/include/inffixed.h +++ /dev/null @@ -1,94 +0,0 @@ - /* inffixed.h -- table for decoding fixed codes - * Generated automatically by makefixed(). - */ - - /* WARNING: this file should *not* be used by applications. It - is part of the implementation of the compression library and - is subject to change. Applications should only use zlib.h. - */ - - static const code lenfix[512] = { - {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, - {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, - {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, - {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, - {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, - {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, - {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, - {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, - {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, - {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, - {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, - {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, - {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, - {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, - {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, - {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, - {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, - {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, - {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, - {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, - {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, - {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, - {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, - {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, - {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, - {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, - {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, - {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, - {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, - {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, - {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, - {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, - {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, - {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, - {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, - {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, - {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, - {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, - {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, - {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, - {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, - {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, - {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, - {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, - {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, - {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, - {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, - {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, - {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, - {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, - {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, - {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, - {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, - {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, - {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, - {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, - {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, - {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, - {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, - {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, - {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, - {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, - {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, - {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, - {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, - {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, - {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, - {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, - {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, - {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, - {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, - {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, - {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, - {0,9,255} - }; - - static const code distfix[32] = { - {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, - {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, - {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, - {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, - {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, - {22,5,193},{64,5,0} - }; diff --git a/include/inflate.h b/include/inflate.h deleted file mode 100644 index a8ef428..0000000 --- a/include/inflate.h +++ /dev/null @@ -1,122 +0,0 @@ -/* inflate.h -- internal inflate state definition - * Copyright (C) 1995-2009 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* define NO_GZIP when compiling if you want to disable gzip header and - trailer decoding by inflate(). NO_GZIP would be used to avoid linking in - the crc code when it is not needed. For shared libraries, gzip decoding - should be left enabled. */ -#ifndef NO_GZIP -# define GUNZIP -#endif - -/* Possible inflate modes between inflate() calls */ -typedef enum { - HEAD, /* i: waiting for magic header */ - FLAGS, /* i: waiting for method and flags (gzip) */ - TIME, /* i: waiting for modification time (gzip) */ - OS, /* i: waiting for extra flags and operating system (gzip) */ - EXLEN, /* i: waiting for extra length (gzip) */ - EXTRA, /* i: waiting for extra bytes (gzip) */ - NAME, /* i: waiting for end of file name (gzip) */ - COMMENT, /* i: waiting for end of comment (gzip) */ - HCRC, /* i: waiting for header crc (gzip) */ - DICTID, /* i: waiting for dictionary check value */ - DICT, /* waiting for inflateSetDictionary() call */ - TYPE, /* i: waiting for type bits, including last-flag bit */ - TYPEDO, /* i: same, but skip check to exit inflate on new block */ - STORED, /* i: waiting for stored size (length and complement) */ - COPY_, /* i/o: same as COPY below, but only first time in */ - COPY, /* i/o: waiting for input or output to copy stored block */ - TABLE, /* i: waiting for dynamic block table lengths */ - LENLENS, /* i: waiting for code length code lengths */ - CODELENS, /* i: waiting for length/lit and distance code lengths */ - LEN_, /* i: same as LEN below, but only first time in */ - LEN, /* i: waiting for length/lit/eob code */ - LENEXT, /* i: waiting for length extra bits */ - DIST, /* i: waiting for distance code */ - DISTEXT, /* i: waiting for distance extra bits */ - MATCH, /* o: waiting for output space to copy string */ - LIT, /* o: waiting for output space to write literal */ - CHECK, /* i: waiting for 32-bit check value */ - LENGTH, /* i: waiting for 32-bit length (gzip) */ - DONE, /* finished check, done -- remain here until reset */ - BAD, /* got a data error -- remain here until reset */ - MEM, /* got an inflate() memory error -- remain here until reset */ - SYNC /* looking for synchronization bytes to restart inflate() */ -} inflate_mode; - -/* - State transitions between above modes - - - (most modes can go to BAD or MEM on error -- not shown for clarity) - - Process header: - HEAD -> (gzip) or (zlib) or (raw) - (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> - HCRC -> TYPE - (zlib) -> DICTID or TYPE - DICTID -> DICT -> TYPE - (raw) -> TYPEDO - Read deflate blocks: - TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK - STORED -> COPY_ -> COPY -> TYPE - TABLE -> LENLENS -> CODELENS -> LEN_ - LEN_ -> LEN - Read deflate codes in fixed or dynamic block: - LEN -> LENEXT or LIT or TYPE - LENEXT -> DIST -> DISTEXT -> MATCH -> LEN - LIT -> LEN - Process trailer: - CHECK -> LENGTH -> DONE - */ - -/* state maintained between inflate() calls. Approximately 10K bytes. */ -struct inflate_state { - inflate_mode mode; /* current inflate mode */ - int last; /* true if processing last block */ - int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ - int havedict; /* true if dictionary provided */ - int flags; /* gzip header method and flags (0 if zlib) */ - unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ - unsigned long check; /* protected copy of check value */ - unsigned long total; /* protected copy of output count */ - gz_headerp head; /* where to save gzip header information */ - /* sliding window */ - unsigned wbits; /* log base 2 of requested window size */ - unsigned wsize; /* window size or zero if not using window */ - unsigned whave; /* valid bytes in the window */ - unsigned wnext; /* window write index */ - unsigned char FAR *window; /* allocated sliding window, if needed */ - /* bit accumulator */ - unsigned long hold; /* input bit accumulator */ - unsigned bits; /* number of bits in "in" */ - /* for string and stored block copying */ - unsigned length; /* literal or length of data to copy */ - unsigned offset; /* distance back to copy string from */ - /* for table and code decoding */ - unsigned extra; /* extra bits needed */ - /* fixed and dynamic code tables */ - code const FAR *lencode; /* starting table for length/literal codes */ - code const FAR *distcode; /* starting table for distance codes */ - unsigned lenbits; /* index bits for lencode */ - unsigned distbits; /* index bits for distcode */ - /* dynamic table building */ - unsigned ncode; /* number of code length code lengths */ - unsigned nlen; /* number of length code lengths */ - unsigned ndist; /* number of distance code lengths */ - unsigned have; /* number of code lengths in lens[] */ - code FAR *next; /* next available space in codes[] */ - unsigned short lens[320]; /* temporary storage for code lengths */ - unsigned short work[288]; /* work area for code table building */ - code codes[ENOUGH]; /* space for code tables */ - int sane; /* if false, allow invalid distance too far */ - int back; /* bits back of last unprocessed length/lit */ - unsigned was; /* initial length of match */ -}; diff --git a/include/inftrees.h b/include/inftrees.h deleted file mode 100644 index a685d8c..0000000 --- a/include/inftrees.h +++ /dev/null @@ -1,62 +0,0 @@ -/* inftrees.h -- header to use inftrees.c - * Copyright (C) 1995-2005, 2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* Structure for decoding tables. Each entry provides either the - information needed to do the operation requested by the code that - indexed that table entry, or it provides a pointer to another - table that indexes more bits of the code. op indicates whether - the entry is a pointer to another table, a literal, a length or - distance, an end-of-block, or an invalid code. For a table - pointer, the low four bits of op is the number of index bits of - that table. For a length or distance, the low four bits of op - is the number of extra bits to get after the code. bits is - the number of bits in this code or part of the code to drop off - of the bit buffer. val is the actual byte to output in the case - of a literal, the base length or distance, or the offset from - the current table to the next table. Each entry is four bytes. */ -typedef struct { - unsigned char op; /* operation, extra bits, table bits */ - unsigned char bits; /* bits in this part of the code */ - unsigned short val; /* offset in table or code value */ -} code; - -/* op values as set by inflate_table(): - 00000000 - literal - 0000tttt - table link, tttt != 0 is the number of table index bits - 0001eeee - length or distance, eeee is the number of extra bits - 01100000 - end of block - 01000000 - invalid code - */ - -/* Maximum size of the dynamic table. The maximum number of code structures is - 1444, which is the sum of 852 for literal/length codes and 592 for distance - codes. These values were found by exhaustive searches using the program - examples/enough.c found in the zlib distribtution. The arguments to that - program are the number of symbols, the initial root table size, and the - maximum bit length of a code. "enough 286 9 15" for literal/length codes - returns returns 852, and "enough 30 6 15" for distance codes returns 592. - The initial root table size (9 or 6) is found in the fifth argument of the - inflate_table() calls in inflate.c and infback.c. If the root table size is - changed, then these maximum sizes would be need to be recalculated and - updated. */ -#define ENOUGH_LENS 852 -#define ENOUGH_DISTS 592 -#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) - -/* Type of code to build for inflate_table() */ -typedef enum { - CODES, - LENS, - DISTS -} codetype; - -int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, - unsigned codes, code FAR * FAR *table, - unsigned FAR *bits, unsigned short FAR *work)); diff --git a/include/kb.h b/include/kb.h deleted file mode 100644 index b58a66f..0000000 --- a/include/kb.h +++ /dev/null @@ -1,92 +0,0 @@ -#define KEY_A 0x04 // Keyboard a and A -#define KEY_B 0x05 // Keyboard b and B -#define KEY_C 0x06 // Keyboard c and C -#define KEY_D 0x07 // Keyboard d and D -#define KEY_E 0x08 // Keyboard e and E -#define KEY_F 0x09 // Keyboard f and F -#define KEY_G 0x0a // Keyboard g and G -#define KEY_H 0x0b // Keyboard h and H -#define KEY_I 0x0c // Keyboard i and I -#define KEY_J 0x0d // Keyboard j and J -#define KEY_K 0x0e // Keyboard k and K -#define KEY_L 0x0f // Keyboard l and L -#define KEY_M 0x10 // Keyboard m and M -#define KEY_N 0x11 // Keyboard n and N -#define KEY_O 0x12 // Keyboard o and O -#define KEY_P 0x13 // Keyboard p and P -#define KEY_Q 0x14 // Keyboard q and Q -#define KEY_R 0x15 // Keyboard r and R -#define KEY_S 0x16 // Keyboard s and S -#define KEY_T 0x17 // Keyboard t and T -#define KEY_U 0x18 // Keyboard u and U -#define KEY_V 0x19 // Keyboard v and V -#define KEY_W 0x1a // Keyboard w and W -#define KEY_X 0x1b // Keyboard x and X -#define KEY_Y 0x1c // Keyboard y and Y -#define KEY_Z 0x1d // Keyboard z and Z - -#define KEY_1 0x1e // Keyboard 1 and ! -#define KEY_2 0x1f // Keyboard 2 and @ -#define KEY_3 0x20 // Keyboard 3 and # -#define KEY_4 0x21 // Keyboard 4 and $ -#define KEY_5 0x22 // Keyboard 5 and % -#define KEY_6 0x23 // Keyboard 6 and ^ -#define KEY_7 0x24 // Keyboard 7 and & -#define KEY_8 0x25 // Keyboard 8 and * -#define KEY_9 0x26 // Keyboard 9 and ( -#define KEY_0 0x27 // Keyboard 0 and ) - -#define KEY_ENTER 0x28 // Keyboard Return (ENTER) -#define KEY_ESC 0x29 // Keyboard ESCAPE -#define KEY_BACKSPACE 0x2a // Keyboard DELETE (Backspace) -#define KEY_TAB 0x2b // Keyboard Tab -#define KEY_SPACE 0x2c // Keyboard Spacebar -#define KEY_MINUS 0x2d // Keyboard - and _ -#define KEY_EQUAL 0x2e // Keyboard = and + -#define KEY_LEFTBRACE 0x2f // Keyboard [ and { -#define KEY_RIGHTBRACE 0x30 // Keyboard ] and } -#define KEY_BACKSLASH 0x31 // Keyboard \ and | -#define KEY_HASHTILDE 0x32 // Keyboard Non-US # and ~ -#define KEY_SEMICOLON 0x33 // Keyboard ; and : -#define KEY_APOSTROPHE 0x34 // Keyboard ' and " -#define KEY_GRAVE 0x35 // Keyboard ` and ~ -#define KEY_COMMA 0x36 // Keyboard , and < -#define KEY_DOT 0x37 // Keyboard . and > -#define KEY_SLASH 0x38 // Keyboard / and ? -#define KEY_CAPSLOCK 0x39 // Keyboard Caps Lock - -#define KEY_F1 0x3a // Keyboard F1 -#define KEY_F2 0x3b // Keyboard F2 -#define KEY_F3 0x3c // Keyboard F3 -#define KEY_F4 0x3d // Keyboard F4 -#define KEY_F5 0x3e // Keyboard F5 -#define KEY_F6 0x3f // Keyboard F6 -#define KEY_F7 0x40 // Keyboard F7 -#define KEY_F8 0x41 // Keyboard F8 -#define KEY_F9 0x42 // Keyboard F9 -#define KEY_F10 0x43 // Keyboard F10 -#define KEY_F11 0x44 // Keyboard F11 -#define KEY_F12 0x45 // Keyboard F12 - -#define KEY_SYSRQ 0x46 // Keyboard Print Screen -#define KEY_SCROLLLOCK 0x47 // Keyboard Scroll Lock -#define KEY_PAUSE 0x48 // Keyboard Pause -#define KEY_INSERT 0x49 // Keyboard Insert -#define KEY_HOME 0x4a // Keyboard Home -#define KEY_PAGEUP 0x4b // Keyboard Page Up -#define KEY_DELETE 0x4c // Keyboard Delete Forward -#define KEY_END 0x4d // Keyboard End -#define KEY_PAGEDOWN 0x4e // Keyboard Page Down -#define KEY_RIGHT 0x4f // Keyboard Right Arrow -#define KEY_LEFT 0x50 // Keyboard Left Arrow -#define KEY_DOWN 0x51 // Keyboard Down Arrow -#define KEY_UP 0x52 // Keyboard Up Arrow -#define KEY_NONUS_BACKSLASH 0x0064 //non us keyboard -#define KEY_LEFTCONTROL 0x00E0 // Left Control -#define KEY_LEFTSHIFT 0x00E1 // Left Shift -#define KEY_LEFTALT 0x00E2 // Keypad Left Alt -#define KEY_LEFTGUI 0x00E3 // Keypad Left Gui -#define KEY_RIGHTCONTROL 0x00E4 // Keypad Right Control -#define KEY_RIGHTSHIFT 0x00E5 // Keypad Right Shift -#define KEY_RIGHTALT 0x00E6 // Keypad Right Alt -#define KEY_RIGHTGUI 0x00E7 // Keypad Right Gui diff --git a/include/libnfs-private.h b/include/libnfs-private.h deleted file mode 100644 index 692ffa1..0000000 --- a/include/libnfs-private.h +++ /dev/null @@ -1,570 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifndef _LIBNFS_PRIVATE_H_ -#define _LIBNFS_PRIVATE_H_ - - -#ifdef HAVE_CONFIG_H -#include "config.h" /* HAVE_SOCKADDR_STORAGE ? */ -#endif - -#ifndef WIN32 -#include /* struct sockaddr_storage */ -#endif - -#ifdef HAVE_NET_IF_H -#include -#endif - - - -#if defined(WIN32) && !defined(IFNAMSIZ) -#define IFNAMSIZ 255 -#endif - -#include "libnfs-zdr.h" -#include "libnfs-raw-nfs.h" -#include "libnfs-raw-nfs4.h" -#include -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef MIN -#define MIN(a, b) (((a) < (b)) ? (a) : (b)) -#endif -#ifndef MAX -#define MAX(a, b) (((a) > (b)) ? (a) : (b)) -#endif - -#if !defined(HAVE_SOCKADDR_STORAGE) && !defined(WIN32) -/* - * RFC 2553: protocol-independent placeholder for socket addresses - */ -#define _SS_MAXSIZE 128 -#define _SS_ALIGNSIZE (sizeof(double)) -#define _SS_PAD1SIZE (_SS_ALIGNSIZE - sizeof(unsigned char) * 2) -#define _SS_PAD2SIZE (_SS_MAXSIZE - sizeof(unsigned char) * 2 - \ - _SS_PAD1SIZE - _SS_ALIGNSIZE) - -struct sockaddr_storage { -#ifdef HAVE_SOCKADDR_LEN - unsigned char ss_len; /* address length */ - unsigned char ss_family; /* address family */ -#else - unsigned short ss_family; -#endif - char __ss_pad1[_SS_PAD1SIZE]; - double __ss_align; /* force desired structure storage alignment */ - char __ss_pad2[_SS_PAD2SIZE]; -}; -#endif - - -struct rpc_fragment { - struct rpc_fragment *next; - uint32_t size; - char *data; -}; - -#define RPC_CONTEXT_MAGIC 0xc6e46435 -#define RPC_PARAM_UNDEFINED -1 - -/* - * Queue is singly-linked but we hold on to the tail - */ -struct rpc_queue { - struct rpc_pdu *head, *tail; -}; - -#define HASHES 1024 -#define NFS_RA_TIMEOUT 5 -#define NFS_MAX_XFER_SIZE (1024 * 1024) -#define ZDR_ENCODE_OVERHEAD 1024 -#define ZDR_ENCODEBUF_MINSIZE 4096 - -struct rpc_endpoint { - struct rpc_endpoint *next; - int program; - int version; - struct service_proc *procs; - int num_procs; -}; - -struct rpc_context { - uint32_t magic; - int fd; - int old_fd; - int is_connected; - int is_nonblocking; - - char *error_string; - - rpc_cb connect_cb; - void *connect_data; - - struct AUTH *auth; - uint32_t xid; - - struct rpc_queue outqueue; - struct sockaddr_storage udp_src; - struct rpc_queue waitpdu[HASHES]; - uint32_t waitpdu_len; - - uint32_t inpos; - char rm_buf[4]; - char *inbuf; - - /* special fields for UDP, which can sometimes be BROADCASTed */ - int is_udp; - struct sockaddr_storage udp_dest; - int is_broadcast; - - /* track the address we connect to so we can auto-reconnect on session failure */ - struct sockaddr_storage s; - int auto_reconnect; - int num_retries; - - /* fragment reassembly */ - struct rpc_fragment *fragments; - - /* parameters passable via URL */ - int tcp_syncnt; - int uid; - int gid; - uint32_t readahead; - uint32_t pagecache; - uint32_t pagecache_ttl; - int debug; - int timeout; - char ifname[IFNAMSIZ]; - - /* Is a server context ? */ - int is_server_context; - struct rpc_endpoint *endpoints; -}; - -struct rpc_pdu { - struct rpc_pdu *next; - - uint32_t xid; - ZDR zdr; - - uint32_t written; - struct rpc_data outdata; - - rpc_cb cb; - void *private_data; - - /* function to decode the zdr reply data and buffer to decode into */ - zdrproc_t zdr_decode_fn; - caddr_t zdr_decode_buf; - uint32_t zdr_decode_bufsize; - -#define PDU_DISCARD_AFTER_SENDING 0x00000001 - uint32_t flags; - - uint64_t timeout; -}; - -void rpc_reset_queue(struct rpc_queue *q); -void rpc_enqueue(struct rpc_queue *q, struct rpc_pdu *pdu); -void rpc_return_to_queue(struct rpc_queue *q, struct rpc_pdu *pdu); -unsigned int rpc_hash_xid(uint32_t xid); - -struct rpc_pdu *rpc_allocate_pdu(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_bufsize); -struct rpc_pdu *rpc_allocate_pdu2(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_bufsize, size_t alloc_hint); -void rpc_free_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu); -int rpc_queue_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu); -uint32_t rpc_get_pdu_size(char *buf); -int rpc_process_pdu(struct rpc_context *rpc, char *buf, int size); -void rpc_error_all_pdus(struct rpc_context *rpc, const char *error); - -void rpc_set_error(struct rpc_context *rpc, const char *error_string, ...) -#ifdef __GNUC__ - __attribute__((format(printf, 2, 3))) -#endif -; - -void nfs_set_error(struct nfs_context *nfs, char *error_string, ...) -#ifdef __GNUC__ - __attribute__((format(printf, 2, 3))) -#endif -; - -#define RPC_LOG(rpc, level, format, ...) \ - do { \ - if (level <= rpc->debug) { \ - debugNetPrintf(2, "libnfs:%d " format "\n", level, ## __VA_ARGS__); \ - } \ - } while (0) - -const char *nfs_get_server(struct nfs_context *nfs); -const char *nfs_get_export(struct nfs_context *nfs); - -/* we dont want to expose UDP to normal applications/users this is private to libnfs to use exclusively for broadcast RPC */ -int rpc_bind_udp(struct rpc_context *rpc, char *addr, int port); -int rpc_set_udp_destination(struct rpc_context *rpc, char *addr, int port, int is_broadcast); -struct rpc_context *rpc_init_udp_context(void); -struct sockaddr *rpc_get_recv_sockaddr(struct rpc_context *rpc); - -void rpc_set_autoreconnect(struct rpc_context *rpc, int num_retries); - -void rpc_set_interface(struct rpc_context *rpc, const char *ifname); - -void rpc_set_tcp_syncnt(struct rpc_context *rpc, int v); -void rpc_set_pagecache(struct rpc_context *rpc, uint32_t v); -void rpc_set_pagecache_ttl(struct rpc_context *rpc, uint32_t v); -void rpc_set_readahead(struct rpc_context *rpc, uint32_t v); -void rpc_set_debug(struct rpc_context *rpc, int level); -void rpc_set_timeout(struct rpc_context *rpc, int timeout); -int rpc_get_timeout(struct rpc_context *rpc); -int rpc_add_fragment(struct rpc_context *rpc, char *data, uint32_t size); -void rpc_free_all_fragments(struct rpc_context *rpc); -int rpc_is_udp_socket(struct rpc_context *rpc); -uint64_t rpc_current_time(void); - -void *zdr_malloc(ZDR *zdrs, uint32_t size); - - -struct nfs_cb_data; -void free_nfs_cb_data(struct nfs_cb_data *data); - -struct nfs_specdata { - uint32_t specdata1; - uint32_t specdata2; -}; -struct nfs_time { - uint32_t seconds; - uint32_t nseconds; -}; -struct nfs_attr { - uint32_t type; - uint32_t mode; - uint32_t uid; - uint32_t gid; - uint32_t nlink; - uint64_t size; - uint64_t used; - uint64_t fsid; - struct nfs_specdata rdev; - struct nfs_time atime; - struct nfs_time mtime; - struct nfs_time ctime; -}; - -struct nfs_fh { - int len; - char *val; -}; - -struct nfs_context { - struct rpc_context *rpc; - char *server; - char *export; - struct nfs_fh rootfh; - uint64_t readmax; - uint64_t writemax; - char *cwd; - int dircache_enabled; - int auto_reconnect; - struct nfsdir *dircache; - uint16_t mask; - - int auto_traverse_mounts; - struct nested_mounts *nested_mounts; - - int version; - int nfsport; - int mountport; - - /* NFSv4 specific fields */ - verifier4 verifier; - char *client_name; - uint64_t clientid; - verifier4 setclientid_confirm; - uint32_t seqid; - int has_lock_owner; -}; - -typedef int (*continue_func)(struct nfs_context *nfs, struct nfs_attr *attr, - struct nfs_cb_data *data); - -struct nfs_cb_data { - struct nfs_context *nfs; - struct nfsfh *nfsfh; - char *saved_path, *path; - int link_count, no_follow; - - nfs_cb cb; - void *private_data; - - continue_func continue_cb; - void *continue_data; - void (*free_continue_data)(void *); - uint64_t continue_int; - - struct nfs_fh fh; - - /* for multi-read/write calls. */ - int error; - int cancel; - int oom; - int num_calls; - size_t count, org_count; - uint64_t offset, max_offset, org_offset; - char *buffer; - int not_my_buffer; - const char *usrbuf; - int update_pos; -}; - -struct nested_mounts { - struct nested_mounts *next; - char *path; - struct nfs_fh fh; - struct nfs_attr attr; -}; - -#define MAX_DIR_CACHE 128 -#define MAX_LINK_COUNT 40 - -struct nfsdir { - struct nfs_fh fh; - struct nfs_attr attr; - struct nfsdir *next; - - struct nfsdirent *entries; - struct nfsdirent *current; -}; - -struct nfs_readahead { - uint64_t fh_offset; - uint32_t cur_ra; -}; - -struct nfs_pagecache_entry { - char buf[NFS_BLKSIZE]; - uint64_t offset; - time_t ts; -}; - -struct nfs_pagecache { - struct nfs_pagecache_entry *entries; - uint32_t num_entries; - time_t ttl; -}; - -struct stateid { - uint32_t seqid; - char other[12]; -}; - -struct nfsfh { - struct nfs_fh fh; - int is_sync; - int is_append; - int is_dirty; - uint64_t offset; - struct nfs_readahead ra; - struct nfs_pagecache pagecache; - - /* NFSv4 */ - struct stateid stateid; - /* locking */ - uint32_t lock_seqid; - struct stateid lock_stateid; -}; - -const struct nfs_fh *nfs_get_rootfh(struct nfs_context *nfs); - -int nfs_normalize_path(struct nfs_context *nfs, char *path); -void nfs_free_nfsdir(struct nfsdir *nfsdir); -void nfs_free_nfsfh(struct nfsfh *nfsfh); - -void nfs_dircache_add(struct nfs_context *nfs, struct nfsdir *nfsdir); -struct nfsdir *nfs_dircache_find(struct nfs_context *nfs, struct nfs_fh *fh); -void nfs_dircache_drop(struct nfs_context *nfs, struct nfs_fh *fh); - -char * nfs_pagecache_get(struct nfs_pagecache *pagecache, uint64_t offset); -void nfs_pagecache_put(struct nfs_pagecache *pagecache, uint64_t offset, - const char *buf, size_t len); - -int nfs3_access_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data); -int nfs3_access2_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_chdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -int nfs3_chmod_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int mode, nfs_cb cb, - void *private_data); -int nfs3_chown_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int uid, int gid, - nfs_cb cb, void *private_data); -int nfs3_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs3_create_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data); -int nfs3_fchmod_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode, - nfs_cb cb, void *private_data); -int nfs3_fchown_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, - int gid, nfs_cb cb, void *private_data); -int nfs3_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs3_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs3_fsync_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs3_ftruncate_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t length, nfs_cb cb, void *private_data); -int nfs3_link_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -int nfs3_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - int64_t offset, int whence, nfs_cb cb, void *private_data); -int nfs3_mkdir2_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data); -int nfs3_mknod_async(struct nfs_context *nfs, const char *path, int mode, - int dev, nfs_cb cb, void *private_data); -int nfs3_mount_async(struct nfs_context *nfs, const char *server, - const char *export, nfs_cb cb, void *private_data); -int nfs3_open_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data); -int nfs3_opendir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_pread_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, nfs_cb cb, - void *private_data, int update_pos); -int nfs3_pwrite_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, const char *buf, - nfs_cb cb, void *private_data, int update_pos); -int nfs3_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_rename_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -int nfs3_rmdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_stat_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -int nfs3_stat64_async(struct nfs_context *nfs, const char *path, - int no_follow, nfs_cb cb, void *private_data); -int nfs3_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_statvfs64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_symlink_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -int nfs3_truncate_async(struct nfs_context *nfs, const char *path, - uint64_t length, nfs_cb cb, void *private_data); -int nfs3_umount_async(struct nfs_context *nfs, nfs_cb cb, void *private_data); -int nfs3_unlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs3_utime_async(struct nfs_context *nfs, const char *path, - struct utimbuf *times, nfs_cb cb, void *private_data); -int nfs3_utimes_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, struct timeval *times, - nfs_cb cb, void *private_data); -int nfs3_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t count, const void *buf, nfs_cb cb, - void *private_data); - -int nfs4_access_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data); -int nfs4_access2_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_chdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -int nfs4_chmod_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int mode, nfs_cb cb, - void *private_data); -int nfs4_chown_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int uid, int gid, - nfs_cb cb, void *private_data); -int nfs4_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs4_create_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data); -int nfs4_fchmod_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode, - nfs_cb cb, void *private_data); -int nfs4_fchown_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, - int gid, nfs_cb cb, void *private_data); -int nfs4_fcntl_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_fcntl_op cmd, void *arg, - nfs_cb cb, void *private_data); -int nfs4_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs4_fsync_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data); -int nfs4_ftruncate_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t length, nfs_cb cb, void *private_data); -int nfs4_link_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -int nfs4_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - int64_t offset, int whence, nfs_cb cb, void *private_data); -int nfs4_lockf_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_lock_op op, uint64_t count, - nfs_cb cb, void *private_data); -int nfs4_mkdir2_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data); -int nfs4_mknod_async(struct nfs_context *nfs, const char *path, int mode, - int dev, nfs_cb cb, void *private_data); -int nfs4_mount_async(struct nfs_context *nfs, const char *server, - const char *export, nfs_cb cb, void *private_data); -int nfs4_open_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data); -int nfs4_opendir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_pread_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, nfs_cb cb, - void *private_data, int update_pos); -int nfs4_pwrite_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, const char *buf, - nfs_cb cb, void *private_data, int update_pos); -int nfs4_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_rename_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -int nfs4_rmdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_stat64_async(struct nfs_context *nfs, const char *path, - int no_follow, nfs_cb cb, void *private_data); -int nfs4_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_statvfs64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_symlink_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -int nfs4_truncate_async(struct nfs_context *nfs, const char *path, - uint64_t length, nfs_cb cb, void *private_data); -int nfs4_unlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -int nfs4_utime_async(struct nfs_context *nfs, const char *path, - struct utimbuf *times, nfs_cb cb, void *private_data); -int nfs4_utimes_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, struct timeval *times, - nfs_cb cb, void *private_data); -int nfs4_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t count, const void *buf, nfs_cb cb, - void *private_data); - -#ifdef __cplusplus -} -#endif - -#endif /* !_LIBNFS_PRIVATE_H_ */ diff --git a/include/modplayer.h b/include/modplayer.h deleted file mode 100644 index 2b31308..0000000 --- a/include/modplayer.h +++ /dev/null @@ -1,60 +0,0 @@ -// modplayer.h: headers for psp modplayer code -// -// All public functions for modplayer -// -////////////////////////////////////////////////////////////////////// -#ifndef _MODPLAYER_GENERAL_H -#define _MODPLAYER_GENERAL_H - -#ifdef __cplusplus -extern "C" { -#endif - -static int modplayint_channel; -typedef void (*fd_initFunc) (int); -typedef int (*fd_loadFunc) (char *); -typedef int (*fd_playFunc) (void); -typedef void (*fd_pauseFunc) (void); -typedef int (*fd_stopFunc) (void); -typedef void (*fd_endFunc) (void); -typedef void (*fd_tickFunc) (void); -typedef void (*fd_timeFunc) (char *); -typedef int (*fd_EOSFunc) (void); -/* Define printf, just to make typing easier */ -//#define printf pspDebugScreenPrintf -typedef struct { - fd_initFunc init; - fd_loadFunc load; - fd_playFunc play; - fd_pauseFunc pause; - fd_stopFunc stop; - fd_endFunc end; - fd_tickFunc tick; - fd_timeFunc time; - fd_EOSFunc eos; // have we reached end of playback.. ie for non-loop mode - char extension[200]; // 4 byte entries. eg mp3\0 or \0\0\0\0 to terminate list -} codecStubs; - - - - -// Function prototypes for public functions - void MODsetStubs(codecStubs * stubs); - -// Function prototypes for private functions - void Mod_Init(int channel); - int Mod_Play(); - void Mod_Pause(); - int Mod_Stop(); - void Mod_End(); - int Mod_Load(char *filename); - void Mod_Tick(); - void Mod_Close(); - int Mod_EndOfStream(); - - void Mod_GetTimeString(char *); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/include/modplayeri.h b/include/modplayeri.h deleted file mode 100644 index 5c2113a..0000000 --- a/include/modplayeri.h +++ /dev/null @@ -1,94 +0,0 @@ -// modplayeri.h: headers for psp modplayer code -// -// NOTE: this is only for including in modplayer.c, use 'modplayer.h' -// for including the public funcs in your own code -// -////////////////////////////////////////////////////////////////////// - -#ifndef _MODPLAYER_H -#define _MODPLAYER_H - -#ifdef __cplusplus -extern "C" { -#endif - -// These next few lines determine how the sound will be mixed. -// Set PLAYBACK_FREQ to whatever you want. -#define PLAYBACK_FREQ 48000 - -// OVERSAMPLE can be commented out to disable that function -// (takes up less CPU time, but doesnt sound as good). -#define OVERSAMPLE - -// The NoteData structure stores the information for a single note and/or effect. - typedef struct { - int sample_num; // The sample number (ie "instrument") to play, 1->31 - int period_index; // This effectively stores the frequency to play the - // sample, although it's actually an index into - // PeriodTable. - int effect; // Contains the effect code - int effect_parms; // Used to store control parameters for the - // various effects - } NoteData; - -// RowData stores all the information for a single row. If there are 8 tracks -// in this mod then this structure will be filled with 8 elements of NoteData, -// one for each track. - typedef struct { - int numnotes; - NoteData *note; - } RowData; - -// Pattern contains all the information for a single pattern. -// It is filled with 64 elements of type RowData. - typedef struct { - int numrows; - RowData *row; - } Pattern; - -// The Sample structure is used to store all the information for a single -// sample, or "instrument". Most of the member's should be self-explanatory. -// The "data" member is an array of bytes containing the raw sample data -// in 8-bit signed format. - typedef struct { - char szName[100]; - int nLength, nFineTune, nVolume, nLoopStart, nLoopLength, nLoopEnd; - int data_length; - char *data; - } Sample; - - -// TrackData is used to store ongoing information about a particular track. - typedef struct { - int sample; // The current sample being played (0 for none) - int pos; // The current playback position in the sample, - // stored in fixed-point format - int period_index; // Which note to play, stored as an index into the - // PeriodTable array - int period; // The period number that period_index corresponds to - // (needed for various effects) - float freq; // This is the actual frequency used to do the mixing. - // It's a combination of the value calculated from the - // period member and an "adjustment" made by various effects. - int volume; // Volume that this track is to be mixed at - int mixvol; // This is the actual volume used to do the mixing. - // It's a combination of the volume member and an - // "adjustment" made by various effects. - int porta; // Used by the porta effect, this stores the note we're - // porta-ing (?) to - int portasp; // The speed at which to porta - int vibspe; // Vibrato speed - int vibdep; // Vibrato depth - int tremspe; // Tremolo speed - int tremdep; // Tremolo depth - int panval; // Pan value....this player doesn't actually do panning, - // so this member is ignored (but included for future use) - int sinepos; // These next two values are pointers to the sine table. - // They're used to do - int sineneg; // various effects. - } TrackData; - -#ifdef __cplusplus -} -#endif -#endif diff --git a/include/modtables.h b/include/modtables.h deleted file mode 100644 index ae9a274..0000000 --- a/include/modtables.h +++ /dev/null @@ -1,508 +0,0 @@ -// Here's the lookup table containing the Amiga period values for each note. -// This is ripped right out of Protracker. -#define NUMNOTES 296 -int PeriodTable[NUMNOTES] = { // The sorted amiga table. - 907, 900, 894, 887, 881, 875, 868, 862, // Finetune -8 to -1 - 856, 850, 844, 838, 832, 826, 820, 814, // C-1 to finetune +7 - 808, 802, 796, 791, 785, 779, 774, 768, // C#1 to finetune +7 - 762, 757, 752, 746, 741, 736, 730, 725, // D-1 to finetune +7 - 720, 715, 709, 704, 699, 694, 689, 684, // D#1 to finetune +7 - 678, 675, 670, 665, 660, 655, 651, 646, // E-1 to finetune +7 - 640, 636, 632, 628, 623, 619, 614, 610, // F-1 to finetune +7 - 604, 601, 597, 592, 588, 584, 580, 575, // F#1 to finetune +7 - 570, 567, 563, 559, 555, 551, 547, 543, // G-1 to finetune +7 - 538, 535, 532, 528, 524, 520, 516, 513, // G#1 to finetune +7 - 508, 505, 502, 498, 494, 491, 487, 484, // A-1 to finetune +7 - 480, 477, 474, 470, 467, 463, 460, 457, // A#1 to finetune +7 - 453, 450, 447, 444, 441, 437, 434, 431, // B-1 to finetune +7 - 428, 425, 422, 419, 416, 413, 410, 407, // C-2 to finetune +7 // Middle C - 404, 401, 398, 395, 392, 390, 387, 384, // C#2 to finetune +7 - 381, 379, 376, 373, 370, 368, 365, 363, // D-2 to finetune +7 - 360, 357, 355, 352, 350, 347, 345, 342, // D#2 to finetune +7 - 339, 337, 335, 332, 330, 328, 325, 323, // E-2 to finetune +7 - 320, 318, 316, 314, 312, 309, 307, 305, // F-2 to finetune +7 - 302, 300, 298, 296, 294, 292, 290, 288, // F#2 to finetune +7 - 285, 284, 282, 280, 278, 276, 274, 272, // G-2 to finetune +7 - 269, 268, 266, 264, 262, 260, 258, 256, // G#2 to finetune +7 - 254, 253, 251, 249, 247, 245, 244, 242, // A-2 to finetune +7 - 240, 238, 237, 235, 233, 232, 230, 228, // A#2 to finetune +7 - 226, 225, 223, 222, 220, 219, 217, 216, // B-2 to finetune +7 - 214, 212, 211, 209, 208, 206, 205, 203, // C-3 to finetune +7 - 202, 200, 199, 198, 196, 195, 193, 192, // C#3 to finetune +7 - 190, 189, 188, 187, 185, 184, 183, 181, // D-3 to finetune +7 - 180, 179, 177, 176, 175, 174, 172, 171, // D#3 to finetune +7 - 170, 169, 167, 166, 165, 164, 163, 161, // E-3 to finetune +7 - 160, 159, 158, 157, 156, 155, 154, 152, // F-3 to finetune +7 - 151, 150, 149, 148, 147, 146, 145, 144, // F#3 to finetune +7 - 143, 142, 141, 140, 139, 138, 137, 136, // G-3 to finetune +7 - 135, 134, 133, 132, 131, 130, 129, 128, // G#3 to finetune +7 - 127, 126, 125, 125, 123, 123, 122, 121, // A-3 to finetune +7 - 120, 119, 118, 118, 117, 116, 115, 114, // A#3 to finetune +7 - 113, 113, 112, 111, 110, 109, 109, 108, // B-3 to finetune +7 -}; - -// This is compensate for the fact that the 'log' function in ps2lib -// seems broken and doesnt return the right values, so this table -// was a quick and easy fix and probably quicker too -int Period_Log_Lookup[] = { - 0, 943, 847, 791, 751, 720, 695, 673, 655, 638, 624, 611, 599, 587, - 577, 568, 559, - 550, 542, 535, 528, 521, 515, 508, 503, 497, 491, 486, 481, 476, 472, - 467, 463, 458, - 454, 450, 446, 443, 439, 435, 432, 428, 425, 422, 419, 415, 412, 409, - 407, 404, 401, - 398, 395, 393, 390, 388, 385, 383, 380, 378, 376, 373, 371, 369, 367, - 365, 362, 360, - 358, 356, 354, 352, 350, 348, 347, 345, 343, 341, 339, 338, 336, 334, - 332, 331, 329, - 327, 326, 324, 323, 321, 319, 318, 316, 315, 313, 312, 311, 309, 308, - 306, 305, 303, - 302, 301, 299, 298, 297, 295, 294, 293, 292, 290, 289, 288, 287, 286, - 284, 283, 282, - 281, 280, 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 267, 266, - 265, 264, 263, - 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 252, 251, 250, - 249, 248, 247, - 246, 245, 244, 243, 242, 242, 241, 240, 239, 238, 237, 236, 236, 235, - 234, 233, 232, - 231, 231, 230, 229, 228, 227, 227, 226, 225, 224, 223, 223, 222, 221, - 220, 220, 219, - 218, 217, 217, 216, 215, 215, 214, 213, 212, 212, 211, 210, 210, 209, - 208, 207, 207, - 206, 205, 205, 204, 203, 203, 202, 201, 201, 200, 199, 199, 198, 198, - 197, 196, 196, - 195, 194, 194, 193, 193, 192, 191, 191, 190, 190, 189, 188, 188, 187, - 187, 186, 185, - 185, 184, 184, 183, 182, 182, 181, 181, 180, 180, 179, 179, 178, 177, - 177, 176, 176, - 175, 175, 174, 174, 173, 173, 172, 171, 171, 170, 170, 169, 169, 168, - 168, 167, 167, - 166, 166, 165, 165, 164, 164, 163, 163, 162, 162, 161, 161, 160, 160, - 159, 159, 158, - 158, 157, 157, 156, 156, 156, 155, 155, 154, 154, 153, 153, 152, 152, - 151, 151, 150, - 150, 150, 149, 149, 148, 148, 147, 147, 146, 146, 146, 145, 145, 144, - 144, 143, 143, - 142, 142, 142, 141, 141, 140, 140, 140, 139, 139, 138, 138, 137, 137, - 137, 136, 136, - 135, 135, 135, 134, 134, 133, 133, 133, 132, 132, 131, 131, 131, 130, - 130, 129, 129, - 129, 128, 128, 127, 127, 127, 126, 126, 126, 125, 125, 124, 124, 124, - 123, 123, 123, - 122, 122, 121, 121, 121, 120, 120, 120, 119, 119, 119, 118, 118, 117, - 117, 117, 116, - 116, 116, 115, 115, 115, 114, 114, 114, 113, 113, 113, 112, 112, 111, - 111, 111, 110, - 110, 110, 109, 109, 109, 108, 108, 108, 107, 107, 107, 106, 106, 106, - 105, 105, 105, - 104, 104, 104, 103, 103, 103, 103, 102, 102, 102, 101, 101, 101, 100, - 100, 100, 99, - 99, 99, 98, 98, 98, 97, 97, 97, 97, 96, 96, 96, 95, 95, 95, 94, 94, - 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 91, 91, 90, 90, 90, 89, 89, - 89, 88, 88, 88, 88, 87, 87, 87, 86, 86, 86, 86, 85, 85, 85, 84, 84, - 84, 84, 83, 83, 83, 83, 82, 82, 82, 81, 81, 81, 81, 80, 80, 80, 79, - 79, 79, 79, 78, 78, 78, 78, 77, 77, 77, 77, 76, 76, 76, 75, 75, 75, - 75, 74, 74, 74, 74, 73, 73, 73, 73, 72, 72, 72, 72, 71, 71, 71, 71, - 70, 70, 70, 70, 69, 69, 69, 69, 68, 68, 68, 68, 67, 67, 67, 67, 66, - 66, 66, 66, 65, 65, 65, 65, 64, 64, 64, 64, 63, 63, 63, 63, 62, 62, - 62, 62, 61, 61, 61, 61, 60, 60, 60, 60, 60, 59, 59, 59, 59, 58, 58, - 58, 58, 57, 57, 57, 57, 56, 56, 56, 56, 56, 55, 55, 55, 55, 54, 54, - 54, 54, 54, 53, 53, 53, 53, 52, 52, 52, 52, 52, 51, 51, 51, 51, 50, - 50, 50, 50, 50, 49, 49, 49, 49, 48, 48, 48, 48, 48, 47, 47, 47, 47, - 46, 46, 46, 46, 46, 45, 45, 45, 45, 45, 44, 44, 44, 44, 44, 43, 43, - 43, 43, 42, 42, 42, 42, 42, 41, 41, 41, 41, 41, 40, 40, 40, 40, 40, - 39, 39, 39, 39, 39, 38, 38, 38, 38, 38, 37, 37, 37, 37, 37, 36, 36, - 36, 36, 36, 35, 35, 35, 35, 35, 34, 34, 34, 34, 34, 33, 33, 33, 33, - 33, 32, 32, 32, 32, 32, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, - 29, 29, 29, 29, 29, 28, 28, 28, 28, 28, 27, 27, 27, 27, 27, 27, 26, - 26, 26, 26, 26, 25, 25, 25, 25, 25, 25, 24, 24, 24, 24, 24, 23, 23, - 23, 23, 23, 23, 22, 22, 22, 22, 22, 21, 21, 21, 21, 21, 21, 20, 20, - 20, 20, 20, 19, 19, 19, 19, 19, 19, 18, 18, 18, 18, 18, 18, 17, 17, - 17, 17, 17, 17, 16, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 14, 14, - 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 11, - 11, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, - 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, - 6, 6, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 3, 3, - 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, - -1, -1, -1, -2, -2, -2, -2, -2, -2, -3, -3, -3, -3, -3, -3, -3, -4, - -4, -4, -4, -4, -4, -4, -5, -5, -5, -5, -5, -5, -5, -6, -6, -6, -6, - -6, -6, -7, -7, -7, -7, -7, -7, -7, -8, -8, -8, -8, -8, -8, -8, -9, - -9, -9, -9, -9, -9, -9, -10, -10, -10, -10, -10, -10, -10, -11, -11, - -11, -11, - -11, -11, -11, -12, -12, -12, -12, -12, -12, -12, -12, -13, -13, -13, - -13, -13, -13, - -13, -14, -14, -14, -14, -14, -14, -14, -15, -15, -15, -15, -15, -15, - -15, -16, -16, - -16, -16, -16, -16, -16, -16, -17, -17, -17, -17, -17, -17, -17, -18, - -18, -18, -18, - -18, -18, -18, -18, -19, -19, -19, -19, -19, -19, -19, -20, -20, -20, - -20, -20, -20, - -20, -20, -21, -21, -21, -21, -21, -21, -21, -21, -22, -22, -22, -22, - -22, -22, -22, - -23, -23, -23, -23, -23, -23, -23, -23, -24, -24, -24, -24, -24, -24, - -24, -24, -25, - -25, -25, -25, -25, -25, -25, -25, -26, -26, -26, -26, -26, -26, -26, - -26, -27, -27, - -27, -27, -27, -27, -27, -27, -28, -28, -28, -28, -28, -28, -28, -28, - -29, -29, -29, - -29, -29, -29, -29, -29, -30, -30, -30, -30, -30, -30, -30, -30, -31, - -31, -31, -31, - -31, -31, -31, -31, -32, -32, -32, -32, -32, -32, -32, -32, -33, -33, - -33, -33, -33, - -33, -33, -33, -33, -34, -34, -34, -34, -34, -34, -34, -34, -35, -35, - -35, -35, -35, - -35, -35, -35, -35, -36, -36, -36, -36, -36, -36, -36, -36, -37, -37, - -37, -37, -37, - -37, -37, -37, -37, -38, -38, -38, -38, -38, -38, -38, -38, -39, -39, - -39, -39, -39, - -39, -39, -39, -39, -40, -40, -40, -40, -40, -40, -40, -40, -40, -41, - -41, -41, -41, - -41, -41, -41, -41, -41, -42, -42, -42, -42, -42, -42, -42, -42, -42, - -43, -43, -43, - -43, -43, -43, -43, -43, -43, -44, -44, -44, -44, -44, -44, -44, -44, - -44, -45, -45, - -45, -45, -45, -45, -45, -45, -45, -46, -46, -46, -46, -46, -46, -46, - -46, -46, -47, - -47, -47, -47, -47, -47, -47, -47, -47, -48, -48, -48, -48, -48, -48, - -48, -48, -48, - -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, -50, -50, -50, -50, - -50, -50, -50, - -50, -50, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -52, -52, - -52, -52, -52, - -52, -52, -52, -52, -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, - -54, -54, -54, - -54, -54, -54, -54, -54, -54, -54, -55, -55, -55, -55, -55, -55, -55, - -55, -55, -56, - -56, -56, -56, -56, -56, -56, -56, -56, -56, -57, -57, -57, -57, -57, - -57, -57, -57, - -57, -57, -58, -58, -58, -58, -58, -58, -58, -58, -58, -58, -59, -59, - -59, -59, -59, - -59, -59, -59, -59, -59, -60, -60, -60, -60, -60, -60, -60, -60, -60, - -60, -61, -61, - -61, -61, -61, -61, -61, -61, -61, -61, -62, -62, -62, -62, -62, -62, - -62, -62, -62, - -62, -62, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -64, -64, - -64, -64, -64, - -64, -64, -64, -64, -64, -64, -65, -65, -65, -65, -65, -65, -65, -65, - -65, -65, -66, - -66, -66, -66, -66, -66, -66, -66, -66, -66, -66, -67, -67, -67, -67, - -67, -67, -67, - -67, -67, -67, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, -68, - -69, -69, -69, - -69, -69, -69, -69, -69, -69, -69, -69, -70, -70, -70, -70, -70, -70, - -70, -70, -70, - -70, -70, -71, -71, -71, -71, -71, -71, -71, -71, -71, -71, -71, -72, - -72, -72, -72, - -72, -72, -72, -72, -72, -72, -72, -73, -73, -73, -73, -73, -73, -73, - -73, -73, -73, - -73, -74, -74, -74, -74, -74, -74, -74, -74, -74, -74, -74, -75, -75, - -75, -75, -75, - -75, -75, -75, -75, -75, -75, -76, -76, -76, -76, -76, -76, -76, -76, - -76, -76, -76, - -76, -77, -77, -77, -77, -77, -77, -77, -77, -77, -77, -77, -78, -78, - -78, -78, -78, - -78, -78, -78, -78, -78, -78, -78, -79, -79, -79, -79, -79, -79, -79, - -79, -79, -79, - -79, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -81, - -81, -81, -81, - -81, -81, -81, -81, -81, -81, -81, -81, -82, -82, -82, -82, -82, -82, - -82, -82, -82, - -82, -82, -82, -83, -83, -83, -83, -83, -83, -83, -83, -83, -83, -83, - -83, -84, -84, - -84, -84, -84, -84, -84, -84, -84, -84, -84, -84, -85, -85, -85, -85, - -85, -85, -85, - -85, -85, -85, -85, -85, -86, -86, -86, -86, -86, -86, -86, -86, -86, - -86, -86, -86, - -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, -88, - -88, -88, -88, - -88, -88, -88, -88, -88, -88, -88, -88, -89, -89, -89, -89, -89, -89, - -89, -89, -89, - -89, -89, -89, -90, -90, -90, -90, -90, -90, -90, -90, -90, -90, -90, - -90, -90, -91, - -91, -91, -91, -91, -91, -91, -91, -91, -91, -91, -91, -91, -92, -92, - -92, -92, -92, - -92, -92, -92, -92, -92, -92, -92, -93, -93, -93, -93, -93, -93, -93, - -93, -93, -93, - -93, -93, -93, -94, -94, -94, -94, -94, -94, -94, -94, -94, -94, -94, - -94, -94, -95, - -95, -95, -95, -95, -95, -95, -95, -95, -95, -95, -95, -95, -96, -96, - -96, -96, -96, - -96, -96, -96, -96, -96, -96, -96, -96, -97, -97, -97, -97, -97, -97, - -97, -97, -97, - -97, -97, -97, -97, -97, -98, -98, -98, -98, -98, -98, -98, -98, -98, - -98, -98, -98, - -98, -99, -99, -99, -99, -99, -99, -99, -99, -99, -99, -99, -99, -99, - -100, -100, -100, - -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -100, -101, - -101, -101, -101, -101, -101, - -101, -101, -101, -101, -101, -101, -101, -101, -102, -102, -102, -102, - -102, -102, -102, -102, -102, - -102, -102, -102, -102, -103, -103, -103, -103, -103, -103, -103, -103, - -103, -103, -103, -103, -103, - -103, -104, -104, -104, -104, -104, -104, -104, -104, -104, -104, -104, - -104, -104, -104, -105, -105, - -105, -105, -105, -105, -105, -105, -105, -105, -105, -105, -105, -105, - -106, -106, -106, -106, -106, - -106, -106, -106, -106, -106, -106, -106, -106, -106, -107, -107, -107, - -107, -107, -107, -107, -107, - -107, -107, -107, -107, -107, -107, -108, -108, -108, -108, -108, -108, - -108, -108, -108, -108, -108, - -108, -108, -108, -108, -109, -109, -109, -109, -109, -109, -109, -109, - -109, -109, -109, -109, -109, - -109, -110, -110, -110, -110, -110, -110, -110, -110, -110, -110, -110, - -110, -110, -110, -110, -111, - -111, -111, -111, -111, -111, -111, -111, -111, -111, -111, -111, -111, - -111, -112, -112, -112, -112, - -112, -112, -112, -112, -112, -112, -112, -112, -112, -112, -112, -113, - -113, -113, -113, -113, -113, - -113, -113, -113, -113, -113, -113, -113, -113, -113, -114, -114, -114, - -114, -114, -114, -114, -114, - -114, -114, -114, -114, -114, -114, -114, -115, -115, -115, -115, -115, - -115, -115, -115, -115, -115, - -115, -115, -115, -115, -115, -116, -116, -116, -116, -116, -116, -116, - -116, -116, -116, -116, -116, - -116, -116, -116, -117, -117, -117, -117, -117, -117, -117, -117, -117, - -117, -117, -117, -117, -117, - -117, -117, -118, -118, -118, -118, -118, -118, -118, -118, -118, -118, - -118, -118, -118, -118, -118, - -119, -119, -119, -119, -119, -119, -119, -119, -119, -119, -119, -119, - -119, -119, -119, -120, -120, - -120, -120, -120, -120, -120, -120, -120, -120, -120, -120, -120, -120, - -120, -120, -121, -121, -121, - -121, -121, -121, -121, -121, -121, -121, -121, -121, -121, -121, -121, - -121, -122, -122, -122, -122, - -122, -122, -122, -122, -122, -122, -122, -122, -122, -122, -122, -122, - -123, -123, -123, -123, -123, - -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, -123, -124, - -124, -124, -124, -124, -124, - -124, -124, -124, -124, -124, -124, -124, -124, -124, -124, -125, -125, - -125, -125, -125, -125, -125, - -125, -125, -125, -125, -125, -125, -125, -125, -125, -126, -126, -126, - -126, -126, -126, -126, -126, - -126, -126, -126, -126, -126, -126, -126, -126, -127, -127, -127, -127, - -127, -127, -127, -127, -127, - -127, -127, -127, -127, -127, -127, -127, -127, -128, -128, -128, -128, - -128, -128, -128, -128, -128, - -128, -128, -128, -128, -128, -128, -128, -129, -129, -129, -129, -129, - -129, -129, -129, -129, -129, - -129, -129, -129, -129, -129, -129, -129, -130, -130, -130, -130, -130, - -130, -130, -130, -130, -130, - -130, -130, -130, -130, -130, -130, -130, -131, -131, -131, -131, -131, - -131, -131, -131, -131, -131, - -131, -131, -131, -131, -131, -131, -131, -132, -132, -132, -132, -132, - -132, -132, -132, -132, -132, - -132, -132, -132, -132, -132, -132, -132, -133, -133, -133, -133, -133, - -133, -133, -133, -133, -133, - -133, -133, -133, -133, -133, -133, -133, -134, -134, -134, -134, -134, - -134, -134, -134, -134, -134, - -134, -134, -134, -134, -134, -134, -134, -135, -135, -135, -135, -135, - -135, -135, -135, -135, -135, - -135, -135, -135, -135, -135, -135, -135, -135, -136, -136, -136, -136, - -136, -136, -136, -136, -136, - -136, -136, -136, -136, -136, -136, -136, -136, -137, -137, -137, -137, - -137, -137, -137, -137, -137, - -137, -137, -137, -137, -137, -137, -137, -137, -137, -138, -138, -138, - -138, -138, -138, -138, -138, - -138, -138, -138, -138, -138, -138, -138, -138, -138, -138, -139, -139, - -139, -139, -139, -139, -139, - -139, -139, -139, -139, -139, -139, -139, -139, -139, -139, -139, -140, - -140, -140, -140, -140, -140, - -140, -140, -140, -140, -140, -140, -140, -140, -140, -140, -140, -140, - -141, -141, -141, -141, -141, - -141, -141, -141, -141, -141, -141, -141, -141, -141, -141, -141, -141, - -141, -142, -142, -142, -142, - -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, -142, - -142, -142, -143, -143, -143, - -143, -143, -143, -143, -143, -143, -143, -143, -143, -143, -143, -143, - -143, -143, -143, -143, -144, - -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, -144, - -144, -144, -144, -144, -144, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, - -145, -145, -146, -146, -146, -146, -146, -146, -146, -146, -146, -146, - -146, -146, -146, -146, -146, - -146, -146, -146, -146, -147, -147, -147, -147, -147, -147, -147, -147, - -147, -147, -147, -147, -147, - -147, -147, -147, -147, -147, -147, -148, -148, -148, -148, -148, -148, - -148, -148, -148, -148, -148, - -148, -148, -148, -148, -148, -148, -148, -148, -149, -149, -149, -149, - -149, -149, -149, -149, -149, - -149, -149, -149, -149, -149, -149, -149, -149, -149, -149, -150, -150, - -150, -150, -150, -150, -150, - -150, -150, -150, -150, -150, -150, -150, -150, -150, -150, -150, -150, - -150, -151, -151, -151, -151, - -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, -151, - -151, -151, -151, -152, -152, - -152, -152, -152, -152, -152, -152, -152, -152, -152, -152, -152, -152, - -152, -152, -152, -152, -152, - -152, -153, -153, -153, -153, -153, -153, -153, -153, -153, -153, -153, - -153, -153, -153, -153, -153, - -153, -153, -153, -153, -154, -154, -154, -154, -154, -154, -154, -154, - -154, -154, -154, -154, -154, - -154, -154, -154, -154, -154, -154, -154, -155, -155, -155, -155, -155, - -155, -155, -155, -155, -155, - -155, -155, -155, -155, -155, -155, -155, -155, -155, -155, -156, -156, - -156, -156, -156, -156, -156, - -156, -156, -156, -156, -156, -156, -156, -156, -156, -156, -156, -156, - -156, -157, -157, -157, -157, - -157, -157, -157, -157, -157, -157, -157, -157, -157, -157, -157, -157, - -157, -157, -157, -157, -158, - -158, -158, -158, -158, -158, -158, -158, -158, -158, -158, -158, -158, - -158, -158, -158, -158, -158, - -158, -158, -158, -159, -159, -159, -159, -159, -159, -159, -159, -159, - -159, -159, -159, -159, -159, - -159, -159, -159, -159, -159, -159, -159, -160, -160, -160, -160, -160, - -160, -160, -160, -160, -160, - -160, -160, -160, -160, -160, -160, -160, -160, -160, -160, -160, -161, - -161, -161, -161, -161, -161, - -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, -161, - -161, -161, -161, -162, -162, - -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, -162, - -162, -162, -162, -162, -162, - -162, -162, -163, -163, -163, -163, -163, -163, -163, -163, -163, -163, - -163, -163, -163, -163, -163, - -163, -163, -163, -163, -163, -163, -164, -164, -164, -164, -164, -164, - -164, -164, -164, -164, -164, - -164, -164, -164, -164, -164, -164, -164, -164, -164, -164, -164, -165, - -165, -165, -165, -165, -165, - -165, -165, -165, -165, -165, -165, -165, -165, -165, -165, -165, -165, - -165, -165, -165, -166, -166, - -166, -166, -166, -166, -166, -166, -166, -166, -166, -166, -166, -166, - -166, -166, -166, -166, -166, - -166, -166, -166, -167, -167, -167, -167, -167, -167, -167, -167, -167, - -167, -167, -167, -167, -167, - -167, -167, -167, -167, -167, -167, -167, -167, -168, -168, -168, -168, - -168, -168, -168, -168, -168, - -168, -168, -168, -168, -168, -168, -168, -168, -168, -168, -168, -168, - -168, -169, -169, -169, -169, - -169, -169, -169, -169, -169, -169, -169, -169, -169, -169, -169, -169, - -169, -169, -169, -169, -169, - -169, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, -170, - -170, -170, -170, -170, -170, - -170, -170, -170, -170, -170, -170, -170, -171, -171, -171, -171, -171, - -171, -171, -171, -171, -171, - -171, -171, -171, -171, -171, -171, -171, -171, -171, -171, -171, -171, - -172, -172, -172, -172, -172, - -172, -172, -172, -172, -172, -172, -172, -172, -172, -172, -172, -172, - -172, -172, -172, -172, -172, - -172, -173, -173, -173, -173, -173, -173, -173, -173, -173, -173, -173, - -173, -173, -173, -173, -173, - -173, -173, -173, -173, -173, -173, -173, -174, -174, -174, -174, -174, - -174, -174, -174, -174, -174, - -174, -174, -174, -174, -174, -174, -174, -174, -174, -174, -174, -174, - -174, -175, -175, -175, -175, - -175, -175, -175, -175, -175, -175, -175, -175, -175, -175, -175, -175, - -175, -175, -175, -175, -175, - -175, -175, -176, -176, -176, -176, -176, -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, - -176, -176, -176, -176, -176, -176, -176, -176, -176, -177, -177, -177, - -177, -177, -177, -177, -177, - -177, -177, -177, -177, -177, -177, -177, -177, -177, -177, -177, -177, - -177, -177, -177, -178, -178, - -178, -178, -178, -178, -178, -178, -178, -178, -178, -178, -178, -178, - -178, -178, -178, -178, -178, - -178, -178, -178, -178, -178, -179, -179, -179, -179, -179, -179, -179, - -179, -179, -179, -179, -179, - -179, -179, -179, -179, -179, -179, -179, -179, -179, -179, -179, -179, - -180, -180, -180, -180, -180, - -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, -180, - -180, -180, -180, -180, -180, - -180, -180, -181, -181, -181, -181, -181, -181, -181, -181, -181, -181, - -181, -181, -181, -181, -181, - -181, -181, -181, -181, -181, -181, -181, -181, -181, -182, -182, -182, - -182, -182, -182, -182, -182, - -182, -182, -182, -182, -182, -182, -182, -182, -182, -182, -182, -182, - -182, -182, -182, -182, -182, - -183, -183, -183, -183, -183, -183, -183, -183, -183, -183, -183, -183, - -183, -183, -183, -183, -183, - -183, -183, -183, -183, -183, -183, -183, -183, -184, -184, -184, -184, - -184, -184, -184, -184, -184, - -184, -184, -184, -184, -184, -184, -184, -184, -184, -184, -184, -184, - -184, -184, -184, -185, -185, - -185, -185, -185, -185, -185, -185, -185, -185, -185, -185, -185, -185, - -185, -185, -185, -185, -185, - -185, -185, -185, -185, -185, -185, -186, -186, -186, -186, -186, -186, - -186, -186, -186, -186, -186, - -186, -186, -186, -186, -186, -186, -186, -186, -186, -186, -186, -186, - -186, -186, -187, -187, -187, - -187, -187, -187, -187, -187, -187, -187, -187, -187, -187, -187, -187, - -187, -187, -187, -187, -187, - -187, -187, -187, -187, -187, -187, -188, -188, -188, -188, -188, -188, - -188, -188, -188, -188, -188, - -188, -188, -188, -188, -188, -188, -188, -188, -188, -188, -188, -188, - -188, -188, -189, -189, -189, - -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, - -189, -189, -189, -189, -189, - -189, -189, -189, -189, -189, -189, -190, -190, -190, -190, -190, -190, - -190, -190, -190, -190, -190, - -190, -190, -190, -190, -190, -190, -190, -190, -190, -190, -190, -190, - -190, -190, -190, -191, -191, - -191, -191, -191, -191, -191, -191, -191, -191, -191, -191, -191, -191, - -191, -191, -191, -191, -191, - -191, -191, -191, -191, -191, -191, -191, -192, -192, -192, -192, -192, - -192, -192, -192, -192, -192, - -192, -192, -192, -192, -192, -192, -192, -192, -192, -192, -192, -192, - -192, -192, -192, -192, -193, - -193, -193, -193, -193, -193, -193, -193, -193, -193, -193, -193, -193, - -193, -193, -193, -193, -193, - -193, -193, -193, -193, -193, -193, -193, -193, -193, -194, -194, -194, - -194, -194, -194, -194, -194, - -194, -194, -194, -194, -194, -194, -194, -194, -194, -194, -194, -194, - -194, -194, -194, -194, -194, - -194, -194, -195, -195, -195, -195, -195, -195, -195, -195, -195, -195, - -195, -195, -195, -195, -195, - -195, -195, -195, -195, -195, -195, -195, -195, -195, -195, -195, -196, - -196, -196, -196, -196, -196, - -196, -196, -196, -196, -196, -196, -196, -196, -196, -196, -196, -196, - -196, -196, -196, -196, -196, - -196, -196, -196, -196, -197, -197, -197, -197, -197, -197, -197, -197, - -197, -197, -197, -197, -197, - -197, -197, -197, -197, -197, -197, -197, -197, -197, -197, -197, -197, - -197, -197, -197, -198, -198, - -198, -198, -198, -198, -198, -198, -198, -198, -198, -198, -198, -198, - -198, -198, -198, -198, -198, - -198, -198, -198, -198, -198, -198, -198, -198, -199, -199, -199, -199, - -199, -199, -199, -199, -199, - -199, -199, -199, -199, -199, -199, -199, -199, -199, -199, -199, -199, - -199, -199, -199, -199, -199, - -199, -199, -200, -200, -200, -200, -200, -200, -200, -200, -200, -200, - -200, -200, -200, -200, -200, - -200, -200, -200, -200, -200, -200, -200, -200, -200, -200, -200, -200, - -200, -201, -201, -201, -201, - -201, -201, -201, -201, -201, -201, -201, -201, -201, -201, -201, -201, - -201, -201, -201, -201, -201, - -201, -201, -201, -201, -201, -201, -201, -202, -202, -202, -202, -202, - -202, -202, -202, -202, -202, - -202, -202, -202, -202, -202, -202, -202, -202, -202, -202, -202, -202, - -202, -202, -202, -202, -202, - -202, -203, -203, -203, -203, -203, -203, -203, -203, -203, -203, -203, - -203, -203, -203, -203, -203, - -203, -203, -203, -203, -203, -203, -203, -203, -203, -203, -203, -203, - -204, -204, -204, -204, -204, - -204, -204, -204, -204, -204, -204, -204, -204, -204, -204, -204, -204, - -204, -204, -204, -204, -204, - -204, -204, -204, -204, -204, -204, -204, -205, -205, -205, -205, -205, - -205, -205, -205, -205, -205, - -205, -205, -205, -205, -205, -205, -205, -205, -205, -205, -205, -205, - -205, -205, -205, -205, -205, - -205, -205, -206, -206, -206, -206, -206, -206, -206, -206, -206, -206, - -206, -206, -206, -206, -206, - -206, -206, -206, -206, -206, -206, -206, -206, -206, -206, -206, -206, - -206, -206, -207, -207, -207, - -207, -207, -207, -207, -207, -207, -207, -207, -207, -207, -207, -207, - -207, -207, -207, -207, -207, - -207, -207, -207, -207, -207, -207, -207, -207, -207, -208, -208, -208, - -208, -208, -208, -208, -208, - -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, -208, - -208, -208, -208, -}; - - -// This table is for vibrato and contains half a sine wave. -unsigned char sintab[32] = { - 0, 24, 49, 74, 97, 120, 141, 161, - 180, 197, 212, 224, 235, 244, 250, 253, - 255, 253, 250, 244, 235, 224, 212, 197, - 180, 161, 141, 120, 97, 74, 49, 24 -}; diff --git a/include/nfsc/libnfs-raw-mount.h b/include/nfsc/libnfs-raw-mount.h deleted file mode 100644 index 23ca6ba..0000000 --- a/include/nfsc/libnfs-raw-mount.h +++ /dev/null @@ -1,279 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _MOUNT_H_RPCGEN -#define _MOUNT_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define MNTPATHLEN 1024 -#define MNTNAMLEN 255 -#define FHSIZE3 64 - -typedef struct { - u_int fhandle3_len; - char *fhandle3_val; -} fhandle3; - -typedef char *dirpath; - -typedef char *name; - -enum mountstat3 { - MNT3_OK = 0, - MNT3ERR_PERM = 1, - MNT3ERR_NOENT = 2, - MNT3ERR_IO = 5, - MNT3ERR_ACCES = 13, - MNT3ERR_NOTDIR = 20, - MNT3ERR_INVAL = 22, - MNT3ERR_NAMETOOLONG = 63, - MNT3ERR_NOTSUPP = 10004, - MNT3ERR_SERVERFAULT = 10006, -}; -typedef enum mountstat3 mountstat3; - -typedef struct mountbody *mountlist; - -struct mountbody { - name ml_hostname; - dirpath ml_directory; - mountlist ml_next; -}; -typedef struct mountbody mountbody; - -typedef struct groupnode *groups; - -struct groupnode { - name gr_name; - groups gr_next; -}; -typedef struct groupnode groupnode; - -typedef struct exportnode *exports; - -struct exportnode { - dirpath ex_dir; - groups ex_groups; - exports ex_next; -}; -typedef struct exportnode exportnode; - -struct mountres3_ok { - fhandle3 fhandle; - struct { - u_int auth_flavors_len; - int *auth_flavors_val; - } auth_flavors; -}; -typedef struct mountres3_ok mountres3_ok; - -struct mountres3 { - mountstat3 fhs_status; - union { - mountres3_ok mountinfo; - } mountres3_u; -}; -typedef struct mountres3 mountres3; - -enum mountstat1 { - MNT1_OK = 0, - MNT1ERR_PERM = 1, - MNT1ERR_NOENT = 2, - MNT1ERR_IO = 5, - MNT1ERR_ACCES = 13, - MNT1ERR_NOTDIR = 20, - MNT1ERR_INVAL = 22, - MNT1ERR_NAMETOOLONG = 63, - MNT1ERR_NOTSUPP = 10004, - MNT1ERR_SERVERFAULT = 10006, -}; -typedef enum mountstat1 mountstat1; -#define FHSIZE 32 - -typedef char fhandle1[FHSIZE]; - -struct mountres1_ok { - fhandle1 fhandle; -}; -typedef struct mountres1_ok mountres1_ok; - -struct mountres1 { - mountstat1 fhs_status; - union { - mountres1_ok mountinfo; - } mountres1_u; -}; -typedef struct mountres1 mountres1; - -#define MOUNT_PROGRAM 100005 -#define MOUNT_V1 1 - -#if defined(__STDC__) || defined(__cplusplus) -#define MOUNT1_NULL 0 -extern void * mount1_null_1(void *, void *); -extern void * mount1_null_1_svc(void *, struct svc_req *); -#define MOUNT1_MNT 1 -extern mountres1 * mount1_mnt_1(dirpath *, void *); -extern mountres1 * mount1_mnt_1_svc(dirpath *, struct svc_req *); -#define MOUNT1_DUMP 2 -extern mountlist * mount1_dump_1(void *, void *); -extern mountlist * mount1_dump_1_svc(void *, struct svc_req *); -#define MOUNT1_UMNT 3 -extern void * mount1_umnt_1(dirpath *, void *); -extern void * mount1_umnt_1_svc(dirpath *, struct svc_req *); -#define MOUNT1_UMNTALL 4 -extern void * mount1_umntall_1(void *, void *); -extern void * mount1_umntall_1_svc(void *, struct svc_req *); -#define MOUNT1_EXPORT 5 -extern exports * mount1_export_1(void *, void *); -extern exports * mount1_export_1_svc(void *, struct svc_req *); -extern int mount_program_1_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define MOUNT1_NULL 0 -extern void * mount1_null_1(); -extern void * mount1_null_1_svc(); -#define MOUNT1_MNT 1 -extern mountres1 * mount1_mnt_1(); -extern mountres1 * mount1_mnt_1_svc(); -#define MOUNT1_DUMP 2 -extern mountlist * mount1_dump_1(); -extern mountlist * mount1_dump_1_svc(); -#define MOUNT1_UMNT 3 -extern void * mount1_umnt_1(); -extern void * mount1_umnt_1_svc(); -#define MOUNT1_UMNTALL 4 -extern void * mount1_umntall_1(); -extern void * mount1_umntall_1_svc(); -#define MOUNT1_EXPORT 5 -extern exports * mount1_export_1(); -extern exports * mount1_export_1_svc(); -extern int mount_program_1_freeresult (); -#endif /* K&R C */ -#define MOUNT_V3 3 - -#if defined(__STDC__) || defined(__cplusplus) -#define MOUNT3_NULL 0 -extern void * mount3_null_3(void *, void *); -extern void * mount3_null_3_svc(void *, struct svc_req *); -#define MOUNT3_MNT 1 -extern mountres3 * mount3_mnt_3(dirpath *, void *); -extern mountres3 * mount3_mnt_3_svc(dirpath *, struct svc_req *); -#define MOUNT3_DUMP 2 -extern mountlist * mount3_dump_3(void *, void *); -extern mountlist * mount3_dump_3_svc(void *, struct svc_req *); -#define MOUNT3_UMNT 3 -extern void * mount3_umnt_3(dirpath *, void *); -extern void * mount3_umnt_3_svc(dirpath *, struct svc_req *); -#define MOUNT3_UMNTALL 4 -extern void * mount3_umntall_3(void *, void *); -extern void * mount3_umntall_3_svc(void *, struct svc_req *); -#define MOUNT3_EXPORT 5 -extern exports * mount3_export_3(void *, void *); -extern exports * mount3_export_3_svc(void *, struct svc_req *); -extern int mount_program_3_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define MOUNT3_NULL 0 -extern void * mount3_null_3(); -extern void * mount3_null_3_svc(); -#define MOUNT3_MNT 1 -extern mountres3 * mount3_mnt_3(); -extern mountres3 * mount3_mnt_3_svc(); -#define MOUNT3_DUMP 2 -extern mountlist * mount3_dump_3(); -extern mountlist * mount3_dump_3_svc(); -#define MOUNT3_UMNT 3 -extern void * mount3_umnt_3(); -extern void * mount3_umnt_3_svc(); -#define MOUNT3_UMNTALL 4 -extern void * mount3_umntall_3(); -extern void * mount3_umntall_3_svc(); -#define MOUNT3_EXPORT 5 -extern exports * mount3_export_3(); -extern exports * mount3_export_3_svc(); -extern int mount_program_3_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_fhandle3 (ZDR *, fhandle3*); -extern uint32_t zdr_dirpath (ZDR *, dirpath*); -extern uint32_t zdr_name (ZDR *, name*); -extern uint32_t zdr_mountstat3 (ZDR *, mountstat3*); -extern uint32_t zdr_mountlist (ZDR *, mountlist*); -extern uint32_t zdr_mountbody (ZDR *, mountbody*); -extern uint32_t zdr_groups (ZDR *, groups*); -extern uint32_t zdr_groupnode (ZDR *, groupnode*); -extern uint32_t zdr_exports (ZDR *, exports*); -extern uint32_t zdr_exportnode (ZDR *, exportnode*); -extern uint32_t zdr_mountres3_ok (ZDR *, mountres3_ok*); -extern uint32_t zdr_mountres3 (ZDR *, mountres3*); -extern uint32_t zdr_mountstat1 (ZDR *, mountstat1*); -extern uint32_t zdr_fhandle1 (ZDR *, fhandle1); -extern uint32_t zdr_mountres1_ok (ZDR *, mountres1_ok*); -extern uint32_t zdr_mountres1 (ZDR *, mountres1*); - -#else /* K&R C */ -extern uint32_t zdr_fhandle3 (); -extern uint32_t zdr_dirpath (); -extern uint32_t zdr_name (); -extern uint32_t zdr_mountstat3 (); -extern uint32_t zdr_mountlist (); -extern uint32_t zdr_mountbody (); -extern uint32_t zdr_groups (); -extern uint32_t zdr_groupnode (); -extern uint32_t zdr_exports (); -extern uint32_t zdr_exportnode (); -extern uint32_t zdr_mountres3_ok (); -extern uint32_t zdr_mountres3 (); -extern uint32_t zdr_mountstat1 (); -extern uint32_t zdr_fhandle1 (); -extern uint32_t zdr_mountres1_ok (); -extern uint32_t zdr_mountres1 (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_MOUNT_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw-nfs.h b/include/nfsc/libnfs-raw-nfs.h deleted file mode 100644 index a3b60f5..0000000 --- a/include/nfsc/libnfs-raw-nfs.h +++ /dev/null @@ -1,2012 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NFS_H_RPCGEN -#define _NFS_H_RPCGEN -#include - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define NFS3_FHSIZE 64 -#define NFS3_WRITEVERFSIZE 8 -#define NFS3_CREATEVERFSIZE 8 -#define NFS3_COOKIEVERFSIZE 8 - - - -typedef char cookieverf3[NFS3_COOKIEVERFSIZE]; - -typedef uint64_t cookie3; - -struct nfs_fh3 { - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct nfs_fh3 nfs_fh3; - -typedef char *filename3; - -struct diropargs3 { - nfs_fh3 dir; - filename3 name; -}; -typedef struct diropargs3 diropargs3; - -enum ftype3 { - NF3REG = 1, - NF3DIR = 2, - NF3BLK = 3, - NF3CHR = 4, - NF3LNK = 5, - NF3SOCK = 6, - NF3FIFO = 7, -}; -typedef enum ftype3 ftype3; - -typedef u_int mode3; - -typedef u_int uid3; - -typedef u_int gid3; - -typedef uint64_t size3; - -typedef uint64_t fileid3; - -struct specdata3 { - u_int specdata1; - u_int specdata2; -}; -typedef struct specdata3 specdata3; - -struct nfstime3 { - u_int seconds; - u_int nseconds; -}; -typedef struct nfstime3 nfstime3; - -struct fattr3 { - ftype3 type; - mode3 mode; - u_int nlink; - uid3 uid; - gid3 gid; - size3 size; - size3 used; - specdata3 rdev; - uint64_t fsid; - fileid3 fileid; - nfstime3 atime; - nfstime3 mtime; - nfstime3 ctime; -}; -typedef struct fattr3 fattr3; - -struct post_op_attr { - uint32_t attributes_follow; - union { - fattr3 attributes; - } post_op_attr_u; -}; -typedef struct post_op_attr post_op_attr; - -enum nfsstat3 { - NFS3_OK = 0, - NFS3ERR_PERM = 1, - NFS3ERR_NOENT = 2, - NFS3ERR_IO = 5, - NFS3ERR_NXIO = 6, - NFS3ERR_ACCES = 13, - NFS3ERR_EXIST = 17, - NFS3ERR_XDEV = 18, - NFS3ERR_NODEV = 19, - NFS3ERR_NOTDIR = 20, - NFS3ERR_ISDIR = 21, - NFS3ERR_INVAL = 22, - NFS3ERR_FBIG = 27, - NFS3ERR_NOSPC = 28, - NFS3ERR_ROFS = 30, - NFS3ERR_MLINK = 31, - NFS3ERR_NAMETOOLONG = 63, - NFS3ERR_NOTEMPTY = 66, - NFS3ERR_DQUOT = 69, - NFS3ERR_STALE = 70, - NFS3ERR_REMOTE = 71, - NFS3ERR_BADHANDLE = 10001, - NFS3ERR_NOT_SYNC = 10002, - NFS3ERR_BAD_COOKIE = 10003, - NFS3ERR_NOTSUPP = 10004, - NFS3ERR_TOOSMALL = 10005, - NFS3ERR_SERVERFAULT = 10006, - NFS3ERR_BADTYPE = 10007, - NFS3ERR_JUKEBOX = 10008, -}; -typedef enum nfsstat3 nfsstat3; - -enum stable_how { - UNSTABLE = 0, - DATA_SYNC = 1, - FILE_SYNC = 2, -}; -typedef enum stable_how stable_how; - -typedef uint64_t offset3; - -typedef u_int count3; - -struct wcc_attr { - size3 size; - nfstime3 mtime; - nfstime3 ctime; -}; -typedef struct wcc_attr wcc_attr; - -struct pre_op_attr { - uint32_t attributes_follow; - union { - wcc_attr attributes; - } pre_op_attr_u; -}; -typedef struct pre_op_attr pre_op_attr; - -struct wcc_data { - pre_op_attr before; - post_op_attr after; -}; -typedef struct wcc_data wcc_data; - -struct WRITE3args { - nfs_fh3 file; - offset3 offset; - count3 count; - stable_how stable; - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct WRITE3args WRITE3args; - -typedef char writeverf3[NFS3_WRITEVERFSIZE]; - -struct WRITE3resok { - wcc_data file_wcc; - count3 count; - stable_how committed; - writeverf3 verf; -}; -typedef struct WRITE3resok WRITE3resok; - -struct WRITE3resfail { - wcc_data file_wcc; -}; -typedef struct WRITE3resfail WRITE3resfail; - -struct WRITE3res { - nfsstat3 status; - union { - WRITE3resok resok; - WRITE3resfail resfail; - } WRITE3res_u; -}; -typedef struct WRITE3res WRITE3res; - -struct LOOKUP3args { - diropargs3 what; -}; -typedef struct LOOKUP3args LOOKUP3args; - -struct LOOKUP3resok { - nfs_fh3 object; - post_op_attr obj_attributes; - post_op_attr dir_attributes; -}; -typedef struct LOOKUP3resok LOOKUP3resok; - -struct LOOKUP3resfail { - post_op_attr dir_attributes; -}; -typedef struct LOOKUP3resfail LOOKUP3resfail; - -struct LOOKUP3res { - nfsstat3 status; - union { - LOOKUP3resok resok; - LOOKUP3resfail resfail; - } LOOKUP3res_u; -}; -typedef struct LOOKUP3res LOOKUP3res; - -struct COMMIT3args { - nfs_fh3 file; - offset3 offset; - count3 count; -}; -typedef struct COMMIT3args COMMIT3args; - -struct COMMIT3resok { - wcc_data file_wcc; - writeverf3 verf; -}; -typedef struct COMMIT3resok COMMIT3resok; - -struct COMMIT3resfail { - wcc_data file_wcc; -}; -typedef struct COMMIT3resfail COMMIT3resfail; - -struct COMMIT3res { - nfsstat3 status; - union { - COMMIT3resok resok; - COMMIT3resfail resfail; - } COMMIT3res_u; -}; -typedef struct COMMIT3res COMMIT3res; -#define ACCESS3_READ 0x0001 -#define ACCESS3_LOOKUP 0x0002 -#define ACCESS3_MODIFY 0x0004 -#define ACCESS3_EXTEND 0x0008 -#define ACCESS3_DELETE 0x0010 -#define ACCESS3_EXECUTE 0x0020 - -struct ACCESS3args { - nfs_fh3 object; - u_int access; -}; -typedef struct ACCESS3args ACCESS3args; - -struct ACCESS3resok { - post_op_attr obj_attributes; - u_int access; -}; -typedef struct ACCESS3resok ACCESS3resok; - -struct ACCESS3resfail { - post_op_attr obj_attributes; -}; -typedef struct ACCESS3resfail ACCESS3resfail; - -struct ACCESS3res { - nfsstat3 status; - union { - ACCESS3resok resok; - ACCESS3resfail resfail; - } ACCESS3res_u; -}; -typedef struct ACCESS3res ACCESS3res; - -struct GETATTR3args { - nfs_fh3 object; -}; -typedef struct GETATTR3args GETATTR3args; - -struct GETATTR3resok { - fattr3 obj_attributes; -}; -typedef struct GETATTR3resok GETATTR3resok; - -struct GETATTR3res { - nfsstat3 status; - union { - GETATTR3resok resok; - } GETATTR3res_u; -}; -typedef struct GETATTR3res GETATTR3res; - -enum time_how { - DONT_CHANGE = 0, - SET_TO_SERVER_TIME = 1, - SET_TO_CLIENT_TIME = 2, -}; -typedef enum time_how time_how; - -struct set_mode3 { - uint32_t set_it; - union { - mode3 mode; - } set_mode3_u; -}; -typedef struct set_mode3 set_mode3; - -struct set_uid3 { - uint32_t set_it; - union { - uid3 uid; - } set_uid3_u; -}; -typedef struct set_uid3 set_uid3; - -struct set_gid3 { - uint32_t set_it; - union { - gid3 gid; - } set_gid3_u; -}; -typedef struct set_gid3 set_gid3; - -struct set_size3 { - uint32_t set_it; - union { - size3 size; - } set_size3_u; -}; -typedef struct set_size3 set_size3; - -struct set_atime { - time_how set_it; - union { - nfstime3 atime; - } set_atime_u; -}; -typedef struct set_atime set_atime; - -struct set_mtime { - time_how set_it; - union { - nfstime3 mtime; - } set_mtime_u; -}; -typedef struct set_mtime set_mtime; - -struct sattr3 { - set_mode3 mode; - set_uid3 uid; - set_gid3 gid; - set_size3 size; - set_atime atime; - set_mtime mtime; -}; -typedef struct sattr3 sattr3; - -enum createmode3 { - UNCHECKED = 0, - GUARDED = 1, - EXCLUSIVE = 2, -}; -typedef enum createmode3 createmode3; - -typedef char createverf3[NFS3_CREATEVERFSIZE]; - -struct createhow3 { - createmode3 mode; - union { - sattr3 obj_attributes; - sattr3 g_obj_attributes; - createverf3 verf; - } createhow3_u; -}; -typedef struct createhow3 createhow3; - -struct CREATE3args { - diropargs3 where; - createhow3 how; -}; -typedef struct CREATE3args CREATE3args; - -struct post_op_fh3 { - uint32_t handle_follows; - union { - nfs_fh3 handle; - } post_op_fh3_u; -}; -typedef struct post_op_fh3 post_op_fh3; - -struct CREATE3resok { - post_op_fh3 obj; - post_op_attr obj_attributes; - wcc_data dir_wcc; -}; -typedef struct CREATE3resok CREATE3resok; - -struct CREATE3resfail { - wcc_data dir_wcc; -}; -typedef struct CREATE3resfail CREATE3resfail; - -struct CREATE3res { - nfsstat3 status; - union { - CREATE3resok resok; - CREATE3resfail resfail; - } CREATE3res_u; -}; -typedef struct CREATE3res CREATE3res; - -struct REMOVE3args { - diropargs3 object; -}; -typedef struct REMOVE3args REMOVE3args; - -struct REMOVE3resok { - wcc_data dir_wcc; -}; -typedef struct REMOVE3resok REMOVE3resok; - -struct REMOVE3resfail { - wcc_data dir_wcc; -}; -typedef struct REMOVE3resfail REMOVE3resfail; - -struct REMOVE3res { - nfsstat3 status; - union { - REMOVE3resok resok; - REMOVE3resfail resfail; - } REMOVE3res_u; -}; -typedef struct REMOVE3res REMOVE3res; - -struct READ3args { - nfs_fh3 file; - offset3 offset; - count3 count; -}; -typedef struct READ3args READ3args; - -struct READ3resok { - post_op_attr file_attributes; - count3 count; - uint32_t eof; - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct READ3resok READ3resok; - -struct READ3resfail { - post_op_attr file_attributes; -}; -typedef struct READ3resfail READ3resfail; - -struct READ3res { - nfsstat3 status; - union { - READ3resok resok; - READ3resfail resfail; - } READ3res_u; -}; -typedef struct READ3res READ3res; -#define FSF3_LINK 0x0001 -#define FSF3_SYMLINK 0x0002 -#define FSF3_HOMOGENEOUS 0x0008 -#define FSF3_CANSETTIME 0x0010 - -struct FSINFO3args { - nfs_fh3 fsroot; -}; -typedef struct FSINFO3args FSINFO3args; - -struct FSINFO3resok { - post_op_attr obj_attributes; - u_int rtmax; - u_int rtpref; - u_int rtmult; - u_int wtmax; - u_int wtpref; - u_int wtmult; - u_int dtpref; - size3 maxfilesize; - nfstime3 time_delta; - u_int properties; -}; -typedef struct FSINFO3resok FSINFO3resok; - -struct FSINFO3resfail { - post_op_attr obj_attributes; -}; -typedef struct FSINFO3resfail FSINFO3resfail; - -struct FSINFO3res { - nfsstat3 status; - union { - FSINFO3resok resok; - FSINFO3resfail resfail; - } FSINFO3res_u; -}; -typedef struct FSINFO3res FSINFO3res; - -struct FSSTAT3args { - nfs_fh3 fsroot; -}; -typedef struct FSSTAT3args FSSTAT3args; - -struct FSSTAT3resok { - post_op_attr obj_attributes; - size3 tbytes; - size3 fbytes; - size3 abytes; - size3 tfiles; - size3 ffiles; - size3 afiles; - u_int invarsec; -}; -typedef struct FSSTAT3resok FSSTAT3resok; - -struct FSSTAT3resfail { - post_op_attr obj_attributes; -}; -typedef struct FSSTAT3resfail FSSTAT3resfail; - -struct FSSTAT3res { - nfsstat3 status; - union { - FSSTAT3resok resok; - FSSTAT3resfail resfail; - } FSSTAT3res_u; -}; -typedef struct FSSTAT3res FSSTAT3res; - -struct PATHCONF3args { - nfs_fh3 object; -}; -typedef struct PATHCONF3args PATHCONF3args; - -struct PATHCONF3resok { - post_op_attr obj_attributes; - u_int linkmax; - u_int name_max; - uint32_t no_trunc; - uint32_t chown_restricted; - uint32_t case_insensitive; - uint32_t case_preserving; -}; -typedef struct PATHCONF3resok PATHCONF3resok; - -struct PATHCONF3resfail { - post_op_attr obj_attributes; -}; -typedef struct PATHCONF3resfail PATHCONF3resfail; - -struct PATHCONF3res { - nfsstat3 status; - union { - PATHCONF3resok resok; - PATHCONF3resfail resfail; - } PATHCONF3res_u; -}; -typedef struct PATHCONF3res PATHCONF3res; - -typedef char *nfspath3; - -struct symlinkdata3 { - sattr3 symlink_attributes; - nfspath3 symlink_data; -}; -typedef struct symlinkdata3 symlinkdata3; - -struct SYMLINK3args { - diropargs3 where; - symlinkdata3 symlink; -}; -typedef struct SYMLINK3args SYMLINK3args; - -struct SYMLINK3resok { - post_op_fh3 obj; - post_op_attr obj_attributes; - wcc_data dir_wcc; -}; -typedef struct SYMLINK3resok SYMLINK3resok; - -struct SYMLINK3resfail { - wcc_data dir_wcc; -}; -typedef struct SYMLINK3resfail SYMLINK3resfail; - -struct SYMLINK3res { - nfsstat3 status; - union { - SYMLINK3resok resok; - SYMLINK3resfail resfail; - } SYMLINK3res_u; -}; -typedef struct SYMLINK3res SYMLINK3res; - -struct READLINK3args { - nfs_fh3 symlink; -}; -typedef struct READLINK3args READLINK3args; - -struct READLINK3resok { - post_op_attr symlink_attributes; - nfspath3 data; -}; -typedef struct READLINK3resok READLINK3resok; - -struct READLINK3resfail { - post_op_attr symlink_attributes; -}; -typedef struct READLINK3resfail READLINK3resfail; - -struct READLINK3res { - nfsstat3 status; - union { - READLINK3resok resok; - READLINK3resfail resfail; - } READLINK3res_u; -}; -typedef struct READLINK3res READLINK3res; - -struct devicedata3 { - sattr3 dev_attributes; - specdata3 spec; -}; -typedef struct devicedata3 devicedata3; - -struct mknoddata3 { - ftype3 type; - union { - devicedata3 chr_device; - devicedata3 blk_device; - sattr3 sock_attributes; - sattr3 pipe_attributes; - } mknoddata3_u; -}; -typedef struct mknoddata3 mknoddata3; - -struct MKNOD3args { - diropargs3 where; - mknoddata3 what; -}; -typedef struct MKNOD3args MKNOD3args; - -struct MKNOD3resok { - post_op_fh3 obj; - post_op_attr obj_attributes; - wcc_data dir_wcc; -}; -typedef struct MKNOD3resok MKNOD3resok; - -struct MKNOD3resfail { - wcc_data dir_wcc; -}; -typedef struct MKNOD3resfail MKNOD3resfail; - -struct MKNOD3res { - nfsstat3 status; - union { - MKNOD3resok resok; - MKNOD3resfail resfail; - } MKNOD3res_u; -}; -typedef struct MKNOD3res MKNOD3res; - -struct MKDIR3args { - diropargs3 where; - sattr3 attributes; -}; -typedef struct MKDIR3args MKDIR3args; - -struct MKDIR3resok { - post_op_fh3 obj; - post_op_attr obj_attributes; - wcc_data dir_wcc; -}; -typedef struct MKDIR3resok MKDIR3resok; - -struct MKDIR3resfail { - wcc_data dir_wcc; -}; -typedef struct MKDIR3resfail MKDIR3resfail; - -struct MKDIR3res { - nfsstat3 status; - union { - MKDIR3resok resok; - MKDIR3resfail resfail; - } MKDIR3res_u; -}; -typedef struct MKDIR3res MKDIR3res; - -struct RMDIR3args { - diropargs3 object; -}; -typedef struct RMDIR3args RMDIR3args; - -struct RMDIR3resok { - wcc_data dir_wcc; -}; -typedef struct RMDIR3resok RMDIR3resok; - -struct RMDIR3resfail { - wcc_data dir_wcc; -}; -typedef struct RMDIR3resfail RMDIR3resfail; - -struct RMDIR3res { - nfsstat3 status; - union { - RMDIR3resok resok; - RMDIR3resfail resfail; - } RMDIR3res_u; -}; -typedef struct RMDIR3res RMDIR3res; - -struct RENAME3args { - diropargs3 from; - diropargs3 to; -}; -typedef struct RENAME3args RENAME3args; - -struct RENAME3resok { - wcc_data fromdir_wcc; - wcc_data todir_wcc; -}; -typedef struct RENAME3resok RENAME3resok; - -struct RENAME3resfail { - wcc_data fromdir_wcc; - wcc_data todir_wcc; -}; -typedef struct RENAME3resfail RENAME3resfail; - -struct RENAME3res { - nfsstat3 status; - union { - RENAME3resok resok; - RENAME3resfail resfail; - } RENAME3res_u; -}; -typedef struct RENAME3res RENAME3res; - -struct READDIRPLUS3args { - nfs_fh3 dir; - cookie3 cookie; - cookieverf3 cookieverf; - count3 dircount; - count3 maxcount; -}; -typedef struct READDIRPLUS3args READDIRPLUS3args; - -struct entryplus3 { - fileid3 fileid; - filename3 name; - cookie3 cookie; - post_op_attr name_attributes; - post_op_fh3 name_handle; - struct entryplus3 *nextentry; -}; -typedef struct entryplus3 entryplus3; - -struct dirlistplus3 { - entryplus3 *entries; - uint32_t eof; -}; -typedef struct dirlistplus3 dirlistplus3; - -struct READDIRPLUS3resok { - post_op_attr dir_attributes; - cookieverf3 cookieverf; - dirlistplus3 reply; -}; -typedef struct READDIRPLUS3resok READDIRPLUS3resok; - -struct READDIRPLUS3resfail { - post_op_attr dir_attributes; -}; -typedef struct READDIRPLUS3resfail READDIRPLUS3resfail; - -struct READDIRPLUS3res { - nfsstat3 status; - union { - READDIRPLUS3resok resok; - READDIRPLUS3resfail resfail; - } READDIRPLUS3res_u; -}; -typedef struct READDIRPLUS3res READDIRPLUS3res; - -struct READDIR3args { - nfs_fh3 dir; - cookie3 cookie; - cookieverf3 cookieverf; - count3 count; -}; -typedef struct READDIR3args READDIR3args; - -struct entry3 { - fileid3 fileid; - filename3 name; - cookie3 cookie; - struct entry3 *nextentry; -}; -typedef struct entry3 entry3; - -struct dirlist3 { - entry3 *entries; - uint32_t eof; -}; -typedef struct dirlist3 dirlist3; - -struct READDIR3resok { - post_op_attr dir_attributes; - cookieverf3 cookieverf; - dirlist3 reply; -}; -typedef struct READDIR3resok READDIR3resok; - -struct READDIR3resfail { - post_op_attr dir_attributes; -}; -typedef struct READDIR3resfail READDIR3resfail; - -struct READDIR3res { - nfsstat3 status; - union { - READDIR3resok resok; - READDIR3resfail resfail; - } READDIR3res_u; -}; -typedef struct READDIR3res READDIR3res; - -struct LINK3args { - nfs_fh3 file; - diropargs3 link; -}; -typedef struct LINK3args LINK3args; - -struct LINK3resok { - post_op_attr file_attributes; - wcc_data linkdir_wcc; -}; -typedef struct LINK3resok LINK3resok; - -struct LINK3resfail { - post_op_attr file_attributes; - wcc_data linkdir_wcc; -}; -typedef struct LINK3resfail LINK3resfail; - -struct LINK3res { - nfsstat3 status; - union { - LINK3resok resok; - LINK3resfail resfail; - } LINK3res_u; -}; -typedef struct LINK3res LINK3res; - -struct sattrguard3 { - uint32_t check; - union { - nfstime3 obj_ctime; - } sattrguard3_u; -}; -typedef struct sattrguard3 sattrguard3; - -struct SETATTR3args { - nfs_fh3 object; - sattr3 new_attributes; - sattrguard3 guard; -}; -typedef struct SETATTR3args SETATTR3args; - -struct SETATTR3resok { - wcc_data obj_wcc; -}; -typedef struct SETATTR3resok SETATTR3resok; - -struct SETATTR3resfail { - wcc_data obj_wcc; -}; -typedef struct SETATTR3resfail SETATTR3resfail; - -struct SETATTR3res { - nfsstat3 status; - union { - SETATTR3resok resok; - SETATTR3resfail resfail; - } SETATTR3res_u; -}; -typedef struct SETATTR3res SETATTR3res; -#define FHSIZE2 32 - -typedef char fhandle2[FHSIZE2]; - -enum ftype2 { - NF2NON = 0, - NF2REG = 1, - NF2DIR = 2, - NF2BLK = 3, - NF2CHR = 4, - NF2LNK = 5, -}; -typedef enum ftype2 ftype2; - -struct fattr2 { - ftype2 type; - u_int mode; - u_int nlink; - u_int uid; - u_int gid; - u_int size; - u_int blocksize; - u_int rdev; - u_int blocks; - u_int fsid; - u_int fileid; - nfstime3 atime; - nfstime3 mtime; - nfstime3 ctime; -}; -typedef struct fattr2 fattr2; - -struct sattr2 { - u_int mode; - u_int uid; - u_int gid; - u_int size; - nfstime3 atime; - nfstime3 mtime; -}; -typedef struct sattr2 sattr2; -#define MAXNAMLEN2 255 - -typedef char *filename2; -#define MAXPATHLEN2 1024 - -typedef char *path2; -#define NFSMAXDATA2 8192 - -typedef struct { - u_int nfsdata2_len; - char *nfsdata2_val; -} nfsdata2; -#define NFSCOOKIESIZE2 4 - -typedef char nfscookie2[NFSCOOKIESIZE2]; - -struct entry2 { - u_int fileid; - filename2 name; - nfscookie2 cookie; - struct entry2 *nextentry; -}; -typedef struct entry2 entry2; - -struct diropargs2 { - fhandle2 dir; - filename2 name; -}; -typedef struct diropargs2 diropargs2; - -struct GETATTR2args { - fhandle2 fhandle; -}; -typedef struct GETATTR2args GETATTR2args; - -struct GETATTR2resok { - fattr2 attributes; -}; -typedef struct GETATTR2resok GETATTR2resok; - -struct GETATTR2res { - nfsstat3 status; - union { - GETATTR2resok resok; - } GETATTR2res_u; -}; -typedef struct GETATTR2res GETATTR2res; - -struct SETATTR2args { - fhandle2 fhandle; - sattr2 attributes; -}; -typedef struct SETATTR2args SETATTR2args; - -struct SETATTR2resok { - fattr2 attributes; -}; -typedef struct SETATTR2resok SETATTR2resok; - -struct SETATTR2res { - nfsstat3 status; - union { - SETATTR2resok resok; - } SETATTR2res_u; -}; -typedef struct SETATTR2res SETATTR2res; - -struct LOOKUP2args { - diropargs2 what; -}; -typedef struct LOOKUP2args LOOKUP2args; - -struct LOOKUP2resok { - fhandle2 file; - fattr2 attributes; -}; -typedef struct LOOKUP2resok LOOKUP2resok; - -struct LOOKUP2res { - nfsstat3 status; - union { - LOOKUP2resok resok; - } LOOKUP2res_u; -}; -typedef struct LOOKUP2res LOOKUP2res; - -struct READLINK2args { - fhandle2 file; -}; -typedef struct READLINK2args READLINK2args; - -struct READLINK2resok { - path2 data; -}; -typedef struct READLINK2resok READLINK2resok; - -struct READLINK2res { - nfsstat3 status; - union { - READLINK2resok resok; - } READLINK2res_u; -}; -typedef struct READLINK2res READLINK2res; - -struct READ2args { - fhandle2 file; - u_int offset; - u_int count; - u_int totalcount; -}; -typedef struct READ2args READ2args; - -struct READ2resok { - fattr2 attributes; - nfsdata2 data; -}; -typedef struct READ2resok READ2resok; - -struct READ2res { - nfsstat3 status; - union { - READ2resok resok; - } READ2res_u; -}; -typedef struct READ2res READ2res; - -struct WRITE2args { - fhandle2 file; - u_int beginoffset; - u_int offset; - u_int totalcount; - nfsdata2 data; -}; -typedef struct WRITE2args WRITE2args; - -struct WRITE2resok { - fattr2 attributes; -}; -typedef struct WRITE2resok WRITE2resok; - -struct WRITE2res { - nfsstat3 status; - union { - WRITE2resok resok; - } WRITE2res_u; -}; -typedef struct WRITE2res WRITE2res; - -struct CREATE2args { - diropargs2 where; - sattr2 attributes; -}; -typedef struct CREATE2args CREATE2args; - -struct CREATE2resok { - fhandle2 file; - fattr2 attributes; -}; -typedef struct CREATE2resok CREATE2resok; - -struct CREATE2res { - nfsstat3 status; - union { - CREATE2resok resok; - } CREATE2res_u; -}; -typedef struct CREATE2res CREATE2res; - -struct REMOVE2args { - diropargs2 what; -}; -typedef struct REMOVE2args REMOVE2args; - -struct REMOVE2res { - nfsstat3 status; -}; -typedef struct REMOVE2res REMOVE2res; - -struct RENAME2args { - diropargs2 from; - diropargs2 to; -}; -typedef struct RENAME2args RENAME2args; - -struct RENAME2res { - nfsstat3 status; -}; -typedef struct RENAME2res RENAME2res; - -struct LINK2args { - fhandle2 from; - diropargs2 to; -}; -typedef struct LINK2args LINK2args; - -struct LINK2res { - nfsstat3 status; -}; -typedef struct LINK2res LINK2res; - -struct SYMLINK2args { - diropargs2 from; - path2 to; - sattr2 attributes; -}; -typedef struct SYMLINK2args SYMLINK2args; - -struct SYMLINK2res { - nfsstat3 status; -}; -typedef struct SYMLINK2res SYMLINK2res; - -struct MKDIR2args { - diropargs2 where; - sattr2 attributes; -}; -typedef struct MKDIR2args MKDIR2args; - -struct MKDIR2resok { - fhandle2 file; - fattr2 attributes; -}; -typedef struct MKDIR2resok MKDIR2resok; - -struct MKDIR2res { - nfsstat3 status; - union { - MKDIR2resok resok; - } MKDIR2res_u; -}; -typedef struct MKDIR2res MKDIR2res; - -struct RMDIR2args { - diropargs2 what; -}; -typedef struct RMDIR2args RMDIR2args; - -struct RMDIR2res { - nfsstat3 status; -}; -typedef struct RMDIR2res RMDIR2res; - -struct READDIR2args { - fhandle2 dir; - nfscookie2 cookie; - u_int count; -}; -typedef struct READDIR2args READDIR2args; - -struct READDIR2resok { - entry2 *entries; - uint32_t eof; -}; -typedef struct READDIR2resok READDIR2resok; - -struct READDIR2res { - nfsstat3 status; - union { - READDIR2resok resok; - } READDIR2res_u; -}; -typedef struct READDIR2res READDIR2res; - -struct STATFS2args { - fhandle2 dir; -}; -typedef struct STATFS2args STATFS2args; - -struct STATFS2resok { - u_int tsize; - u_int bsize; - u_int blocks; - u_int bfree; - u_int bavail; -}; -typedef struct STATFS2resok STATFS2resok; - -struct STATFS2res { - nfsstat3 status; - union { - STATFS2resok resok; - } STATFS2res_u; -}; -typedef struct STATFS2res STATFS2res; - -enum nfsacl_type { - NFSACL_TYPE_USER_OBJ = 0x0001, - NFSACL_TYPE_USER = 0x0002, - NFSACL_TYPE_GROUP_OBJ = 0x0004, - NFSACL_TYPE_GROUP = 0x0008, - NFSACL_TYPE_CLASS_OBJ = 0x0010, - NFSACL_TYPE_CLASS = 0x0020, - NFSACL_TYPE_DEFAULT = 0x1000, - NFSACL_TYPE_DEFAULT_USER_OBJ = 0x1001, - NFSACL_TYPE_DEFAULT_USER = 0x1002, - NFSACL_TYPE_DEFAULT_GROUP_OBJ = 0x1004, - NFSACL_TYPE_DEFAULT_GROUP = 0x1008, - NFSACL_TYPE_DEFAULT_CLASS_OBJ = 0x1010, - NFSACL_TYPE_DEFAULT_OTHER_OBJ = 0x1020, -}; -typedef enum nfsacl_type nfsacl_type; -#define NFSACL_PERM_READ 0x04 -#define NFSACL_PERM_WRITE 0x02 -#define NFSACL_PERM_EXEC 0x01 - -struct nfsacl_ace { - enum nfsacl_type type; - u_int id; - u_int perm; -}; -typedef struct nfsacl_ace nfsacl_ace; -#define NFSACL_MASK_ACL_ENTRY 0x0001 -#define NFSACL_MASK_ACL_COUNT 0x0002 -#define NFSACL_MASK_ACL_DEFAULT_ENTRY 0x0004 -#define NFSACL_MASK_ACL_DEFAULT_COUNT 0x0008 - -struct GETACL3args { - nfs_fh3 dir; - u_int mask; -}; -typedef struct GETACL3args GETACL3args; - -struct GETACL3resok { - post_op_attr attr; - u_int mask; - u_int ace_count; - struct { - u_int ace_len; - struct nfsacl_ace *ace_val; - } ace; - u_int default_ace_count; - struct { - u_int default_ace_len; - struct nfsacl_ace *default_ace_val; - } default_ace; -}; -typedef struct GETACL3resok GETACL3resok; - -struct GETACL3res { - nfsstat3 status; - union { - GETACL3resok resok; - } GETACL3res_u; -}; -typedef struct GETACL3res GETACL3res; - -struct SETACL3args { - nfs_fh3 dir; - u_int mask; - u_int ace_count; - struct { - u_int ace_len; - struct nfsacl_ace *ace_val; - } ace; - u_int default_ace_count; - struct { - u_int default_ace_len; - struct nfsacl_ace *default_ace_val; - } default_ace; -}; -typedef struct SETACL3args SETACL3args; - -struct SETACL3resok { - post_op_attr attr; -}; -typedef struct SETACL3resok SETACL3resok; - -struct SETACL3res { - nfsstat3 status; - union { - SETACL3resok resok; - } SETACL3res_u; -}; -typedef struct SETACL3res SETACL3res; - -#define NFS_PROGRAM 100003 -#define NFS_V2 2 - -#if defined(__STDC__) || defined(__cplusplus) -#define NFS2_NULL 0 -extern void * nfs2_null_2(void *, void *); -extern void * nfs2_null_2_svc(void *, struct svc_req *); -#define NFS2_GETATTR 1 -extern GETATTR2res * nfs2_getattr_2(GETATTR2args *, void *); -extern GETATTR2res * nfs2_getattr_2_svc(GETATTR2args *, struct svc_req *); -#define NFS2_SETATTR 2 -extern SETATTR2res * nfs2_setattr_2(SETATTR2args *, void *); -extern SETATTR2res * nfs2_setattr_2_svc(SETATTR2args *, struct svc_req *); -#define NFS2_LOOKUP 4 -extern LOOKUP2res * nfs2_lookup_2(LOOKUP2args *, void *); -extern LOOKUP2res * nfs2_lookup_2_svc(LOOKUP2args *, struct svc_req *); -#define NFS2_READLINK 5 -extern READLINK2res * nfs2_readlink_2(READLINK2args *, void *); -extern READLINK2res * nfs2_readlink_2_svc(READLINK2args *, struct svc_req *); -#define NFS2_READ 6 -extern READ2res * nfs2_read_2(READ2args *, void *); -extern READ2res * nfs2_read_2_svc(READ2args *, struct svc_req *); -#define NFS2_WRITE 8 -extern WRITE2res * nfs2_write_2(WRITE2args *, void *); -extern WRITE2res * nfs2_write_2_svc(WRITE2args *, struct svc_req *); -#define NFS2_CREATE 9 -extern CREATE2res * nfs2_create_2(CREATE2args *, void *); -extern CREATE2res * nfs2_create_2_svc(CREATE2args *, struct svc_req *); -#define NFS2_REMOVE 10 -extern REMOVE2res * nfs2_remove_2(REMOVE2args *, void *); -extern REMOVE2res * nfs2_remove_2_svc(REMOVE2args *, struct svc_req *); -#define NFS2_RENAME 11 -extern RENAME2res * nfs2_rename_2(RENAME2args *, void *); -extern RENAME2res * nfs2_rename_2_svc(RENAME2args *, struct svc_req *); -#define NFS2_LINK 12 -extern LINK2res * nfs2_link_2(LINK2args *, void *); -extern LINK2res * nfs2_link_2_svc(LINK2args *, struct svc_req *); -#define NFS2_SYMLINK 13 -extern SYMLINK2res * nfs2_symlink_2(SYMLINK2args *, void *); -extern SYMLINK2res * nfs2_symlink_2_svc(SYMLINK2args *, struct svc_req *); -#define NFS2_MKDIR 14 -extern MKDIR2res * nfs2_mkdir_2(MKDIR2args *, void *); -extern MKDIR2res * nfs2_mkdir_2_svc(MKDIR2args *, struct svc_req *); -#define NFS2_RMDIR 15 -extern RMDIR2res * nfs2_rmdir_2(RMDIR2args *, void *); -extern RMDIR2res * nfs2_rmdir_2_svc(RMDIR2args *, struct svc_req *); -#define NFS2_READDIR 16 -extern READDIR2res * nfs2_readdir_2(READDIR2args *, void *); -extern READDIR2res * nfs2_readdir_2_svc(READDIR2args *, struct svc_req *); -#define NFS2_STATFS 17 -extern STATFS2res * nfs2_statfs_2(STATFS2args *, void *); -extern STATFS2res * nfs2_statfs_2_svc(STATFS2args *, struct svc_req *); -extern int nfs_program_2_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define NFS2_NULL 0 -extern void * nfs2_null_2(); -extern void * nfs2_null_2_svc(); -#define NFS2_GETATTR 1 -extern GETATTR2res * nfs2_getattr_2(); -extern GETATTR2res * nfs2_getattr_2_svc(); -#define NFS2_SETATTR 2 -extern SETATTR2res * nfs2_setattr_2(); -extern SETATTR2res * nfs2_setattr_2_svc(); -#define NFS2_LOOKUP 4 -extern LOOKUP2res * nfs2_lookup_2(); -extern LOOKUP2res * nfs2_lookup_2_svc(); -#define NFS2_READLINK 5 -extern READLINK2res * nfs2_readlink_2(); -extern READLINK2res * nfs2_readlink_2_svc(); -#define NFS2_READ 6 -extern READ2res * nfs2_read_2(); -extern READ2res * nfs2_read_2_svc(); -#define NFS2_WRITE 8 -extern WRITE2res * nfs2_write_2(); -extern WRITE2res * nfs2_write_2_svc(); -#define NFS2_CREATE 9 -extern CREATE2res * nfs2_create_2(); -extern CREATE2res * nfs2_create_2_svc(); -#define NFS2_REMOVE 10 -extern REMOVE2res * nfs2_remove_2(); -extern REMOVE2res * nfs2_remove_2_svc(); -#define NFS2_RENAME 11 -extern RENAME2res * nfs2_rename_2(); -extern RENAME2res * nfs2_rename_2_svc(); -#define NFS2_LINK 12 -extern LINK2res * nfs2_link_2(); -extern LINK2res * nfs2_link_2_svc(); -#define NFS2_SYMLINK 13 -extern SYMLINK2res * nfs2_symlink_2(); -extern SYMLINK2res * nfs2_symlink_2_svc(); -#define NFS2_MKDIR 14 -extern MKDIR2res * nfs2_mkdir_2(); -extern MKDIR2res * nfs2_mkdir_2_svc(); -#define NFS2_RMDIR 15 -extern RMDIR2res * nfs2_rmdir_2(); -extern RMDIR2res * nfs2_rmdir_2_svc(); -#define NFS2_READDIR 16 -extern READDIR2res * nfs2_readdir_2(); -extern READDIR2res * nfs2_readdir_2_svc(); -#define NFS2_STATFS 17 -extern STATFS2res * nfs2_statfs_2(); -extern STATFS2res * nfs2_statfs_2_svc(); -extern int nfs_program_2_freeresult (); -#endif /* K&R C */ -#define NFS_V3 3 - -#if defined(__STDC__) || defined(__cplusplus) -#define NFS3_NULL 0 -extern void * nfs3_null_3(void *, void *); -extern void * nfs3_null_3_svc(void *, struct svc_req *); -#define NFS3_GETATTR 1 -extern GETATTR3res * nfs3_getattr_3(GETATTR3args *, void *); -extern GETATTR3res * nfs3_getattr_3_svc(GETATTR3args *, struct svc_req *); -#define NFS3_SETATTR 2 -extern SETATTR3res * nfs3_setattr_3(SETATTR3args *, void *); -extern SETATTR3res * nfs3_setattr_3_svc(SETATTR3args *, struct svc_req *); -#define NFS3_LOOKUP 3 -extern LOOKUP3res * nfs3_lookup_3(LOOKUP3args *, void *); -extern LOOKUP3res * nfs3_lookup_3_svc(LOOKUP3args *, struct svc_req *); -#define NFS3_ACCESS 4 -extern ACCESS3res * nfs3_access_3(ACCESS3args *, void *); -extern ACCESS3res * nfs3_access_3_svc(ACCESS3args *, struct svc_req *); -#define NFS3_READLINK 5 -extern READLINK3res * nfs3_readlink_3(READLINK3args *, void *); -extern READLINK3res * nfs3_readlink_3_svc(READLINK3args *, struct svc_req *); -#define NFS3_READ 6 -extern READ3res * nfs3_read_3(READ3args *, void *); -extern READ3res * nfs3_read_3_svc(READ3args *, struct svc_req *); -#define NFS3_WRITE 7 -extern WRITE3res * nfs3_write_3(WRITE3args *, void *); -extern WRITE3res * nfs3_write_3_svc(WRITE3args *, struct svc_req *); -#define NFS3_CREATE 8 -extern CREATE3res * nfs3_create_3(CREATE3args *, void *); -extern CREATE3res * nfs3_create_3_svc(CREATE3args *, struct svc_req *); -#define NFS3_MKDIR 9 -extern MKDIR3res * nfs3_mkdir_3(MKDIR3args *, void *); -extern MKDIR3res * nfs3_mkdir_3_svc(MKDIR3args *, struct svc_req *); -#define NFS3_SYMLINK 10 -extern SYMLINK3res * nfs3_symlink_3(SYMLINK3args *, void *); -extern SYMLINK3res * nfs3_symlink_3_svc(SYMLINK3args *, struct svc_req *); -#define NFS3_MKNOD 11 -extern MKNOD3res * nfs3_mknod_3(MKNOD3args *, void *); -extern MKNOD3res * nfs3_mknod_3_svc(MKNOD3args *, struct svc_req *); -#define NFS3_REMOVE 12 -extern REMOVE3res * nfs3_remove_3(REMOVE3args *, void *); -extern REMOVE3res * nfs3_remove_3_svc(REMOVE3args *, struct svc_req *); -#define NFS3_RMDIR 13 -extern RMDIR3res * nfs3_rmdir_3(RMDIR3args *, void *); -extern RMDIR3res * nfs3_rmdir_3_svc(RMDIR3args *, struct svc_req *); -#define NFS3_RENAME 14 -extern RENAME3res * nfs3_rename_3(RENAME3args *, void *); -extern RENAME3res * nfs3_rename_3_svc(RENAME3args *, struct svc_req *); -#define NFS3_LINK 15 -extern LINK3res * nfs3_link_3(LINK3args *, void *); -extern LINK3res * nfs3_link_3_svc(LINK3args *, struct svc_req *); -#define NFS3_READDIR 16 -extern READDIR3res * nfs3_readdir_3(READDIR3args *, void *); -extern READDIR3res * nfs3_readdir_3_svc(READDIR3args *, struct svc_req *); -#define NFS3_READDIRPLUS 17 -extern READDIRPLUS3res * nfs3_readdirplus_3(READDIRPLUS3args *, void *); -extern READDIRPLUS3res * nfs3_readdirplus_3_svc(READDIRPLUS3args *, struct svc_req *); -#define NFS3_FSSTAT 18 -extern FSSTAT3res * nfs3_fsstat_3(FSSTAT3args *, void *); -extern FSSTAT3res * nfs3_fsstat_3_svc(FSSTAT3args *, struct svc_req *); -#define NFS3_FSINFO 19 -extern FSINFO3res * nfs3_fsinfo_3(FSINFO3args *, void *); -extern FSINFO3res * nfs3_fsinfo_3_svc(FSINFO3args *, struct svc_req *); -#define NFS3_PATHCONF 20 -extern PATHCONF3res * nfs3_pathconf_3(PATHCONF3args *, void *); -extern PATHCONF3res * nfs3_pathconf_3_svc(PATHCONF3args *, struct svc_req *); -#define NFS3_COMMIT 21 -extern COMMIT3res * nfs3_commit_3(COMMIT3args *, void *); -extern COMMIT3res * nfs3_commit_3_svc(COMMIT3args *, struct svc_req *); -extern int nfs_program_3_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define NFS3_NULL 0 -extern void * nfs3_null_3(); -extern void * nfs3_null_3_svc(); -#define NFS3_GETATTR 1 -extern GETATTR3res * nfs3_getattr_3(); -extern GETATTR3res * nfs3_getattr_3_svc(); -#define NFS3_SETATTR 2 -extern SETATTR3res * nfs3_setattr_3(); -extern SETATTR3res * nfs3_setattr_3_svc(); -#define NFS3_LOOKUP 3 -extern LOOKUP3res * nfs3_lookup_3(); -extern LOOKUP3res * nfs3_lookup_3_svc(); -#define NFS3_ACCESS 4 -extern ACCESS3res * nfs3_access_3(); -extern ACCESS3res * nfs3_access_3_svc(); -#define NFS3_READLINK 5 -extern READLINK3res * nfs3_readlink_3(); -extern READLINK3res * nfs3_readlink_3_svc(); -#define NFS3_READ 6 -extern READ3res * nfs3_read_3(); -extern READ3res * nfs3_read_3_svc(); -#define NFS3_WRITE 7 -extern WRITE3res * nfs3_write_3(); -extern WRITE3res * nfs3_write_3_svc(); -#define NFS3_CREATE 8 -extern CREATE3res * nfs3_create_3(); -extern CREATE3res * nfs3_create_3_svc(); -#define NFS3_MKDIR 9 -extern MKDIR3res * nfs3_mkdir_3(); -extern MKDIR3res * nfs3_mkdir_3_svc(); -#define NFS3_SYMLINK 10 -extern SYMLINK3res * nfs3_symlink_3(); -extern SYMLINK3res * nfs3_symlink_3_svc(); -#define NFS3_MKNOD 11 -extern MKNOD3res * nfs3_mknod_3(); -extern MKNOD3res * nfs3_mknod_3_svc(); -#define NFS3_REMOVE 12 -extern REMOVE3res * nfs3_remove_3(); -extern REMOVE3res * nfs3_remove_3_svc(); -#define NFS3_RMDIR 13 -extern RMDIR3res * nfs3_rmdir_3(); -extern RMDIR3res * nfs3_rmdir_3_svc(); -#define NFS3_RENAME 14 -extern RENAME3res * nfs3_rename_3(); -extern RENAME3res * nfs3_rename_3_svc(); -#define NFS3_LINK 15 -extern LINK3res * nfs3_link_3(); -extern LINK3res * nfs3_link_3_svc(); -#define NFS3_READDIR 16 -extern READDIR3res * nfs3_readdir_3(); -extern READDIR3res * nfs3_readdir_3_svc(); -#define NFS3_READDIRPLUS 17 -extern READDIRPLUS3res * nfs3_readdirplus_3(); -extern READDIRPLUS3res * nfs3_readdirplus_3_svc(); -#define NFS3_FSSTAT 18 -extern FSSTAT3res * nfs3_fsstat_3(); -extern FSSTAT3res * nfs3_fsstat_3_svc(); -#define NFS3_FSINFO 19 -extern FSINFO3res * nfs3_fsinfo_3(); -extern FSINFO3res * nfs3_fsinfo_3_svc(); -#define NFS3_PATHCONF 20 -extern PATHCONF3res * nfs3_pathconf_3(); -extern PATHCONF3res * nfs3_pathconf_3_svc(); -#define NFS3_COMMIT 21 -extern COMMIT3res * nfs3_commit_3(); -extern COMMIT3res * nfs3_commit_3_svc(); -extern int nfs_program_3_freeresult (); -#endif /* K&R C */ - -#define NFSACL_PROGRAM 100227 -#define NFSACL_V3 3 - -#if defined(__STDC__) || defined(__cplusplus) -#define NFSACL3_NULL 0 -extern void * nfsacl3_null_3(void *, void *); -extern void * nfsacl3_null_3_svc(void *, struct svc_req *); -#define NFSACL3_GETACL 1 -extern GETACL3res * nfsacl3_getacl_3(GETACL3args *, void *); -extern GETACL3res * nfsacl3_getacl_3_svc(GETACL3args *, struct svc_req *); -#define NFSACL3_SETACL 2 -extern SETACL3res * nfsacl3_setacl_3(SETACL3args *, void *); -extern SETACL3res * nfsacl3_setacl_3_svc(SETACL3args *, struct svc_req *); -extern int nfsacl_program_3_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define NFSACL3_NULL 0 -extern void * nfsacl3_null_3(); -extern void * nfsacl3_null_3_svc(); -#define NFSACL3_GETACL 1 -extern GETACL3res * nfsacl3_getacl_3(); -extern GETACL3res * nfsacl3_getacl_3_svc(); -#define NFSACL3_SETACL 2 -extern SETACL3res * nfsacl3_setacl_3(); -extern SETACL3res * nfsacl3_setacl_3_svc(); -extern int nfsacl_program_3_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_cookieverf3 (ZDR *, cookieverf3); -extern uint32_t zdr_cookie3 (ZDR *, cookie3*); -extern uint32_t zdr_nfs_fh3 (ZDR *, nfs_fh3*); -extern uint32_t zdr_filename3 (ZDR *, filename3*); -extern uint32_t zdr_diropargs3 (ZDR *, diropargs3*); -extern uint32_t zdr_ftype3 (ZDR *, ftype3*); -extern uint32_t zdr_mode3 (ZDR *, mode3*); -extern uint32_t zdr_uid3 (ZDR *, uid3*); -extern uint32_t zdr_gid3 (ZDR *, gid3*); -extern uint32_t zdr_size3 (ZDR *, size3*); -extern uint32_t zdr_fileid3 (ZDR *, fileid3*); -extern uint32_t zdr_specdata3 (ZDR *, specdata3*); -extern uint32_t zdr_nfstime3 (ZDR *, nfstime3*); -extern uint32_t zdr_fattr3 (ZDR *, fattr3*); -extern uint32_t zdr_post_op_attr (ZDR *, post_op_attr*); -extern uint32_t zdr_nfsstat3 (ZDR *, nfsstat3*); -extern uint32_t zdr_stable_how (ZDR *, stable_how*); -extern uint32_t zdr_offset3 (ZDR *, offset3*); -extern uint32_t zdr_count3 (ZDR *, count3*); -extern uint32_t zdr_wcc_attr (ZDR *, wcc_attr*); -extern uint32_t zdr_pre_op_attr (ZDR *, pre_op_attr*); -extern uint32_t zdr_wcc_data (ZDR *, wcc_data*); -extern uint32_t zdr_WRITE3args (ZDR *, WRITE3args*); -extern uint32_t zdr_writeverf3 (ZDR *, writeverf3); -extern uint32_t zdr_WRITE3resok (ZDR *, WRITE3resok*); -extern uint32_t zdr_WRITE3resfail (ZDR *, WRITE3resfail*); -extern uint32_t zdr_WRITE3res (ZDR *, WRITE3res*); -extern uint32_t zdr_LOOKUP3args (ZDR *, LOOKUP3args*); -extern uint32_t zdr_LOOKUP3resok (ZDR *, LOOKUP3resok*); -extern uint32_t zdr_LOOKUP3resfail (ZDR *, LOOKUP3resfail*); -extern uint32_t zdr_LOOKUP3res (ZDR *, LOOKUP3res*); -extern uint32_t zdr_COMMIT3args (ZDR *, COMMIT3args*); -extern uint32_t zdr_COMMIT3resok (ZDR *, COMMIT3resok*); -extern uint32_t zdr_COMMIT3resfail (ZDR *, COMMIT3resfail*); -extern uint32_t zdr_COMMIT3res (ZDR *, COMMIT3res*); -extern uint32_t zdr_ACCESS3args (ZDR *, ACCESS3args*); -extern uint32_t zdr_ACCESS3resok (ZDR *, ACCESS3resok*); -extern uint32_t zdr_ACCESS3resfail (ZDR *, ACCESS3resfail*); -extern uint32_t zdr_ACCESS3res (ZDR *, ACCESS3res*); -extern uint32_t zdr_GETATTR3args (ZDR *, GETATTR3args*); -extern uint32_t zdr_GETATTR3resok (ZDR *, GETATTR3resok*); -extern uint32_t zdr_GETATTR3res (ZDR *, GETATTR3res*); -extern uint32_t zdr_time_how (ZDR *, time_how*); -extern uint32_t zdr_set_mode3 (ZDR *, set_mode3*); -extern uint32_t zdr_set_uid3 (ZDR *, set_uid3*); -extern uint32_t zdr_set_gid3 (ZDR *, set_gid3*); -extern uint32_t zdr_set_size3 (ZDR *, set_size3*); -extern uint32_t zdr_set_atime (ZDR *, set_atime*); -extern uint32_t zdr_set_mtime (ZDR *, set_mtime*); -extern uint32_t zdr_sattr3 (ZDR *, sattr3*); -extern uint32_t zdr_createmode3 (ZDR *, createmode3*); -extern uint32_t zdr_createverf3 (ZDR *, createverf3); -extern uint32_t zdr_createhow3 (ZDR *, createhow3*); -extern uint32_t zdr_CREATE3args (ZDR *, CREATE3args*); -extern uint32_t zdr_post_op_fh3 (ZDR *, post_op_fh3*); -extern uint32_t zdr_CREATE3resok (ZDR *, CREATE3resok*); -extern uint32_t zdr_CREATE3resfail (ZDR *, CREATE3resfail*); -extern uint32_t zdr_CREATE3res (ZDR *, CREATE3res*); -extern uint32_t zdr_REMOVE3args (ZDR *, REMOVE3args*); -extern uint32_t zdr_REMOVE3resok (ZDR *, REMOVE3resok*); -extern uint32_t zdr_REMOVE3resfail (ZDR *, REMOVE3resfail*); -extern uint32_t zdr_REMOVE3res (ZDR *, REMOVE3res*); -extern uint32_t zdr_READ3args (ZDR *, READ3args*); -extern uint32_t zdr_READ3resok (ZDR *, READ3resok*); -extern uint32_t zdr_READ3resfail (ZDR *, READ3resfail*); -extern uint32_t zdr_READ3res (ZDR *, READ3res*); -extern uint32_t zdr_FSINFO3args (ZDR *, FSINFO3args*); -extern uint32_t zdr_FSINFO3resok (ZDR *, FSINFO3resok*); -extern uint32_t zdr_FSINFO3resfail (ZDR *, FSINFO3resfail*); -extern uint32_t zdr_FSINFO3res (ZDR *, FSINFO3res*); -extern uint32_t zdr_FSSTAT3args (ZDR *, FSSTAT3args*); -extern uint32_t zdr_FSSTAT3resok (ZDR *, FSSTAT3resok*); -extern uint32_t zdr_FSSTAT3resfail (ZDR *, FSSTAT3resfail*); -extern uint32_t zdr_FSSTAT3res (ZDR *, FSSTAT3res*); -extern uint32_t zdr_PATHCONF3args (ZDR *, PATHCONF3args*); -extern uint32_t zdr_PATHCONF3resok (ZDR *, PATHCONF3resok*); -extern uint32_t zdr_PATHCONF3resfail (ZDR *, PATHCONF3resfail*); -extern uint32_t zdr_PATHCONF3res (ZDR *, PATHCONF3res*); -extern uint32_t zdr_nfspath3 (ZDR *, nfspath3*); -extern uint32_t zdr_symlinkdata3 (ZDR *, symlinkdata3*); -extern uint32_t zdr_SYMLINK3args (ZDR *, SYMLINK3args*); -extern uint32_t zdr_SYMLINK3resok (ZDR *, SYMLINK3resok*); -extern uint32_t zdr_SYMLINK3resfail (ZDR *, SYMLINK3resfail*); -extern uint32_t zdr_SYMLINK3res (ZDR *, SYMLINK3res*); -extern uint32_t zdr_READLINK3args (ZDR *, READLINK3args*); -extern uint32_t zdr_READLINK3resok (ZDR *, READLINK3resok*); -extern uint32_t zdr_READLINK3resfail (ZDR *, READLINK3resfail*); -extern uint32_t zdr_READLINK3res (ZDR *, READLINK3res*); -extern uint32_t zdr_devicedata3 (ZDR *, devicedata3*); -extern uint32_t zdr_mknoddata3 (ZDR *, mknoddata3*); -extern uint32_t zdr_MKNOD3args (ZDR *, MKNOD3args*); -extern uint32_t zdr_MKNOD3resok (ZDR *, MKNOD3resok*); -extern uint32_t zdr_MKNOD3resfail (ZDR *, MKNOD3resfail*); -extern uint32_t zdr_MKNOD3res (ZDR *, MKNOD3res*); -extern uint32_t zdr_MKDIR3args (ZDR *, MKDIR3args*); -extern uint32_t zdr_MKDIR3resok (ZDR *, MKDIR3resok*); -extern uint32_t zdr_MKDIR3resfail (ZDR *, MKDIR3resfail*); -extern uint32_t zdr_MKDIR3res (ZDR *, MKDIR3res*); -extern uint32_t zdr_RMDIR3args (ZDR *, RMDIR3args*); -extern uint32_t zdr_RMDIR3resok (ZDR *, RMDIR3resok*); -extern uint32_t zdr_RMDIR3resfail (ZDR *, RMDIR3resfail*); -extern uint32_t zdr_RMDIR3res (ZDR *, RMDIR3res*); -extern uint32_t zdr_RENAME3args (ZDR *, RENAME3args*); -extern uint32_t zdr_RENAME3resok (ZDR *, RENAME3resok*); -extern uint32_t zdr_RENAME3resfail (ZDR *, RENAME3resfail*); -extern uint32_t zdr_RENAME3res (ZDR *, RENAME3res*); -extern uint32_t zdr_READDIRPLUS3args (ZDR *, READDIRPLUS3args*); -extern uint32_t zdr_entryplus3 (ZDR *, entryplus3*); -extern uint32_t zdr_dirlistplus3 (ZDR *, dirlistplus3*); -extern uint32_t zdr_READDIRPLUS3resok (ZDR *, READDIRPLUS3resok*); -extern uint32_t zdr_READDIRPLUS3resfail (ZDR *, READDIRPLUS3resfail*); -extern uint32_t zdr_READDIRPLUS3res (ZDR *, READDIRPLUS3res*); -extern uint32_t zdr_READDIR3args (ZDR *, READDIR3args*); -extern uint32_t zdr_entry3 (ZDR *, entry3*); -extern uint32_t zdr_dirlist3 (ZDR *, dirlist3*); -extern uint32_t zdr_READDIR3resok (ZDR *, READDIR3resok*); -extern uint32_t zdr_READDIR3resfail (ZDR *, READDIR3resfail*); -extern uint32_t zdr_READDIR3res (ZDR *, READDIR3res*); -extern uint32_t zdr_LINK3args (ZDR *, LINK3args*); -extern uint32_t zdr_LINK3resok (ZDR *, LINK3resok*); -extern uint32_t zdr_LINK3resfail (ZDR *, LINK3resfail*); -extern uint32_t zdr_LINK3res (ZDR *, LINK3res*); -extern uint32_t zdr_sattrguard3 (ZDR *, sattrguard3*); -extern uint32_t zdr_SETATTR3args (ZDR *, SETATTR3args*); -extern uint32_t zdr_SETATTR3resok (ZDR *, SETATTR3resok*); -extern uint32_t zdr_SETATTR3resfail (ZDR *, SETATTR3resfail*); -extern uint32_t zdr_SETATTR3res (ZDR *, SETATTR3res*); -extern uint32_t zdr_fhandle2 (ZDR *, fhandle2); -extern uint32_t zdr_ftype2 (ZDR *, ftype2*); -extern uint32_t zdr_fattr2 (ZDR *, fattr2*); -extern uint32_t zdr_sattr2 (ZDR *, sattr2*); -extern uint32_t zdr_filename2 (ZDR *, filename2*); -extern uint32_t zdr_path2 (ZDR *, path2*); -extern uint32_t zdr_nfsdata2 (ZDR *, nfsdata2*); -extern uint32_t zdr_nfscookie2 (ZDR *, nfscookie2); -extern uint32_t zdr_entry2 (ZDR *, entry2*); -extern uint32_t zdr_diropargs2 (ZDR *, diropargs2*); -extern uint32_t zdr_GETATTR2args (ZDR *, GETATTR2args*); -extern uint32_t zdr_GETATTR2resok (ZDR *, GETATTR2resok*); -extern uint32_t zdr_GETATTR2res (ZDR *, GETATTR2res*); -extern uint32_t zdr_SETATTR2args (ZDR *, SETATTR2args*); -extern uint32_t zdr_SETATTR2resok (ZDR *, SETATTR2resok*); -extern uint32_t zdr_SETATTR2res (ZDR *, SETATTR2res*); -extern uint32_t zdr_LOOKUP2args (ZDR *, LOOKUP2args*); -extern uint32_t zdr_LOOKUP2resok (ZDR *, LOOKUP2resok*); -extern uint32_t zdr_LOOKUP2res (ZDR *, LOOKUP2res*); -extern uint32_t zdr_READLINK2args (ZDR *, READLINK2args*); -extern uint32_t zdr_READLINK2resok (ZDR *, READLINK2resok*); -extern uint32_t zdr_READLINK2res (ZDR *, READLINK2res*); -extern uint32_t zdr_READ2args (ZDR *, READ2args*); -extern uint32_t zdr_READ2resok (ZDR *, READ2resok*); -extern uint32_t zdr_READ2res (ZDR *, READ2res*); -extern uint32_t zdr_WRITE2args (ZDR *, WRITE2args*); -extern uint32_t zdr_WRITE2resok (ZDR *, WRITE2resok*); -extern uint32_t zdr_WRITE2res (ZDR *, WRITE2res*); -extern uint32_t zdr_CREATE2args (ZDR *, CREATE2args*); -extern uint32_t zdr_CREATE2resok (ZDR *, CREATE2resok*); -extern uint32_t zdr_CREATE2res (ZDR *, CREATE2res*); -extern uint32_t zdr_REMOVE2args (ZDR *, REMOVE2args*); -extern uint32_t zdr_REMOVE2res (ZDR *, REMOVE2res*); -extern uint32_t zdr_RENAME2args (ZDR *, RENAME2args*); -extern uint32_t zdr_RENAME2res (ZDR *, RENAME2res*); -extern uint32_t zdr_LINK2args (ZDR *, LINK2args*); -extern uint32_t zdr_LINK2res (ZDR *, LINK2res*); -extern uint32_t zdr_SYMLINK2args (ZDR *, SYMLINK2args*); -extern uint32_t zdr_SYMLINK2res (ZDR *, SYMLINK2res*); -extern uint32_t zdr_MKDIR2args (ZDR *, MKDIR2args*); -extern uint32_t zdr_MKDIR2resok (ZDR *, MKDIR2resok*); -extern uint32_t zdr_MKDIR2res (ZDR *, MKDIR2res*); -extern uint32_t zdr_RMDIR2args (ZDR *, RMDIR2args*); -extern uint32_t zdr_RMDIR2res (ZDR *, RMDIR2res*); -extern uint32_t zdr_READDIR2args (ZDR *, READDIR2args*); -extern uint32_t zdr_READDIR2resok (ZDR *, READDIR2resok*); -extern uint32_t zdr_READDIR2res (ZDR *, READDIR2res*); -extern uint32_t zdr_STATFS2args (ZDR *, STATFS2args*); -extern uint32_t zdr_STATFS2resok (ZDR *, STATFS2resok*); -extern uint32_t zdr_STATFS2res (ZDR *, STATFS2res*); -extern uint32_t zdr_nfsacl_type (ZDR *, nfsacl_type*); -extern uint32_t zdr_nfsacl_ace (ZDR *, nfsacl_ace*); -extern uint32_t zdr_GETACL3args (ZDR *, GETACL3args*); -extern uint32_t zdr_GETACL3resok (ZDR *, GETACL3resok*); -extern uint32_t zdr_GETACL3res (ZDR *, GETACL3res*); -extern uint32_t zdr_SETACL3args (ZDR *, SETACL3args*); -extern uint32_t zdr_SETACL3resok (ZDR *, SETACL3resok*); -extern uint32_t zdr_SETACL3res (ZDR *, SETACL3res*); - -#else /* K&R C */ -extern uint32_t zdr_cookieverf3 (); -extern uint32_t zdr_cookie3 (); -extern uint32_t zdr_nfs_fh3 (); -extern uint32_t zdr_filename3 (); -extern uint32_t zdr_diropargs3 (); -extern uint32_t zdr_ftype3 (); -extern uint32_t zdr_mode3 (); -extern uint32_t zdr_uid3 (); -extern uint32_t zdr_gid3 (); -extern uint32_t zdr_size3 (); -extern uint32_t zdr_fileid3 (); -extern uint32_t zdr_specdata3 (); -extern uint32_t zdr_nfstime3 (); -extern uint32_t zdr_fattr3 (); -extern uint32_t zdr_post_op_attr (); -extern uint32_t zdr_nfsstat3 (); -extern uint32_t zdr_stable_how (); -extern uint32_t zdr_offset3 (); -extern uint32_t zdr_count3 (); -extern uint32_t zdr_wcc_attr (); -extern uint32_t zdr_pre_op_attr (); -extern uint32_t zdr_wcc_data (); -extern uint32_t zdr_WRITE3args (); -extern uint32_t zdr_writeverf3 (); -extern uint32_t zdr_WRITE3resok (); -extern uint32_t zdr_WRITE3resfail (); -extern uint32_t zdr_WRITE3res (); -extern uint32_t zdr_LOOKUP3args (); -extern uint32_t zdr_LOOKUP3resok (); -extern uint32_t zdr_LOOKUP3resfail (); -extern uint32_t zdr_LOOKUP3res (); -extern uint32_t zdr_COMMIT3args (); -extern uint32_t zdr_COMMIT3resok (); -extern uint32_t zdr_COMMIT3resfail (); -extern uint32_t zdr_COMMIT3res (); -extern uint32_t zdr_ACCESS3args (); -extern uint32_t zdr_ACCESS3resok (); -extern uint32_t zdr_ACCESS3resfail (); -extern uint32_t zdr_ACCESS3res (); -extern uint32_t zdr_GETATTR3args (); -extern uint32_t zdr_GETATTR3resok (); -extern uint32_t zdr_GETATTR3res (); -extern uint32_t zdr_time_how (); -extern uint32_t zdr_set_mode3 (); -extern uint32_t zdr_set_uid3 (); -extern uint32_t zdr_set_gid3 (); -extern uint32_t zdr_set_size3 (); -extern uint32_t zdr_set_atime (); -extern uint32_t zdr_set_mtime (); -extern uint32_t zdr_sattr3 (); -extern uint32_t zdr_createmode3 (); -extern uint32_t zdr_createverf3 (); -extern uint32_t zdr_createhow3 (); -extern uint32_t zdr_CREATE3args (); -extern uint32_t zdr_post_op_fh3 (); -extern uint32_t zdr_CREATE3resok (); -extern uint32_t zdr_CREATE3resfail (); -extern uint32_t zdr_CREATE3res (); -extern uint32_t zdr_REMOVE3args (); -extern uint32_t zdr_REMOVE3resok (); -extern uint32_t zdr_REMOVE3resfail (); -extern uint32_t zdr_REMOVE3res (); -extern uint32_t zdr_READ3args (); -extern uint32_t zdr_READ3resok (); -extern uint32_t zdr_READ3resfail (); -extern uint32_t zdr_READ3res (); -extern uint32_t zdr_FSINFO3args (); -extern uint32_t zdr_FSINFO3resok (); -extern uint32_t zdr_FSINFO3resfail (); -extern uint32_t zdr_FSINFO3res (); -extern uint32_t zdr_FSSTAT3args (); -extern uint32_t zdr_FSSTAT3resok (); -extern uint32_t zdr_FSSTAT3resfail (); -extern uint32_t zdr_FSSTAT3res (); -extern uint32_t zdr_PATHCONF3args (); -extern uint32_t zdr_PATHCONF3resok (); -extern uint32_t zdr_PATHCONF3resfail (); -extern uint32_t zdr_PATHCONF3res (); -extern uint32_t zdr_nfspath3 (); -extern uint32_t zdr_symlinkdata3 (); -extern uint32_t zdr_SYMLINK3args (); -extern uint32_t zdr_SYMLINK3resok (); -extern uint32_t zdr_SYMLINK3resfail (); -extern uint32_t zdr_SYMLINK3res (); -extern uint32_t zdr_READLINK3args (); -extern uint32_t zdr_READLINK3resok (); -extern uint32_t zdr_READLINK3resfail (); -extern uint32_t zdr_READLINK3res (); -extern uint32_t zdr_devicedata3 (); -extern uint32_t zdr_mknoddata3 (); -extern uint32_t zdr_MKNOD3args (); -extern uint32_t zdr_MKNOD3resok (); -extern uint32_t zdr_MKNOD3resfail (); -extern uint32_t zdr_MKNOD3res (); -extern uint32_t zdr_MKDIR3args (); -extern uint32_t zdr_MKDIR3resok (); -extern uint32_t zdr_MKDIR3resfail (); -extern uint32_t zdr_MKDIR3res (); -extern uint32_t zdr_RMDIR3args (); -extern uint32_t zdr_RMDIR3resok (); -extern uint32_t zdr_RMDIR3resfail (); -extern uint32_t zdr_RMDIR3res (); -extern uint32_t zdr_RENAME3args (); -extern uint32_t zdr_RENAME3resok (); -extern uint32_t zdr_RENAME3resfail (); -extern uint32_t zdr_RENAME3res (); -extern uint32_t zdr_READDIRPLUS3args (); -extern uint32_t zdr_entryplus3 (); -extern uint32_t zdr_dirlistplus3 (); -extern uint32_t zdr_READDIRPLUS3resok (); -extern uint32_t zdr_READDIRPLUS3resfail (); -extern uint32_t zdr_READDIRPLUS3res (); -extern uint32_t zdr_READDIR3args (); -extern uint32_t zdr_entry3 (); -extern uint32_t zdr_dirlist3 (); -extern uint32_t zdr_READDIR3resok (); -extern uint32_t zdr_READDIR3resfail (); -extern uint32_t zdr_READDIR3res (); -extern uint32_t zdr_LINK3args (); -extern uint32_t zdr_LINK3resok (); -extern uint32_t zdr_LINK3resfail (); -extern uint32_t zdr_LINK3res (); -extern uint32_t zdr_sattrguard3 (); -extern uint32_t zdr_SETATTR3args (); -extern uint32_t zdr_SETATTR3resok (); -extern uint32_t zdr_SETATTR3resfail (); -extern uint32_t zdr_SETATTR3res (); -extern uint32_t zdr_fhandle2 (); -extern uint32_t zdr_ftype2 (); -extern uint32_t zdr_fattr2 (); -extern uint32_t zdr_sattr2 (); -extern uint32_t zdr_filename2 (); -extern uint32_t zdr_path2 (); -extern uint32_t zdr_nfsdata2 (); -extern uint32_t zdr_nfscookie2 (); -extern uint32_t zdr_entry2 (); -extern uint32_t zdr_diropargs2 (); -extern uint32_t zdr_GETATTR2args (); -extern uint32_t zdr_GETATTR2resok (); -extern uint32_t zdr_GETATTR2res (); -extern uint32_t zdr_SETATTR2args (); -extern uint32_t zdr_SETATTR2resok (); -extern uint32_t zdr_SETATTR2res (); -extern uint32_t zdr_LOOKUP2args (); -extern uint32_t zdr_LOOKUP2resok (); -extern uint32_t zdr_LOOKUP2res (); -extern uint32_t zdr_READLINK2args (); -extern uint32_t zdr_READLINK2resok (); -extern uint32_t zdr_READLINK2res (); -extern uint32_t zdr_READ2args (); -extern uint32_t zdr_READ2resok (); -extern uint32_t zdr_READ2res (); -extern uint32_t zdr_WRITE2args (); -extern uint32_t zdr_WRITE2resok (); -extern uint32_t zdr_WRITE2res (); -extern uint32_t zdr_CREATE2args (); -extern uint32_t zdr_CREATE2resok (); -extern uint32_t zdr_CREATE2res (); -extern uint32_t zdr_REMOVE2args (); -extern uint32_t zdr_REMOVE2res (); -extern uint32_t zdr_RENAME2args (); -extern uint32_t zdr_RENAME2res (); -extern uint32_t zdr_LINK2args (); -extern uint32_t zdr_LINK2res (); -extern uint32_t zdr_SYMLINK2args (); -extern uint32_t zdr_SYMLINK2res (); -extern uint32_t zdr_MKDIR2args (); -extern uint32_t zdr_MKDIR2resok (); -extern uint32_t zdr_MKDIR2res (); -extern uint32_t zdr_RMDIR2args (); -extern uint32_t zdr_RMDIR2res (); -extern uint32_t zdr_READDIR2args (); -extern uint32_t zdr_READDIR2resok (); -extern uint32_t zdr_READDIR2res (); -extern uint32_t zdr_STATFS2args (); -extern uint32_t zdr_STATFS2resok (); -extern uint32_t zdr_STATFS2res (); -extern uint32_t zdr_nfsacl_type (); -extern uint32_t zdr_nfsacl_ace (); -extern uint32_t zdr_GETACL3args (); -extern uint32_t zdr_GETACL3resok (); -extern uint32_t zdr_GETACL3res (); -extern uint32_t zdr_SETACL3args (); -extern uint32_t zdr_SETACL3resok (); -extern uint32_t zdr_SETACL3res (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NFS_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw-nfs4.h b/include/nfsc/libnfs-raw-nfs4.h deleted file mode 100644 index 9f70753..0000000 --- a/include/nfsc/libnfs-raw-nfs4.h +++ /dev/null @@ -1,1987 +0,0 @@ -/* This is based on RFC3530 which contains the following copyright statement: - - - Copyright (C) The Internet Society (2003). All Rights Reserved. - - This document and translations of it may be copied and furnished to - others, and derivative works that comment on or otherwise explain it - or assist in its implementation may be prepared, copied, published - and distributed, in whole or in part, without restriction of any - kind, provided that the above copyright notice and this paragraph are - included on all such copies and derivative works. However, this - document itself may not be modified in any way, such as by removing - the copyright notice or references to the Internet Society or other - Internet organizations, except as needed for the purpose of - developing Internet standards in which case the procedures for - copyrights defined in the Internet Standards process must be - followed, or as required to translate it into languages other than - English. - - The limited permissions granted above are perpetual and will not be - revoked by the Internet Society or its successors or assigns. - - This document and the information contained herein is provided on an - "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING - TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING - BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION - HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF - MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. -*/ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NFS4_H_RPCGEN -#define _NFS4_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define NFS4_FHSIZE 128 -#define NFS4_VERIFIER_SIZE 8 -#define NFS4_OPAQUE_LIMIT 1024 - -enum nfs_ftype4 { - NF4REG = 1, - NF4DIR = 2, - NF4BLK = 3, - NF4CHR = 4, - NF4LNK = 5, - NF4SOCK = 6, - NF4FIFO = 7, - NF4ATTRDIR = 8, - NF4NAMEDATTR = 9, -}; -typedef enum nfs_ftype4 nfs_ftype4; - -enum nfsstat4 { - NFS4_OK = 0, - NFS4ERR_PERM = 1, - NFS4ERR_NOENT = 2, - NFS4ERR_IO = 5, - NFS4ERR_NXIO = 6, - NFS4ERR_ACCESS = 13, - NFS4ERR_EXIST = 17, - NFS4ERR_XDEV = 18, - NFS4ERR_NOTDIR = 20, - NFS4ERR_ISDIR = 21, - NFS4ERR_INVAL = 22, - NFS4ERR_FBIG = 27, - NFS4ERR_NOSPC = 28, - NFS4ERR_ROFS = 30, - NFS4ERR_MLINK = 31, - NFS4ERR_NAMETOOLONG = 63, - NFS4ERR_NOTEMPTY = 66, - NFS4ERR_DQUOT = 69, - NFS4ERR_STALE = 70, - NFS4ERR_BADHANDLE = 10001, - NFS4ERR_BAD_COOKIE = 10003, - NFS4ERR_NOTSUPP = 10004, - NFS4ERR_TOOSMALL = 10005, - NFS4ERR_SERVERFAULT = 10006, - NFS4ERR_BADTYPE = 10007, - NFS4ERR_DELAY = 10008, - NFS4ERR_SAME = 10009, - NFS4ERR_DENIED = 10010, - NFS4ERR_EXPIRED = 10011, - NFS4ERR_LOCKED = 10012, - NFS4ERR_GRACE = 10013, - NFS4ERR_FHEXPIRED = 10014, - NFS4ERR_SHARE_DENIED = 10015, - NFS4ERR_WRONGSEC = 10016, - NFS4ERR_CLID_INUSE = 10017, - NFS4ERR_RESOURCE = 10018, - NFS4ERR_MOVED = 10019, - NFS4ERR_NOFILEHANDLE = 10020, - NFS4ERR_MINOR_VERS_MISMATCH = 10021, - NFS4ERR_STALE_CLIENTID = 10022, - NFS4ERR_STALE_STATEID = 10023, - NFS4ERR_OLD_STATEID = 10024, - NFS4ERR_BAD_STATEID = 10025, - NFS4ERR_BAD_SEQID = 10026, - NFS4ERR_NOT_SAME = 10027, - NFS4ERR_LOCK_RANGE = 10028, - NFS4ERR_SYMLINK = 10029, - NFS4ERR_RESTOREFH = 10030, - NFS4ERR_LEASE_MOVED = 10031, - NFS4ERR_ATTRNOTSUPP = 10032, - NFS4ERR_NO_GRACE = 10033, - NFS4ERR_RECLAIM_BAD = 10034, - NFS4ERR_RECLAIM_CONFLICT = 10035, - NFS4ERR_BADZDR = 10036, - NFS4ERR_LOCKS_HELD = 10037, - NFS4ERR_OPENMODE = 10038, - NFS4ERR_BADOWNER = 10039, - NFS4ERR_BADCHAR = 10040, - NFS4ERR_BADNAME = 10041, - NFS4ERR_BAD_RANGE = 10042, - NFS4ERR_LOCK_NOTSUPP = 10043, - NFS4ERR_OP_ILLEGAL = 10044, - NFS4ERR_DEADLOCK = 10045, - NFS4ERR_FILE_OPEN = 10046, - NFS4ERR_ADMIN_REVOKED = 10047, - NFS4ERR_CB_PATH_DOWN = 10048, -}; -typedef enum nfsstat4 nfsstat4; - -typedef struct { - u_int bitmap4_len; - uint32_t *bitmap4_val; -} bitmap4; - -typedef uint64_t offset4; - -typedef uint32_t count4; - -typedef uint64_t length4; - -typedef uint64_t clientid4; - -typedef uint32_t seqid4; - -typedef struct { - u_int utf8string_len; - char *utf8string_val; -} utf8string; - -typedef utf8string utf8str_cis; - -typedef utf8string utf8str_cs; - -typedef utf8string utf8str_mixed; - -typedef utf8str_cs component4; - -typedef struct { - u_int pathname4_len; - component4 *pathname4_val; -} pathname4; - -typedef uint64_t nfs_lockid4; - -typedef uint64_t nfs_cookie4; - -typedef utf8str_cs linktext4; - -typedef struct { - u_int sec_oid4_len; - char *sec_oid4_val; -} sec_oid4; - -typedef uint32_t qop4; - -typedef uint32_t mode4; - -typedef uint64_t changeid4; - -typedef char verifier4[NFS4_VERIFIER_SIZE]; - -struct nfstime4 { - int64_t seconds; - uint32_t nseconds; -}; -typedef struct nfstime4 nfstime4; - -enum time_how4 { - SET_TO_SERVER_TIME4 = 0, - SET_TO_CLIENT_TIME4 = 1, -}; -typedef enum time_how4 time_how4; - -struct settime4 { - time_how4 set_it; - union { - nfstime4 time; - } settime4_u; -}; -typedef struct settime4 settime4; - -typedef struct { - u_int nfs_fh4_len; - char *nfs_fh4_val; -} nfs_fh4; - -struct fsid4 { - uint64_t major; - uint64_t minor; -}; -typedef struct fsid4 fsid4; - -struct fs_location4 { - struct { - u_int server_len; - utf8str_cis *server_val; - } server; - pathname4 rootpath; -}; -typedef struct fs_location4 fs_location4; - -struct fs_locations4 { - pathname4 fs_root; - struct { - u_int locations_len; - fs_location4 *locations_val; - } locations; -}; -typedef struct fs_locations4 fs_locations4; -#define ACL4_SUPPORT_ALLOW_ACL 0x00000001 -#define ACL4_SUPPORT_DENY_ACL 0x00000002 -#define ACL4_SUPPORT_AUDIT_ACL 0x00000004 -#define ACL4_SUPPORT_ALARM_ACL 0x00000008 - -typedef uint32_t acetype4; -#define ACE4_ACCESS_ALLOWED_ACE_TYPE 0x00000000 -#define ACE4_ACCESS_DENIED_ACE_TYPE 0x00000001 -#define ACE4_SYSTEM_AUDIT_ACE_TYPE 0x00000002 -#define ACE4_SYSTEM_ALARM_ACE_TYPE 0x00000003 - -typedef uint32_t aceflag4; -#define ACE4_FILE_INHERIT_ACE 0x00000001 -#define ACE4_DIRECTORY_INHERIT_ACE 0x00000002 -#define ACE4_NO_PROPAGATE_INHERIT_ACE 0x00000004 -#define ACE4_INHERIT_ONLY_ACE 0x00000008 -#define ACE4_SUCCESSFUL_ACCESS_ACE_FLAG 0x00000010 -#define ACE4_FAILED_ACCESS_ACE_FLAG 0x00000020 -#define ACE4_IDENTIFIER_GROUP 0x00000040 - -typedef uint32_t acemask4; -#define ACE4_READ_DATA 0x00000001 -#define ACE4_LIST_DIRECTORY 0x00000001 -#define ACE4_WRITE_DATA 0x00000002 -#define ACE4_ADD_FILE 0x00000002 -#define ACE4_APPEND_DATA 0x00000004 -#define ACE4_ADD_SUBDIRECTORY 0x00000004 -#define ACE4_READ_NAMED_ATTRS 0x00000008 -#define ACE4_WRITE_NAMED_ATTRS 0x00000010 -#define ACE4_EXECUTE 0x00000020 -#define ACE4_DELETE_CHILD 0x00000040 -#define ACE4_READ_ATTRIBUTES 0x00000080 -#define ACE4_WRITE_ATTRIBUTES 0x00000100 -#define ACE4_DELETE 0x00010000 -#define ACE4_READ_ACL 0x00020000 -#define ACE4_WRITE_ACL 0x00040000 -#define ACE4_WRITE_OWNER 0x00080000 -#define ACE4_SYNCHRONIZE 0x00100000 -#define ACE4_GENERIC_READ 0x00120081 -#define ACE4_GENERIC_WRITE 0x00160106 -#define ACE4_GENERIC_EXECUTE 0x001200A0 - -struct nfsace4 { - acetype4 type; - aceflag4 flag; - acemask4 access_mask; - utf8str_mixed who; -}; -typedef struct nfsace4 nfsace4; -#define MODE4_SUID 0x800 -#define MODE4_SGID 0x400 -#define MODE4_SVTX 0x200 -#define MODE4_RUSR 0x100 -#define MODE4_WUSR 0x080 -#define MODE4_XUSR 0x040 -#define MODE4_RGRP 0x020 -#define MODE4_WGRP 0x010 -#define MODE4_XGRP 0x008 -#define MODE4_ROTH 0x004 -#define MODE4_WOTH 0x002 -#define MODE4_XOTH 0x001 - -struct specdata4 { - uint32_t specdata1; - uint32_t specdata2; -}; -typedef struct specdata4 specdata4; -#define FH4_PERSISTENT 0x00000000 -#define FH4_NOEXPIRE_WITH_OPEN 0x00000001 -#define FH4_VOLATILE_ANY 0x00000002 -#define FH4_VOL_MIGRATION 0x00000004 -#define FH4_VOL_RENAME 0x00000008 - -typedef bitmap4 fattr4_supported_attrs; - -typedef nfs_ftype4 fattr4_type; - -typedef uint32_t fattr4_fh_expire_type; - -typedef changeid4 fattr4_change; - -typedef uint64_t fattr4_size; - -typedef uint32_t fattr4_link_support; - -typedef uint32_t fattr4_symlink_support; - -typedef uint32_t fattr4_named_attr; - -typedef fsid4 fattr4_fsid; - -typedef uint32_t fattr4_unique_handles; - -typedef uint32_t fattr4_lease_time; - -typedef nfsstat4 fattr4_rdattr_error; - -typedef struct { - u_int fattr4_acl_len; - nfsace4 *fattr4_acl_val; -} fattr4_acl; - -typedef uint32_t fattr4_aclsupport; - -typedef uint32_t fattr4_archive; - -typedef uint32_t fattr4_cansettime; - -typedef uint32_t fattr4_case_insensitive; - -typedef uint32_t fattr4_case_preserving; - -typedef uint32_t fattr4_chown_restricted; - -typedef uint64_t fattr4_fileid; - -typedef uint64_t fattr4_files_avail; - -typedef nfs_fh4 fattr4_filehandle; - -typedef uint64_t fattr4_files_free; - -typedef uint64_t fattr4_files_total; - -typedef fs_locations4 fattr4_fs_locations; - -typedef uint32_t fattr4_hidden; - -typedef uint32_t fattr4_homogeneous; - -typedef uint64_t fattr4_maxfilesize; - -typedef uint32_t fattr4_maxlink; - -typedef uint32_t fattr4_maxname; - -typedef uint64_t fattr4_maxread; - -typedef uint64_t fattr4_maxwrite; - -typedef utf8str_cs fattr4_mimetype; - -typedef mode4 fattr4_mode; - -typedef uint64_t fattr4_mounted_on_fileid; - -typedef uint32_t fattr4_no_trunc; - -typedef uint32_t fattr4_numlinks; - -typedef utf8str_mixed fattr4_owner; - -typedef utf8str_mixed fattr4_owner_group; - -typedef uint64_t fattr4_quota_avail_hard; - -typedef uint64_t fattr4_quota_avail_soft; - -typedef uint64_t fattr4_quota_used; - -typedef specdata4 fattr4_rawdev; - -typedef uint64_t fattr4_space_avail; - -typedef uint64_t fattr4_space_free; - -typedef uint64_t fattr4_space_total; - -typedef uint64_t fattr4_space_used; - -typedef uint32_t fattr4_system; - -typedef nfstime4 fattr4_time_access; - -typedef settime4 fattr4_time_access_set; - -typedef nfstime4 fattr4_time_backup; - -typedef nfstime4 fattr4_time_create; - -typedef nfstime4 fattr4_time_delta; - -typedef nfstime4 fattr4_time_metadata; - -typedef nfstime4 fattr4_time_modify; - -typedef settime4 fattr4_time_modify_set; -#define FATTR4_SUPPORTED_ATTRS 0 -#define FATTR4_TYPE 1 -#define FATTR4_FH_EXPIRE_TYPE 2 -#define FATTR4_CHANGE 3 -#define FATTR4_SIZE 4 -#define FATTR4_LINK_SUPPORT 5 -#define FATTR4_SYMLINK_SUPPORT 6 -#define FATTR4_NAMED_ATTR 7 -#define FATTR4_FSID 8 -#define FATTR4_UNIQUE_HANDLES 9 -#define FATTR4_LEASE_TIME 10 -#define FATTR4_RDATTR_ERROR 11 -#define FATTR4_FILEHANDLE 19 -#define FATTR4_ACL 12 -#define FATTR4_ACLSUPPORT 13 -#define FATTR4_ARCHIVE 14 -#define FATTR4_CANSETTIME 15 -#define FATTR4_CASE_INSENSITIVE 16 -#define FATTR4_CASE_PRESERVING 17 -#define FATTR4_CHOWN_RESTRICTED 18 -#define FATTR4_FILEID 20 -#define FATTR4_FILES_AVAIL 21 -#define FATTR4_FILES_FREE 22 -#define FATTR4_FILES_TOTAL 23 -#define FATTR4_FS_LOCATIONS 24 -#define FATTR4_HIDDEN 25 -#define FATTR4_HOMOGENEOUS 26 -#define FATTR4_MAXFILESIZE 27 -#define FATTR4_MAXLINK 28 -#define FATTR4_MAXNAME 29 -#define FATTR4_MAXREAD 30 -#define FATTR4_MAXWRITE 31 -#define FATTR4_MIMETYPE 32 -#define FATTR4_MODE 33 -#define FATTR4_NO_TRUNC 34 -#define FATTR4_NUMLINKS 35 -#define FATTR4_OWNER 36 -#define FATTR4_OWNER_GROUP 37 -#define FATTR4_QUOTA_AVAIL_HARD 38 -#define FATTR4_QUOTA_AVAIL_SOFT 39 -#define FATTR4_QUOTA_USED 40 -#define FATTR4_RAWDEV 41 -#define FATTR4_SPACE_AVAIL 42 -#define FATTR4_SPACE_FREE 43 -#define FATTR4_SPACE_TOTAL 44 -#define FATTR4_SPACE_USED 45 -#define FATTR4_SYSTEM 46 -#define FATTR4_TIME_ACCESS 47 -#define FATTR4_TIME_ACCESS_SET 48 -#define FATTR4_TIME_BACKUP 49 -#define FATTR4_TIME_CREATE 50 -#define FATTR4_TIME_DELTA 51 -#define FATTR4_TIME_METADATA 52 -#define FATTR4_TIME_MODIFY 53 -#define FATTR4_TIME_MODIFY_SET 54 -#define FATTR4_MOUNTED_ON_FILEID 55 - -typedef struct { - u_int attrlist4_len; - char *attrlist4_val; -} attrlist4; - -struct fattr4 { - bitmap4 attrmask; - attrlist4 attr_vals; -}; -typedef struct fattr4 fattr4; - -struct change_info4 { - uint32_t atomic; - changeid4 before; - changeid4 after; -}; -typedef struct change_info4 change_info4; - -struct clientaddr4 { - char *r_netid; - char *r_addr; -}; -typedef struct clientaddr4 clientaddr4; - -struct cb_client4 { - uint32_t cb_program; - clientaddr4 cb_location; -}; -typedef struct cb_client4 cb_client4; - -struct stateid4 { - uint32_t seqid; - char other[12]; -}; -typedef struct stateid4 stateid4; - -struct nfs_client_id4 { - verifier4 verifier; - struct { - u_int id_len; - char *id_val; - } id; -}; -typedef struct nfs_client_id4 nfs_client_id4; - -struct open_owner4 { - clientid4 clientid; - struct { - u_int owner_len; - char *owner_val; - } owner; -}; -typedef struct open_owner4 open_owner4; - -struct lock_owner4 { - clientid4 clientid; - struct { - u_int owner_len; - char *owner_val; - } owner; -}; -typedef struct lock_owner4 lock_owner4; - -enum nfs_lock_type4 { - READ_LT = 1, - WRITE_LT = 2, - READW_LT = 3, - WRITEW_LT = 4, -}; -typedef enum nfs_lock_type4 nfs_lock_type4; -#define ACCESS4_READ 0x00000001 -#define ACCESS4_LOOKUP 0x00000002 -#define ACCESS4_MODIFY 0x00000004 -#define ACCESS4_EXTEND 0x00000008 -#define ACCESS4_DELETE 0x00000010 -#define ACCESS4_EXECUTE 0x00000020 - -struct ACCESS4args { - uint32_t access; -}; -typedef struct ACCESS4args ACCESS4args; - -struct ACCESS4resok { - uint32_t supported; - uint32_t access; -}; -typedef struct ACCESS4resok ACCESS4resok; - -struct ACCESS4res { - nfsstat4 status; - union { - ACCESS4resok resok4; - } ACCESS4res_u; -}; -typedef struct ACCESS4res ACCESS4res; - -struct CLOSE4args { - seqid4 seqid; - stateid4 open_stateid; -}; -typedef struct CLOSE4args CLOSE4args; - -struct CLOSE4res { - nfsstat4 status; - union { - stateid4 open_stateid; - } CLOSE4res_u; -}; -typedef struct CLOSE4res CLOSE4res; - -struct COMMIT4args { - offset4 offset; - count4 count; -}; -typedef struct COMMIT4args COMMIT4args; - -struct COMMIT4resok { - verifier4 writeverf; -}; -typedef struct COMMIT4resok COMMIT4resok; - -struct COMMIT4res { - nfsstat4 status; - union { - COMMIT4resok resok4; - } COMMIT4res_u; -}; -typedef struct COMMIT4res COMMIT4res; - -struct createtype4 { - nfs_ftype4 type; - union { - linktext4 linkdata; - specdata4 devdata; - } createtype4_u; -}; -typedef struct createtype4 createtype4; - -struct CREATE4args { - createtype4 objtype; - component4 objname; - fattr4 createattrs; -}; -typedef struct CREATE4args CREATE4args; - -struct CREATE4resok { - change_info4 cinfo; - bitmap4 attrset; -}; -typedef struct CREATE4resok CREATE4resok; - -struct CREATE4res { - nfsstat4 status; - union { - CREATE4resok resok4; - } CREATE4res_u; -}; -typedef struct CREATE4res CREATE4res; - -struct DELEGPURGE4args { - clientid4 clientid; -}; -typedef struct DELEGPURGE4args DELEGPURGE4args; - -struct DELEGPURGE4res { - nfsstat4 status; -}; -typedef struct DELEGPURGE4res DELEGPURGE4res; - -struct DELEGRETURN4args { - stateid4 deleg_stateid; -}; -typedef struct DELEGRETURN4args DELEGRETURN4args; - -struct DELEGRETURN4res { - nfsstat4 status; -}; -typedef struct DELEGRETURN4res DELEGRETURN4res; - -struct GETATTR4args { - bitmap4 attr_request; -}; -typedef struct GETATTR4args GETATTR4args; - -struct GETATTR4resok { - fattr4 obj_attributes; -}; -typedef struct GETATTR4resok GETATTR4resok; - -struct GETATTR4res { - nfsstat4 status; - union { - GETATTR4resok resok4; - } GETATTR4res_u; -}; -typedef struct GETATTR4res GETATTR4res; - -struct GETFH4resok { - nfs_fh4 object; -}; -typedef struct GETFH4resok GETFH4resok; - -struct GETFH4res { - nfsstat4 status; - union { - GETFH4resok resok4; - } GETFH4res_u; -}; -typedef struct GETFH4res GETFH4res; - -struct LINK4args { - component4 newname; -}; -typedef struct LINK4args LINK4args; - -struct LINK4resok { - change_info4 cinfo; -}; -typedef struct LINK4resok LINK4resok; - -struct LINK4res { - nfsstat4 status; - union { - LINK4resok resok4; - } LINK4res_u; -}; -typedef struct LINK4res LINK4res; - -struct open_to_lock_owner4 { - seqid4 open_seqid; - stateid4 open_stateid; - seqid4 lock_seqid; - lock_owner4 lock_owner; -}; -typedef struct open_to_lock_owner4 open_to_lock_owner4; - -struct exist_lock_owner4 { - stateid4 lock_stateid; - seqid4 lock_seqid; -}; -typedef struct exist_lock_owner4 exist_lock_owner4; - -struct locker4 { - uint32_t new_lock_owner; - union { - open_to_lock_owner4 open_owner; - exist_lock_owner4 lock_owner; - } locker4_u; -}; -typedef struct locker4 locker4; - -struct LOCK4args { - nfs_lock_type4 locktype; - uint32_t reclaim; - offset4 offset; - length4 length; - locker4 locker; -}; -typedef struct LOCK4args LOCK4args; - -struct LOCK4denied { - offset4 offset; - length4 length; - nfs_lock_type4 locktype; - lock_owner4 owner; -}; -typedef struct LOCK4denied LOCK4denied; - -struct LOCK4resok { - stateid4 lock_stateid; -}; -typedef struct LOCK4resok LOCK4resok; - -struct LOCK4res { - nfsstat4 status; - union { - LOCK4resok resok4; - LOCK4denied denied; - } LOCK4res_u; -}; -typedef struct LOCK4res LOCK4res; - -struct LOCKT4args { - nfs_lock_type4 locktype; - offset4 offset; - length4 length; - lock_owner4 owner; -}; -typedef struct LOCKT4args LOCKT4args; - -struct LOCKT4res { - nfsstat4 status; - union { - LOCK4denied denied; - } LOCKT4res_u; -}; -typedef struct LOCKT4res LOCKT4res; - -struct LOCKU4args { - nfs_lock_type4 locktype; - seqid4 seqid; - stateid4 lock_stateid; - offset4 offset; - length4 length; -}; -typedef struct LOCKU4args LOCKU4args; - -struct LOCKU4res { - nfsstat4 status; - union { - stateid4 lock_stateid; - } LOCKU4res_u; -}; -typedef struct LOCKU4res LOCKU4res; - -struct LOOKUP4args { - component4 objname; -}; -typedef struct LOOKUP4args LOOKUP4args; - -struct LOOKUP4res { - nfsstat4 status; -}; -typedef struct LOOKUP4res LOOKUP4res; - -struct LOOKUPP4res { - nfsstat4 status; -}; -typedef struct LOOKUPP4res LOOKUPP4res; - -struct NVERIFY4args { - fattr4 obj_attributes; -}; -typedef struct NVERIFY4args NVERIFY4args; - -struct NVERIFY4res { - nfsstat4 status; -}; -typedef struct NVERIFY4res NVERIFY4res; - -enum createmode4 { - UNCHECKED4 = 0, - GUARDED4 = 1, - EXCLUSIVE4 = 2, -}; -typedef enum createmode4 createmode4; - -struct createhow4 { - createmode4 mode; - union { - fattr4 createattrs; - verifier4 createverf; - } createhow4_u; -}; -typedef struct createhow4 createhow4; - -enum opentype4 { - OPEN4_NOCREATE = 0, - OPEN4_CREATE = 1, -}; -typedef enum opentype4 opentype4; - -struct openflag4 { - opentype4 opentype; - union { - createhow4 how; - } openflag4_u; -}; -typedef struct openflag4 openflag4; - -enum limit_by4 { - NFS_LIMIT_SIZE = 1, - NFS_LIMIT_BLOCKS = 2, -}; -typedef enum limit_by4 limit_by4; - -struct nfs_modified_limit4 { - uint32_t num_blocks; - uint32_t bytes_per_block; -}; -typedef struct nfs_modified_limit4 nfs_modified_limit4; - -struct nfs_space_limit4 { - limit_by4 limitby; - union { - uint64_t filesize; - nfs_modified_limit4 mod_blocks; - } nfs_space_limit4_u; -}; -typedef struct nfs_space_limit4 nfs_space_limit4; -#define OPEN4_SHARE_ACCESS_READ 0x00000001 -#define OPEN4_SHARE_ACCESS_WRITE 0x00000002 -#define OPEN4_SHARE_ACCESS_BOTH 0x00000003 -#define OPEN4_SHARE_DENY_NONE 0x00000000 -#define OPEN4_SHARE_DENY_READ 0x00000001 -#define OPEN4_SHARE_DENY_WRITE 0x00000002 -#define OPEN4_SHARE_DENY_BOTH 0x00000003 - -enum open_delegation_type4 { - OPEN_DELEGATE_NONE = 0, - OPEN_DELEGATE_READ = 1, - OPEN_DELEGATE_WRITE = 2, -}; -typedef enum open_delegation_type4 open_delegation_type4; - -enum open_claim_type4 { - CLAIM_NULL = 0, - CLAIM_PREVIOUS = 1, - CLAIM_DELEGATE_CUR = 2, - CLAIM_DELEGATE_PREV = 3, -}; -typedef enum open_claim_type4 open_claim_type4; - -struct open_claim_delegate_cur4 { - stateid4 delegate_stateid; - component4 file; -}; -typedef struct open_claim_delegate_cur4 open_claim_delegate_cur4; - -struct open_claim4 { - open_claim_type4 claim; - union { - component4 file; - open_delegation_type4 delegate_type; - open_claim_delegate_cur4 delegate_cur_info; - component4 file_delegate_prev; - } open_claim4_u; -}; -typedef struct open_claim4 open_claim4; - -struct OPEN4args { - seqid4 seqid; - uint32_t share_access; - uint32_t share_deny; - open_owner4 owner; - openflag4 openhow; - open_claim4 claim; -}; -typedef struct OPEN4args OPEN4args; - -struct open_read_delegation4 { - stateid4 stateid; - uint32_t recall; - nfsace4 permissions; -}; -typedef struct open_read_delegation4 open_read_delegation4; - -struct open_write_delegation4 { - stateid4 stateid; - uint32_t recall; - nfs_space_limit4 space_limit; - nfsace4 permissions; -}; -typedef struct open_write_delegation4 open_write_delegation4; - -struct open_delegation4 { - open_delegation_type4 delegation_type; - union { - open_read_delegation4 read; - open_write_delegation4 write; - } open_delegation4_u; -}; -typedef struct open_delegation4 open_delegation4; -#define OPEN4_RESULT_CONFIRM 0x00000002 -#define OPEN4_RESULT_LOCKTYPE_POSIX 0x00000004 - -struct OPEN4resok { - stateid4 stateid; - change_info4 cinfo; - uint32_t rflags; - bitmap4 attrset; - open_delegation4 delegation; -}; -typedef struct OPEN4resok OPEN4resok; - -struct OPEN4res { - nfsstat4 status; - union { - OPEN4resok resok4; - } OPEN4res_u; -}; -typedef struct OPEN4res OPEN4res; - -struct OPENATTR4args { - uint32_t createdir; -}; -typedef struct OPENATTR4args OPENATTR4args; - -struct OPENATTR4res { - nfsstat4 status; -}; -typedef struct OPENATTR4res OPENATTR4res; - -struct OPEN_CONFIRM4args { - stateid4 open_stateid; - seqid4 seqid; -}; -typedef struct OPEN_CONFIRM4args OPEN_CONFIRM4args; - -struct OPEN_CONFIRM4resok { - stateid4 open_stateid; -}; -typedef struct OPEN_CONFIRM4resok OPEN_CONFIRM4resok; - -struct OPEN_CONFIRM4res { - nfsstat4 status; - union { - OPEN_CONFIRM4resok resok4; - } OPEN_CONFIRM4res_u; -}; -typedef struct OPEN_CONFIRM4res OPEN_CONFIRM4res; - -struct OPEN_DOWNGRADE4args { - stateid4 open_stateid; - seqid4 seqid; - uint32_t share_access; - uint32_t share_deny; -}; -typedef struct OPEN_DOWNGRADE4args OPEN_DOWNGRADE4args; - -struct OPEN_DOWNGRADE4resok { - stateid4 open_stateid; -}; -typedef struct OPEN_DOWNGRADE4resok OPEN_DOWNGRADE4resok; - -struct OPEN_DOWNGRADE4res { - nfsstat4 status; - union { - OPEN_DOWNGRADE4resok resok4; - } OPEN_DOWNGRADE4res_u; -}; -typedef struct OPEN_DOWNGRADE4res OPEN_DOWNGRADE4res; - -struct PUTFH4args { - nfs_fh4 object; -}; -typedef struct PUTFH4args PUTFH4args; - -struct PUTFH4res { - nfsstat4 status; -}; -typedef struct PUTFH4res PUTFH4res; - -struct PUTPUBFH4res { - nfsstat4 status; -}; -typedef struct PUTPUBFH4res PUTPUBFH4res; - -struct PUTROOTFH4res { - nfsstat4 status; -}; -typedef struct PUTROOTFH4res PUTROOTFH4res; - -struct READ4args { - stateid4 stateid; - offset4 offset; - count4 count; -}; -typedef struct READ4args READ4args; - -struct READ4resok { - uint32_t eof; - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct READ4resok READ4resok; - -struct READ4res { - nfsstat4 status; - union { - READ4resok resok4; - } READ4res_u; -}; -typedef struct READ4res READ4res; - -struct READDIR4args { - nfs_cookie4 cookie; - verifier4 cookieverf; - count4 dircount; - count4 maxcount; - bitmap4 attr_request; -}; -typedef struct READDIR4args READDIR4args; - -struct entry4 { - nfs_cookie4 cookie; - component4 name; - fattr4 attrs; - struct entry4 *nextentry; -}; -typedef struct entry4 entry4; - -struct dirlist4 { - entry4 *entries; - uint32_t eof; -}; -typedef struct dirlist4 dirlist4; - -struct READDIR4resok { - verifier4 cookieverf; - dirlist4 reply; -}; -typedef struct READDIR4resok READDIR4resok; - -struct READDIR4res { - nfsstat4 status; - union { - READDIR4resok resok4; - } READDIR4res_u; -}; -typedef struct READDIR4res READDIR4res; - -struct READLINK4resok { - linktext4 link; -}; -typedef struct READLINK4resok READLINK4resok; - -struct READLINK4res { - nfsstat4 status; - union { - READLINK4resok resok4; - } READLINK4res_u; -}; -typedef struct READLINK4res READLINK4res; - -struct REMOVE4args { - component4 target; -}; -typedef struct REMOVE4args REMOVE4args; - -struct REMOVE4resok { - change_info4 cinfo; -}; -typedef struct REMOVE4resok REMOVE4resok; - -struct REMOVE4res { - nfsstat4 status; - union { - REMOVE4resok resok4; - } REMOVE4res_u; -}; -typedef struct REMOVE4res REMOVE4res; - -struct RENAME4args { - component4 oldname; - component4 newname; -}; -typedef struct RENAME4args RENAME4args; - -struct RENAME4resok { - change_info4 source_cinfo; - change_info4 target_cinfo; -}; -typedef struct RENAME4resok RENAME4resok; - -struct RENAME4res { - nfsstat4 status; - union { - RENAME4resok resok4; - } RENAME4res_u; -}; -typedef struct RENAME4res RENAME4res; - -struct RENEW4args { - clientid4 clientid; -}; -typedef struct RENEW4args RENEW4args; - -struct RENEW4res { - nfsstat4 status; -}; -typedef struct RENEW4res RENEW4res; - -struct RESTOREFH4res { - nfsstat4 status; -}; -typedef struct RESTOREFH4res RESTOREFH4res; - -struct SAVEFH4res { - nfsstat4 status; -}; -typedef struct SAVEFH4res SAVEFH4res; - -struct SETATTR4args { - stateid4 stateid; - fattr4 obj_attributes; -}; -typedef struct SETATTR4args SETATTR4args; - -struct SETATTR4res { - nfsstat4 status; - bitmap4 attrsset; -}; -typedef struct SETATTR4res SETATTR4res; - -struct SETCLIENTID4args { - nfs_client_id4 client; - cb_client4 callback; - uint32_t callback_ident; -}; -typedef struct SETCLIENTID4args SETCLIENTID4args; - -struct SETCLIENTID4resok { - clientid4 clientid; - verifier4 setclientid_confirm; -}; -typedef struct SETCLIENTID4resok SETCLIENTID4resok; - -struct SETCLIENTID4res { - nfsstat4 status; - union { - SETCLIENTID4resok resok4; - clientaddr4 client_using; - } SETCLIENTID4res_u; -}; -typedef struct SETCLIENTID4res SETCLIENTID4res; - -struct SETCLIENTID_CONFIRM4args { - clientid4 clientid; - verifier4 setclientid_confirm; -}; -typedef struct SETCLIENTID_CONFIRM4args SETCLIENTID_CONFIRM4args; - -struct SETCLIENTID_CONFIRM4res { - nfsstat4 status; -}; -typedef struct SETCLIENTID_CONFIRM4res SETCLIENTID_CONFIRM4res; - -struct VERIFY4args { - fattr4 obj_attributes; -}; -typedef struct VERIFY4args VERIFY4args; - -struct VERIFY4res { - nfsstat4 status; -}; -typedef struct VERIFY4res VERIFY4res; - -enum stable_how4 { - UNSTABLE4 = 0, - DATA_SYNC4 = 1, - FILE_SYNC4 = 2, -}; -typedef enum stable_how4 stable_how4; - -struct WRITE4args { - stateid4 stateid; - offset4 offset; - stable_how4 stable; - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct WRITE4args WRITE4args; - -struct WRITE4resok { - count4 count; - stable_how4 committed; - verifier4 writeverf; -}; -typedef struct WRITE4resok WRITE4resok; - -struct WRITE4res { - nfsstat4 status; - union { - WRITE4resok resok4; - } WRITE4res_u; -}; -typedef struct WRITE4res WRITE4res; - -struct RELEASE_LOCKOWNER4args { - lock_owner4 lock_owner; -}; -typedef struct RELEASE_LOCKOWNER4args RELEASE_LOCKOWNER4args; - -struct RELEASE_LOCKOWNER4res { - nfsstat4 status; -}; -typedef struct RELEASE_LOCKOWNER4res RELEASE_LOCKOWNER4res; - -struct ILLEGAL4res { - nfsstat4 status; -}; -typedef struct ILLEGAL4res ILLEGAL4res; - -enum nfs_opnum4 { - OP_ACCESS = 3, - OP_CLOSE = 4, - OP_COMMIT = 5, - OP_CREATE = 6, - OP_DELEGPURGE = 7, - OP_DELEGRETURN = 8, - OP_GETATTR = 9, - OP_GETFH = 10, - OP_LINK = 11, - OP_LOCK = 12, - OP_LOCKT = 13, - OP_LOCKU = 14, - OP_LOOKUP = 15, - OP_LOOKUPP = 16, - OP_NVERIFY = 17, - OP_OPEN = 18, - OP_OPENATTR = 19, - OP_OPEN_CONFIRM = 20, - OP_OPEN_DOWNGRADE = 21, - OP_PUTFH = 22, - OP_PUTPUBFH = 23, - OP_PUTROOTFH = 24, - OP_READ = 25, - OP_READDIR = 26, - OP_READLINK = 27, - OP_REMOVE = 28, - OP_RENAME = 29, - OP_RENEW = 30, - OP_RESTOREFH = 31, - OP_SAVEFH = 32, - OP_SECINFO = 33, - OP_SETATTR = 34, - OP_SETCLIENTID = 35, - OP_SETCLIENTID_CONFIRM = 36, - OP_VERIFY = 37, - OP_WRITE = 38, - OP_RELEASE_LOCKOWNER = 39, - OP_ILLEGAL = 10044, -}; -typedef enum nfs_opnum4 nfs_opnum4; - -struct nfs_argop4 { - nfs_opnum4 argop; - union { - ACCESS4args opaccess; - CLOSE4args opclose; - COMMIT4args opcommit; - CREATE4args opcreate; - DELEGPURGE4args opdelegpurge; - DELEGRETURN4args opdelegreturn; - GETATTR4args opgetattr; - LINK4args oplink; - LOCK4args oplock; - LOCKT4args oplockt; - LOCKU4args oplocku; - LOOKUP4args oplookup; - NVERIFY4args opnverify; - OPEN4args opopen; - OPENATTR4args opopenattr; - OPEN_CONFIRM4args opopen_confirm; - OPEN_DOWNGRADE4args opopen_downgrade; - PUTFH4args opputfh; - READ4args opread; - READDIR4args opreaddir; - REMOVE4args opremove; - RENAME4args oprename; - RENEW4args oprenew; - SETATTR4args opsetattr; - SETCLIENTID4args opsetclientid; - SETCLIENTID_CONFIRM4args opsetclientid_confirm; - VERIFY4args opverify; - WRITE4args opwrite; - RELEASE_LOCKOWNER4args oprelease_lockowner; - } nfs_argop4_u; -}; -typedef struct nfs_argop4 nfs_argop4; - -struct nfs_resop4 { - nfs_opnum4 resop; - union { - ACCESS4res opaccess; - CLOSE4res opclose; - COMMIT4res opcommit; - CREATE4res opcreate; - DELEGPURGE4res opdelegpurge; - DELEGRETURN4res opdelegreturn; - GETATTR4res opgetattr; - GETFH4res opgetfh; - LINK4res oplink; - LOCK4res oplock; - LOCKT4res oplockt; - LOCKU4res oplocku; - LOOKUP4res oplookup; - LOOKUPP4res oplookupp; - NVERIFY4res opnverify; - OPEN4res opopen; - OPENATTR4res opopenattr; - OPEN_CONFIRM4res opopen_confirm; - OPEN_DOWNGRADE4res opopen_downgrade; - PUTFH4res opputfh; - PUTPUBFH4res opputpubfh; - PUTROOTFH4res opputrootfh; - READ4res opread; - READDIR4res opreaddir; - READLINK4res opreadlink; - REMOVE4res opremove; - RENAME4res oprename; - RENEW4res oprenew; - RESTOREFH4res oprestorefh; - SAVEFH4res opsavefh; - SETATTR4res opsetattr; - SETCLIENTID4res opsetclientid; - SETCLIENTID_CONFIRM4res opsetclientid_confirm; - VERIFY4res opverify; - WRITE4res opwrite; - RELEASE_LOCKOWNER4res oprelease_lockowner; - ILLEGAL4res opillegal; - } nfs_resop4_u; -}; -typedef struct nfs_resop4 nfs_resop4; - -struct COMPOUND4args { - utf8str_cs tag; - uint32_t minorversion; - struct { - u_int argarray_len; - nfs_argop4 *argarray_val; - } argarray; -}; -typedef struct COMPOUND4args COMPOUND4args; - -struct COMPOUND4res { - nfsstat4 status; - utf8str_cs tag; - struct { - u_int resarray_len; - nfs_resop4 *resarray_val; - } resarray; -}; -typedef struct COMPOUND4res COMPOUND4res; - -struct CB_GETATTR4args { - nfs_fh4 fh; - bitmap4 attr_request; -}; -typedef struct CB_GETATTR4args CB_GETATTR4args; - -struct CB_GETATTR4resok { - fattr4 obj_attributes; -}; -typedef struct CB_GETATTR4resok CB_GETATTR4resok; - -struct CB_GETATTR4res { - nfsstat4 status; - union { - CB_GETATTR4resok resok4; - } CB_GETATTR4res_u; -}; -typedef struct CB_GETATTR4res CB_GETATTR4res; - -struct CB_RECALL4args { - stateid4 stateid; - uint32_t truncate; - nfs_fh4 fh; -}; -typedef struct CB_RECALL4args CB_RECALL4args; - -struct CB_RECALL4res { - nfsstat4 status; -}; -typedef struct CB_RECALL4res CB_RECALL4res; - -struct CB_ILLEGAL4res { - nfsstat4 status; -}; -typedef struct CB_ILLEGAL4res CB_ILLEGAL4res; - -enum nfs_cb_opnum4 { - OP_CB_GETATTR = 3, - OP_CB_RECALL = 4, - OP_CB_ILLEGAL = 10044, -}; -typedef enum nfs_cb_opnum4 nfs_cb_opnum4; - -struct nfs_cb_argop4 { - u_int argop; - union { - CB_GETATTR4args opcbgetattr; - CB_RECALL4args opcbrecall; - } nfs_cb_argop4_u; -}; -typedef struct nfs_cb_argop4 nfs_cb_argop4; - -struct nfs_cb_resop4 { - u_int resop; - union { - CB_GETATTR4res opcbgetattr; - CB_RECALL4res opcbrecall; - CB_ILLEGAL4res opcbillegal; - } nfs_cb_resop4_u; -}; -typedef struct nfs_cb_resop4 nfs_cb_resop4; - -struct CB_COMPOUND4args { - utf8str_cs tag; - uint32_t minorversion; - uint32_t callback_ident; - struct { - u_int argarray_len; - nfs_cb_argop4 *argarray_val; - } argarray; -}; -typedef struct CB_COMPOUND4args CB_COMPOUND4args; - -struct CB_COMPOUND4res { - nfsstat4 status; - utf8str_cs tag; - struct { - u_int resarray_len; - nfs_cb_resop4 *resarray_val; - } resarray; -}; -typedef struct CB_COMPOUND4res CB_COMPOUND4res; - -#define NFS4_PROGRAM 100003 -#define NFS_V4 4 - -#if defined(__STDC__) || defined(__cplusplus) -#define NFSPROC4_NULL 0 -extern void * nfsproc4_null_4(void *, void *); -extern void * nfsproc4_null_4_svc(void *, struct svc_req *); -#define NFSPROC4_COMPOUND 1 -extern COMPOUND4res * nfsproc4_compound_4(COMPOUND4args *, void *); -extern COMPOUND4res * nfsproc4_compound_4_svc(COMPOUND4args *, struct svc_req *); -extern int nfs4_program_4_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define NFSPROC4_NULL 0 -extern void * nfsproc4_null_4(); -extern void * nfsproc4_null_4_svc(); -#define NFSPROC4_COMPOUND 1 -extern COMPOUND4res * nfsproc4_compound_4(); -extern COMPOUND4res * nfsproc4_compound_4_svc(); -extern int nfs4_program_4_freeresult (); -#endif /* K&R C */ - -#define NFS4_CALLBACK 0x40000000 -#define NFS_CB 1 - -#if defined(__STDC__) || defined(__cplusplus) -#define CB_NULL 0 -extern void * cb_null_1(void *, void *); -extern void * cb_null_1_svc(void *, struct svc_req *); -#define CB_COMPOUND 1 -extern CB_COMPOUND4res * cb_compound_1(CB_COMPOUND4args *, void *); -extern CB_COMPOUND4res * cb_compound_1_svc(CB_COMPOUND4args *, struct svc_req *); -extern int nfs4_callback_1_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define CB_NULL 0 -extern void * cb_null_1(); -extern void * cb_null_1_svc(); -#define CB_COMPOUND 1 -extern CB_COMPOUND4res * cb_compound_1(); -extern CB_COMPOUND4res * cb_compound_1_svc(); -extern int nfs4_callback_1_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_nfs_ftype4 (ZDR *, nfs_ftype4*); -extern uint32_t zdr_nfsstat4 (ZDR *, nfsstat4*); -extern uint32_t zdr_bitmap4 (ZDR *, bitmap4*); -extern uint32_t zdr_offset4 (ZDR *, offset4*); -extern uint32_t zdr_count4 (ZDR *, count4*); -extern uint32_t zdr_length4 (ZDR *, length4*); -extern uint32_t zdr_clientid4 (ZDR *, clientid4*); -extern uint32_t zdr_seqid4 (ZDR *, seqid4*); -extern uint32_t zdr_utf8string (ZDR *, utf8string*); -extern uint32_t zdr_utf8str_cis (ZDR *, utf8str_cis*); -extern uint32_t zdr_utf8str_cs (ZDR *, utf8str_cs*); -extern uint32_t zdr_utf8str_mixed (ZDR *, utf8str_mixed*); -extern uint32_t zdr_component4 (ZDR *, component4*); -extern uint32_t zdr_pathname4 (ZDR *, pathname4*); -extern uint32_t zdr_nfs_lockid4 (ZDR *, nfs_lockid4*); -extern uint32_t zdr_nfs_cookie4 (ZDR *, nfs_cookie4*); -extern uint32_t zdr_linktext4 (ZDR *, linktext4*); -extern uint32_t zdr_sec_oid4 (ZDR *, sec_oid4*); -extern uint32_t zdr_qop4 (ZDR *, qop4*); -extern uint32_t zdr_mode4 (ZDR *, mode4*); -extern uint32_t zdr_changeid4 (ZDR *, changeid4*); -extern uint32_t zdr_verifier4 (ZDR *, verifier4); -extern uint32_t zdr_nfstime4 (ZDR *, nfstime4*); -extern uint32_t zdr_time_how4 (ZDR *, time_how4*); -extern uint32_t zdr_settime4 (ZDR *, settime4*); -extern uint32_t zdr_nfs_fh4 (ZDR *, nfs_fh4*); -extern uint32_t zdr_fsid4 (ZDR *, fsid4*); -extern uint32_t zdr_fs_location4 (ZDR *, fs_location4*); -extern uint32_t zdr_fs_locations4 (ZDR *, fs_locations4*); -extern uint32_t zdr_acetype4 (ZDR *, acetype4*); -extern uint32_t zdr_aceflag4 (ZDR *, aceflag4*); -extern uint32_t zdr_acemask4 (ZDR *, acemask4*); -extern uint32_t zdr_nfsace4 (ZDR *, nfsace4*); -extern uint32_t zdr_specdata4 (ZDR *, specdata4*); -extern uint32_t zdr_fattr4_supported_attrs (ZDR *, fattr4_supported_attrs*); -extern uint32_t zdr_fattr4_type (ZDR *, fattr4_type*); -extern uint32_t zdr_fattr4_fh_expire_type (ZDR *, fattr4_fh_expire_type*); -extern uint32_t zdr_fattr4_change (ZDR *, fattr4_change*); -extern uint32_t zdr_fattr4_size (ZDR *, fattr4_size*); -extern uint32_t zdr_fattr4_link_support (ZDR *, fattr4_link_support*); -extern uint32_t zdr_fattr4_symlink_support (ZDR *, fattr4_symlink_support*); -extern uint32_t zdr_fattr4_named_attr (ZDR *, fattr4_named_attr*); -extern uint32_t zdr_fattr4_fsid (ZDR *, fattr4_fsid*); -extern uint32_t zdr_fattr4_unique_handles (ZDR *, fattr4_unique_handles*); -extern uint32_t zdr_fattr4_lease_time (ZDR *, fattr4_lease_time*); -extern uint32_t zdr_fattr4_rdattr_error (ZDR *, fattr4_rdattr_error*); -extern uint32_t zdr_fattr4_acl (ZDR *, fattr4_acl*); -extern uint32_t zdr_fattr4_aclsupport (ZDR *, fattr4_aclsupport*); -extern uint32_t zdr_fattr4_archive (ZDR *, fattr4_archive*); -extern uint32_t zdr_fattr4_cansettime (ZDR *, fattr4_cansettime*); -extern uint32_t zdr_fattr4_case_insensitive (ZDR *, fattr4_case_insensitive*); -extern uint32_t zdr_fattr4_case_preserving (ZDR *, fattr4_case_preserving*); -extern uint32_t zdr_fattr4_chown_restricted (ZDR *, fattr4_chown_restricted*); -extern uint32_t zdr_fattr4_fileid (ZDR *, fattr4_fileid*); -extern uint32_t zdr_fattr4_files_avail (ZDR *, fattr4_files_avail*); -extern uint32_t zdr_fattr4_filehandle (ZDR *, fattr4_filehandle*); -extern uint32_t zdr_fattr4_files_free (ZDR *, fattr4_files_free*); -extern uint32_t zdr_fattr4_files_total (ZDR *, fattr4_files_total*); -extern uint32_t zdr_fattr4_fs_locations (ZDR *, fattr4_fs_locations*); -extern uint32_t zdr_fattr4_hidden (ZDR *, fattr4_hidden*); -extern uint32_t zdr_fattr4_homogeneous (ZDR *, fattr4_homogeneous*); -extern uint32_t zdr_fattr4_maxfilesize (ZDR *, fattr4_maxfilesize*); -extern uint32_t zdr_fattr4_maxlink (ZDR *, fattr4_maxlink*); -extern uint32_t zdr_fattr4_maxname (ZDR *, fattr4_maxname*); -extern uint32_t zdr_fattr4_maxread (ZDR *, fattr4_maxread*); -extern uint32_t zdr_fattr4_maxwrite (ZDR *, fattr4_maxwrite*); -extern uint32_t zdr_fattr4_mimetype (ZDR *, fattr4_mimetype*); -extern uint32_t zdr_fattr4_mode (ZDR *, fattr4_mode*); -extern uint32_t zdr_fattr4_mounted_on_fileid (ZDR *, fattr4_mounted_on_fileid*); -extern uint32_t zdr_fattr4_no_trunc (ZDR *, fattr4_no_trunc*); -extern uint32_t zdr_fattr4_numlinks (ZDR *, fattr4_numlinks*); -extern uint32_t zdr_fattr4_owner (ZDR *, fattr4_owner*); -extern uint32_t zdr_fattr4_owner_group (ZDR *, fattr4_owner_group*); -extern uint32_t zdr_fattr4_quota_avail_hard (ZDR *, fattr4_quota_avail_hard*); -extern uint32_t zdr_fattr4_quota_avail_soft (ZDR *, fattr4_quota_avail_soft*); -extern uint32_t zdr_fattr4_quota_used (ZDR *, fattr4_quota_used*); -extern uint32_t zdr_fattr4_rawdev (ZDR *, fattr4_rawdev*); -extern uint32_t zdr_fattr4_space_avail (ZDR *, fattr4_space_avail*); -extern uint32_t zdr_fattr4_space_free (ZDR *, fattr4_space_free*); -extern uint32_t zdr_fattr4_space_total (ZDR *, fattr4_space_total*); -extern uint32_t zdr_fattr4_space_used (ZDR *, fattr4_space_used*); -extern uint32_t zdr_fattr4_system (ZDR *, fattr4_system*); -extern uint32_t zdr_fattr4_time_access (ZDR *, fattr4_time_access*); -extern uint32_t zdr_fattr4_time_access_set (ZDR *, fattr4_time_access_set*); -extern uint32_t zdr_fattr4_time_backup (ZDR *, fattr4_time_backup*); -extern uint32_t zdr_fattr4_time_create (ZDR *, fattr4_time_create*); -extern uint32_t zdr_fattr4_time_delta (ZDR *, fattr4_time_delta*); -extern uint32_t zdr_fattr4_time_metadata (ZDR *, fattr4_time_metadata*); -extern uint32_t zdr_fattr4_time_modify (ZDR *, fattr4_time_modify*); -extern uint32_t zdr_fattr4_time_modify_set (ZDR *, fattr4_time_modify_set*); -extern uint32_t zdr_attrlist4 (ZDR *, attrlist4*); -extern uint32_t zdr_fattr4 (ZDR *, fattr4*); -extern uint32_t zdr_change_info4 (ZDR *, change_info4*); -extern uint32_t zdr_clientaddr4 (ZDR *, clientaddr4*); -extern uint32_t zdr_cb_client4 (ZDR *, cb_client4*); -extern uint32_t zdr_stateid4 (ZDR *, stateid4*); -extern uint32_t zdr_nfs_client_id4 (ZDR *, nfs_client_id4*); -extern uint32_t zdr_open_owner4 (ZDR *, open_owner4*); -extern uint32_t zdr_lock_owner4 (ZDR *, lock_owner4*); -extern uint32_t zdr_nfs_lock_type4 (ZDR *, nfs_lock_type4*); -extern uint32_t zdr_ACCESS4args (ZDR *, ACCESS4args*); -extern uint32_t zdr_ACCESS4resok (ZDR *, ACCESS4resok*); -extern uint32_t zdr_ACCESS4res (ZDR *, ACCESS4res*); -extern uint32_t zdr_CLOSE4args (ZDR *, CLOSE4args*); -extern uint32_t zdr_CLOSE4res (ZDR *, CLOSE4res*); -extern uint32_t zdr_COMMIT4args (ZDR *, COMMIT4args*); -extern uint32_t zdr_COMMIT4resok (ZDR *, COMMIT4resok*); -extern uint32_t zdr_COMMIT4res (ZDR *, COMMIT4res*); -extern uint32_t zdr_createtype4 (ZDR *, createtype4*); -extern uint32_t zdr_CREATE4args (ZDR *, CREATE4args*); -extern uint32_t zdr_CREATE4resok (ZDR *, CREATE4resok*); -extern uint32_t zdr_CREATE4res (ZDR *, CREATE4res*); -extern uint32_t zdr_DELEGPURGE4args (ZDR *, DELEGPURGE4args*); -extern uint32_t zdr_DELEGPURGE4res (ZDR *, DELEGPURGE4res*); -extern uint32_t zdr_DELEGRETURN4args (ZDR *, DELEGRETURN4args*); -extern uint32_t zdr_DELEGRETURN4res (ZDR *, DELEGRETURN4res*); -extern uint32_t zdr_GETATTR4args (ZDR *, GETATTR4args*); -extern uint32_t zdr_GETATTR4resok (ZDR *, GETATTR4resok*); -extern uint32_t zdr_GETATTR4res (ZDR *, GETATTR4res*); -extern uint32_t zdr_GETFH4resok (ZDR *, GETFH4resok*); -extern uint32_t zdr_GETFH4res (ZDR *, GETFH4res*); -extern uint32_t zdr_LINK4args (ZDR *, LINK4args*); -extern uint32_t zdr_LINK4resok (ZDR *, LINK4resok*); -extern uint32_t zdr_LINK4res (ZDR *, LINK4res*); -extern uint32_t zdr_open_to_lock_owner4 (ZDR *, open_to_lock_owner4*); -extern uint32_t zdr_exist_lock_owner4 (ZDR *, exist_lock_owner4*); -extern uint32_t zdr_locker4 (ZDR *, locker4*); -extern uint32_t zdr_LOCK4args (ZDR *, LOCK4args*); -extern uint32_t zdr_LOCK4denied (ZDR *, LOCK4denied*); -extern uint32_t zdr_LOCK4resok (ZDR *, LOCK4resok*); -extern uint32_t zdr_LOCK4res (ZDR *, LOCK4res*); -extern uint32_t zdr_LOCKT4args (ZDR *, LOCKT4args*); -extern uint32_t zdr_LOCKT4res (ZDR *, LOCKT4res*); -extern uint32_t zdr_LOCKU4args (ZDR *, LOCKU4args*); -extern uint32_t zdr_LOCKU4res (ZDR *, LOCKU4res*); -extern uint32_t zdr_LOOKUP4args (ZDR *, LOOKUP4args*); -extern uint32_t zdr_LOOKUP4res (ZDR *, LOOKUP4res*); -extern uint32_t zdr_LOOKUPP4res (ZDR *, LOOKUPP4res*); -extern uint32_t zdr_NVERIFY4args (ZDR *, NVERIFY4args*); -extern uint32_t zdr_NVERIFY4res (ZDR *, NVERIFY4res*); -extern uint32_t zdr_createmode4 (ZDR *, createmode4*); -extern uint32_t zdr_createhow4 (ZDR *, createhow4*); -extern uint32_t zdr_opentype4 (ZDR *, opentype4*); -extern uint32_t zdr_openflag4 (ZDR *, openflag4*); -extern uint32_t zdr_limit_by4 (ZDR *, limit_by4*); -extern uint32_t zdr_nfs_modified_limit4 (ZDR *, nfs_modified_limit4*); -extern uint32_t zdr_nfs_space_limit4 (ZDR *, nfs_space_limit4*); -extern uint32_t zdr_open_delegation_type4 (ZDR *, open_delegation_type4*); -extern uint32_t zdr_open_claim_type4 (ZDR *, open_claim_type4*); -extern uint32_t zdr_open_claim_delegate_cur4 (ZDR *, open_claim_delegate_cur4*); -extern uint32_t zdr_open_claim4 (ZDR *, open_claim4*); -extern uint32_t zdr_OPEN4args (ZDR *, OPEN4args*); -extern uint32_t zdr_open_read_delegation4 (ZDR *, open_read_delegation4*); -extern uint32_t zdr_open_write_delegation4 (ZDR *, open_write_delegation4*); -extern uint32_t zdr_open_delegation4 (ZDR *, open_delegation4*); -extern uint32_t zdr_OPEN4resok (ZDR *, OPEN4resok*); -extern uint32_t zdr_OPEN4res (ZDR *, OPEN4res*); -extern uint32_t zdr_OPENATTR4args (ZDR *, OPENATTR4args*); -extern uint32_t zdr_OPENATTR4res (ZDR *, OPENATTR4res*); -extern uint32_t zdr_OPEN_CONFIRM4args (ZDR *, OPEN_CONFIRM4args*); -extern uint32_t zdr_OPEN_CONFIRM4resok (ZDR *, OPEN_CONFIRM4resok*); -extern uint32_t zdr_OPEN_CONFIRM4res (ZDR *, OPEN_CONFIRM4res*); -extern uint32_t zdr_OPEN_DOWNGRADE4args (ZDR *, OPEN_DOWNGRADE4args*); -extern uint32_t zdr_OPEN_DOWNGRADE4resok (ZDR *, OPEN_DOWNGRADE4resok*); -extern uint32_t zdr_OPEN_DOWNGRADE4res (ZDR *, OPEN_DOWNGRADE4res*); -extern uint32_t zdr_PUTFH4args (ZDR *, PUTFH4args*); -extern uint32_t zdr_PUTFH4res (ZDR *, PUTFH4res*); -extern uint32_t zdr_PUTPUBFH4res (ZDR *, PUTPUBFH4res*); -extern uint32_t zdr_PUTROOTFH4res (ZDR *, PUTROOTFH4res*); -extern uint32_t zdr_READ4args (ZDR *, READ4args*); -extern uint32_t zdr_READ4resok (ZDR *, READ4resok*); -extern uint32_t zdr_READ4res (ZDR *, READ4res*); -extern uint32_t zdr_READDIR4args (ZDR *, READDIR4args*); -extern uint32_t zdr_entry4 (ZDR *, entry4*); -extern uint32_t zdr_dirlist4 (ZDR *, dirlist4*); -extern uint32_t zdr_READDIR4resok (ZDR *, READDIR4resok*); -extern uint32_t zdr_READDIR4res (ZDR *, READDIR4res*); -extern uint32_t zdr_READLINK4resok (ZDR *, READLINK4resok*); -extern uint32_t zdr_READLINK4res (ZDR *, READLINK4res*); -extern uint32_t zdr_REMOVE4args (ZDR *, REMOVE4args*); -extern uint32_t zdr_REMOVE4resok (ZDR *, REMOVE4resok*); -extern uint32_t zdr_REMOVE4res (ZDR *, REMOVE4res*); -extern uint32_t zdr_RENAME4args (ZDR *, RENAME4args*); -extern uint32_t zdr_RENAME4resok (ZDR *, RENAME4resok*); -extern uint32_t zdr_RENAME4res (ZDR *, RENAME4res*); -extern uint32_t zdr_RENEW4args (ZDR *, RENEW4args*); -extern uint32_t zdr_RENEW4res (ZDR *, RENEW4res*); -extern uint32_t zdr_RESTOREFH4res (ZDR *, RESTOREFH4res*); -extern uint32_t zdr_SAVEFH4res (ZDR *, SAVEFH4res*); -extern uint32_t zdr_SETATTR4args (ZDR *, SETATTR4args*); -extern uint32_t zdr_SETATTR4res (ZDR *, SETATTR4res*); -extern uint32_t zdr_SETCLIENTID4args (ZDR *, SETCLIENTID4args*); -extern uint32_t zdr_SETCLIENTID4resok (ZDR *, SETCLIENTID4resok*); -extern uint32_t zdr_SETCLIENTID4res (ZDR *, SETCLIENTID4res*); -extern uint32_t zdr_SETCLIENTID_CONFIRM4args (ZDR *, SETCLIENTID_CONFIRM4args*); -extern uint32_t zdr_SETCLIENTID_CONFIRM4res (ZDR *, SETCLIENTID_CONFIRM4res*); -extern uint32_t zdr_VERIFY4args (ZDR *, VERIFY4args*); -extern uint32_t zdr_VERIFY4res (ZDR *, VERIFY4res*); -extern uint32_t zdr_stable_how4 (ZDR *, stable_how4*); -extern uint32_t zdr_WRITE4args (ZDR *, WRITE4args*); -extern uint32_t zdr_WRITE4resok (ZDR *, WRITE4resok*); -extern uint32_t zdr_WRITE4res (ZDR *, WRITE4res*); -extern uint32_t zdr_RELEASE_LOCKOWNER4args (ZDR *, RELEASE_LOCKOWNER4args*); -extern uint32_t zdr_RELEASE_LOCKOWNER4res (ZDR *, RELEASE_LOCKOWNER4res*); -extern uint32_t zdr_ILLEGAL4res (ZDR *, ILLEGAL4res*); -extern uint32_t zdr_nfs_opnum4 (ZDR *, nfs_opnum4*); -extern uint32_t zdr_nfs_argop4 (ZDR *, nfs_argop4*); -extern uint32_t zdr_nfs_resop4 (ZDR *, nfs_resop4*); -extern uint32_t zdr_COMPOUND4args (ZDR *, COMPOUND4args*); -extern uint32_t zdr_COMPOUND4res (ZDR *, COMPOUND4res*); -extern uint32_t zdr_CB_GETATTR4args (ZDR *, CB_GETATTR4args*); -extern uint32_t zdr_CB_GETATTR4resok (ZDR *, CB_GETATTR4resok*); -extern uint32_t zdr_CB_GETATTR4res (ZDR *, CB_GETATTR4res*); -extern uint32_t zdr_CB_RECALL4args (ZDR *, CB_RECALL4args*); -extern uint32_t zdr_CB_RECALL4res (ZDR *, CB_RECALL4res*); -extern uint32_t zdr_CB_ILLEGAL4res (ZDR *, CB_ILLEGAL4res*); -extern uint32_t zdr_nfs_cb_opnum4 (ZDR *, nfs_cb_opnum4*); -extern uint32_t zdr_nfs_cb_argop4 (ZDR *, nfs_cb_argop4*); -extern uint32_t zdr_nfs_cb_resop4 (ZDR *, nfs_cb_resop4*); -extern uint32_t zdr_CB_COMPOUND4args (ZDR *, CB_COMPOUND4args*); -extern uint32_t zdr_CB_COMPOUND4res (ZDR *, CB_COMPOUND4res*); - -#else /* K&R C */ -extern uint32_t zdr_nfs_ftype4 (); -extern uint32_t zdr_nfsstat4 (); -extern uint32_t zdr_bitmap4 (); -extern uint32_t zdr_offset4 (); -extern uint32_t zdr_count4 (); -extern uint32_t zdr_length4 (); -extern uint32_t zdr_clientid4 (); -extern uint32_t zdr_seqid4 (); -extern uint32_t zdr_utf8string (); -extern uint32_t zdr_utf8str_cis (); -extern uint32_t zdr_utf8str_cs (); -extern uint32_t zdr_utf8str_mixed (); -extern uint32_t zdr_component4 (); -extern uint32_t zdr_pathname4 (); -extern uint32_t zdr_nfs_lockid4 (); -extern uint32_t zdr_nfs_cookie4 (); -extern uint32_t zdr_linktext4 (); -extern uint32_t zdr_sec_oid4 (); -extern uint32_t zdr_qop4 (); -extern uint32_t zdr_mode4 (); -extern uint32_t zdr_changeid4 (); -extern uint32_t zdr_verifier4 (); -extern uint32_t zdr_nfstime4 (); -extern uint32_t zdr_time_how4 (); -extern uint32_t zdr_settime4 (); -extern uint32_t zdr_nfs_fh4 (); -extern uint32_t zdr_fsid4 (); -extern uint32_t zdr_fs_location4 (); -extern uint32_t zdr_fs_locations4 (); -extern uint32_t zdr_acetype4 (); -extern uint32_t zdr_aceflag4 (); -extern uint32_t zdr_acemask4 (); -extern uint32_t zdr_nfsace4 (); -extern uint32_t zdr_specdata4 (); -extern uint32_t zdr_fattr4_supported_attrs (); -extern uint32_t zdr_fattr4_type (); -extern uint32_t zdr_fattr4_fh_expire_type (); -extern uint32_t zdr_fattr4_change (); -extern uint32_t zdr_fattr4_size (); -extern uint32_t zdr_fattr4_link_support (); -extern uint32_t zdr_fattr4_symlink_support (); -extern uint32_t zdr_fattr4_named_attr (); -extern uint32_t zdr_fattr4_fsid (); -extern uint32_t zdr_fattr4_unique_handles (); -extern uint32_t zdr_fattr4_lease_time (); -extern uint32_t zdr_fattr4_rdattr_error (); -extern uint32_t zdr_fattr4_acl (); -extern uint32_t zdr_fattr4_aclsupport (); -extern uint32_t zdr_fattr4_archive (); -extern uint32_t zdr_fattr4_cansettime (); -extern uint32_t zdr_fattr4_case_insensitive (); -extern uint32_t zdr_fattr4_case_preserving (); -extern uint32_t zdr_fattr4_chown_restricted (); -extern uint32_t zdr_fattr4_fileid (); -extern uint32_t zdr_fattr4_files_avail (); -extern uint32_t zdr_fattr4_filehandle (); -extern uint32_t zdr_fattr4_files_free (); -extern uint32_t zdr_fattr4_files_total (); -extern uint32_t zdr_fattr4_fs_locations (); -extern uint32_t zdr_fattr4_hidden (); -extern uint32_t zdr_fattr4_homogeneous (); -extern uint32_t zdr_fattr4_maxfilesize (); -extern uint32_t zdr_fattr4_maxlink (); -extern uint32_t zdr_fattr4_maxname (); -extern uint32_t zdr_fattr4_maxread (); -extern uint32_t zdr_fattr4_maxwrite (); -extern uint32_t zdr_fattr4_mimetype (); -extern uint32_t zdr_fattr4_mode (); -extern uint32_t zdr_fattr4_mounted_on_fileid (); -extern uint32_t zdr_fattr4_no_trunc (); -extern uint32_t zdr_fattr4_numlinks (); -extern uint32_t zdr_fattr4_owner (); -extern uint32_t zdr_fattr4_owner_group (); -extern uint32_t zdr_fattr4_quota_avail_hard (); -extern uint32_t zdr_fattr4_quota_avail_soft (); -extern uint32_t zdr_fattr4_quota_used (); -extern uint32_t zdr_fattr4_rawdev (); -extern uint32_t zdr_fattr4_space_avail (); -extern uint32_t zdr_fattr4_space_free (); -extern uint32_t zdr_fattr4_space_total (); -extern uint32_t zdr_fattr4_space_used (); -extern uint32_t zdr_fattr4_system (); -extern uint32_t zdr_fattr4_time_access (); -extern uint32_t zdr_fattr4_time_access_set (); -extern uint32_t zdr_fattr4_time_backup (); -extern uint32_t zdr_fattr4_time_create (); -extern uint32_t zdr_fattr4_time_delta (); -extern uint32_t zdr_fattr4_time_metadata (); -extern uint32_t zdr_fattr4_time_modify (); -extern uint32_t zdr_fattr4_time_modify_set (); -extern uint32_t zdr_attrlist4 (); -extern uint32_t zdr_fattr4 (); -extern uint32_t zdr_change_info4 (); -extern uint32_t zdr_clientaddr4 (); -extern uint32_t zdr_cb_client4 (); -extern uint32_t zdr_stateid4 (); -extern uint32_t zdr_nfs_client_id4 (); -extern uint32_t zdr_open_owner4 (); -extern uint32_t zdr_lock_owner4 (); -extern uint32_t zdr_nfs_lock_type4 (); -extern uint32_t zdr_ACCESS4args (); -extern uint32_t zdr_ACCESS4resok (); -extern uint32_t zdr_ACCESS4res (); -extern uint32_t zdr_CLOSE4args (); -extern uint32_t zdr_CLOSE4res (); -extern uint32_t zdr_COMMIT4args (); -extern uint32_t zdr_COMMIT4resok (); -extern uint32_t zdr_COMMIT4res (); -extern uint32_t zdr_createtype4 (); -extern uint32_t zdr_CREATE4args (); -extern uint32_t zdr_CREATE4resok (); -extern uint32_t zdr_CREATE4res (); -extern uint32_t zdr_DELEGPURGE4args (); -extern uint32_t zdr_DELEGPURGE4res (); -extern uint32_t zdr_DELEGRETURN4args (); -extern uint32_t zdr_DELEGRETURN4res (); -extern uint32_t zdr_GETATTR4args (); -extern uint32_t zdr_GETATTR4resok (); -extern uint32_t zdr_GETATTR4res (); -extern uint32_t zdr_GETFH4resok (); -extern uint32_t zdr_GETFH4res (); -extern uint32_t zdr_LINK4args (); -extern uint32_t zdr_LINK4resok (); -extern uint32_t zdr_LINK4res (); -extern uint32_t zdr_open_to_lock_owner4 (); -extern uint32_t zdr_exist_lock_owner4 (); -extern uint32_t zdr_locker4 (); -extern uint32_t zdr_LOCK4args (); -extern uint32_t zdr_LOCK4denied (); -extern uint32_t zdr_LOCK4resok (); -extern uint32_t zdr_LOCK4res (); -extern uint32_t zdr_LOCKT4args (); -extern uint32_t zdr_LOCKT4res (); -extern uint32_t zdr_LOCKU4args (); -extern uint32_t zdr_LOCKU4res (); -extern uint32_t zdr_LOOKUP4args (); -extern uint32_t zdr_LOOKUP4res (); -extern uint32_t zdr_LOOKUPP4res (); -extern uint32_t zdr_NVERIFY4args (); -extern uint32_t zdr_NVERIFY4res (); -extern uint32_t zdr_createmode4 (); -extern uint32_t zdr_createhow4 (); -extern uint32_t zdr_opentype4 (); -extern uint32_t zdr_openflag4 (); -extern uint32_t zdr_limit_by4 (); -extern uint32_t zdr_nfs_modified_limit4 (); -extern uint32_t zdr_nfs_space_limit4 (); -extern uint32_t zdr_open_delegation_type4 (); -extern uint32_t zdr_open_claim_type4 (); -extern uint32_t zdr_open_claim_delegate_cur4 (); -extern uint32_t zdr_open_claim4 (); -extern uint32_t zdr_OPEN4args (); -extern uint32_t zdr_open_read_delegation4 (); -extern uint32_t zdr_open_write_delegation4 (); -extern uint32_t zdr_open_delegation4 (); -extern uint32_t zdr_OPEN4resok (); -extern uint32_t zdr_OPEN4res (); -extern uint32_t zdr_OPENATTR4args (); -extern uint32_t zdr_OPENATTR4res (); -extern uint32_t zdr_OPEN_CONFIRM4args (); -extern uint32_t zdr_OPEN_CONFIRM4resok (); -extern uint32_t zdr_OPEN_CONFIRM4res (); -extern uint32_t zdr_OPEN_DOWNGRADE4args (); -extern uint32_t zdr_OPEN_DOWNGRADE4resok (); -extern uint32_t zdr_OPEN_DOWNGRADE4res (); -extern uint32_t zdr_PUTFH4args (); -extern uint32_t zdr_PUTFH4res (); -extern uint32_t zdr_PUTPUBFH4res (); -extern uint32_t zdr_PUTROOTFH4res (); -extern uint32_t zdr_READ4args (); -extern uint32_t zdr_READ4resok (); -extern uint32_t zdr_READ4res (); -extern uint32_t zdr_READDIR4args (); -extern uint32_t zdr_entry4 (); -extern uint32_t zdr_dirlist4 (); -extern uint32_t zdr_READDIR4resok (); -extern uint32_t zdr_READDIR4res (); -extern uint32_t zdr_READLINK4resok (); -extern uint32_t zdr_READLINK4res (); -extern uint32_t zdr_REMOVE4args (); -extern uint32_t zdr_REMOVE4resok (); -extern uint32_t zdr_REMOVE4res (); -extern uint32_t zdr_RENAME4args (); -extern uint32_t zdr_RENAME4resok (); -extern uint32_t zdr_RENAME4res (); -extern uint32_t zdr_RENEW4args (); -extern uint32_t zdr_RENEW4res (); -extern uint32_t zdr_RESTOREFH4res (); -extern uint32_t zdr_SAVEFH4res (); -extern uint32_t zdr_SETATTR4args (); -extern uint32_t zdr_SETATTR4res (); -extern uint32_t zdr_SETCLIENTID4args (); -extern uint32_t zdr_SETCLIENTID4resok (); -extern uint32_t zdr_SETCLIENTID4res (); -extern uint32_t zdr_SETCLIENTID_CONFIRM4args (); -extern uint32_t zdr_SETCLIENTID_CONFIRM4res (); -extern uint32_t zdr_VERIFY4args (); -extern uint32_t zdr_VERIFY4res (); -extern uint32_t zdr_stable_how4 (); -extern uint32_t zdr_WRITE4args (); -extern uint32_t zdr_WRITE4resok (); -extern uint32_t zdr_WRITE4res (); -extern uint32_t zdr_RELEASE_LOCKOWNER4args (); -extern uint32_t zdr_RELEASE_LOCKOWNER4res (); -extern uint32_t zdr_ILLEGAL4res (); -extern uint32_t zdr_nfs_opnum4 (); -extern uint32_t zdr_nfs_argop4 (); -extern uint32_t zdr_nfs_resop4 (); -extern uint32_t zdr_COMPOUND4args (); -extern uint32_t zdr_COMPOUND4res (); -extern uint32_t zdr_CB_GETATTR4args (); -extern uint32_t zdr_CB_GETATTR4resok (); -extern uint32_t zdr_CB_GETATTR4res (); -extern uint32_t zdr_CB_RECALL4args (); -extern uint32_t zdr_CB_RECALL4res (); -extern uint32_t zdr_CB_ILLEGAL4res (); -extern uint32_t zdr_nfs_cb_opnum4 (); -extern uint32_t zdr_nfs_cb_argop4 (); -extern uint32_t zdr_nfs_cb_resop4 (); -extern uint32_t zdr_CB_COMPOUND4args (); -extern uint32_t zdr_CB_COMPOUND4res (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NFS4_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw-nlm.h b/include/nfsc/libnfs-raw-nlm.h deleted file mode 100644 index 53635f5..0000000 --- a/include/nfsc/libnfs-raw-nlm.h +++ /dev/null @@ -1,344 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NLM_H_RPCGEN -#define _NLM_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -struct nlm_fh4 { - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct nlm_fh4 nlm_fh4; - -typedef char *nlm4_oh; - -struct nlm_cookie { - struct { - u_int data_len; - char *data_val; - } data; -}; -typedef struct nlm_cookie nlm_cookie; - -enum nlmstat4 { - NLM4_GRANTED = 0, - NLM4_DENIED = 1, - NLM4_DENIED_NOLOCKS = 2, - NLM4_BLOCKED = 3, - NLM4_DENIED_GRACE_PERIOD = 4, - NLM4_DEADLCK = 5, - NLM4_ROFS = 6, - NLM4_STALE_FH = 7, - NLM4_FBIG = 8, - NLM4_FAILED = 9, -}; -typedef enum nlmstat4 nlmstat4; - -struct nlm4_holder { - uint32_t exclusive; - u_int svid; - nlm4_oh oh; - uint64_t l_offset; - uint64_t l_len; -}; -typedef struct nlm4_holder nlm4_holder; -#define NLM_MAXNAME 256 - -struct nlm4_lock { - char *caller_name; - struct nlm_fh4 fh; - nlm4_oh oh; - u_int svid; - uint64_t l_offset; - uint64_t l_len; -}; -typedef struct nlm4_lock nlm4_lock; - -struct nlm4_share { - char *caller_name; - struct nlm_fh4 fh; - nlm4_oh oh; - u_int mode; - u_int access; -}; -typedef struct nlm4_share nlm4_share; - -struct nlm4_testres_denied { - nlm4_holder holder; -}; -typedef struct nlm4_testres_denied nlm4_testres_denied; - -struct nlm4_testreply { - nlmstat4 status; - union { - nlm4_testres_denied lock; - } nlm4_testreply_u; -}; -typedef struct nlm4_testreply nlm4_testreply; - -struct NLM4_TESTres { - nlm_cookie cookie; - nlm4_testreply reply; -}; -typedef struct NLM4_TESTres NLM4_TESTres; - -struct NLM4_TESTargs { - nlm_cookie cookie; - uint32_t exclusive; - nlm4_lock lock; -}; -typedef struct NLM4_TESTargs NLM4_TESTargs; - -struct NLM4_CANCres { - nlm_cookie cookie; - nlmstat4 status; -}; -typedef struct NLM4_CANCres NLM4_CANCres; - -struct NLM4_CANCargs { - nlm_cookie cookie; - uint32_t block; - uint32_t exclusive; - nlm4_lock lock; -}; -typedef struct NLM4_CANCargs NLM4_CANCargs; - -struct NLM4_UNLOCKres { - nlm_cookie cookie; - nlmstat4 status; -}; -typedef struct NLM4_UNLOCKres NLM4_UNLOCKres; - -struct NLM4_UNLOCKargs { - nlm_cookie cookie; - nlm4_lock lock; -}; -typedef struct NLM4_UNLOCKargs NLM4_UNLOCKargs; - -struct NLM4_LOCKres { - nlm_cookie cookie; - nlmstat4 status; -}; -typedef struct NLM4_LOCKres NLM4_LOCKres; - -struct NLM4_LOCKargs { - nlm_cookie cookie; - uint32_t block; - uint32_t exclusive; - nlm4_lock lock; - uint32_t reclaim; - int state; -}; -typedef struct NLM4_LOCKargs NLM4_LOCKargs; - -struct NLM4_GRANTEDargs { - nlm_cookie cookie; - uint32_t exclusive; - nlm4_lock lock; -}; -typedef struct NLM4_GRANTEDargs NLM4_GRANTEDargs; - -struct NLM4_GRANTEDres { - nlm_cookie cookie; - nlmstat4 status; -}; -typedef struct NLM4_GRANTEDres NLM4_GRANTEDres; - -#define NLM_PROGRAM 100021 -#define NLM_V4 4 - -#if defined(__STDC__) || defined(__cplusplus) -#define NLM4_NULL 0 -extern void * nlm4_null_4(void *, void *); -extern void * nlm4_null_4_svc(void *, struct svc_req *); -#define NLM4_TEST 1 -extern NLM4_TESTres * nlm4_test_4(NLM4_TESTargs *, void *); -extern NLM4_TESTres * nlm4_test_4_svc(NLM4_TESTargs *, struct svc_req *); -#define NLM4_LOCK 2 -extern NLM4_LOCKres * nlm4_lock_4(NLM4_LOCKargs *, void *); -extern NLM4_LOCKres * nlm4_lock_4_svc(NLM4_LOCKargs *, struct svc_req *); -#define NLM4_CANCEL 3 -extern NLM4_CANCres * nlm4_cancel_4(NLM4_CANCargs *, void *); -extern NLM4_CANCres * nlm4_cancel_4_svc(NLM4_CANCargs *, struct svc_req *); -#define NLM4_UNLOCK 4 -extern NLM4_UNLOCKres * nlm4_unlock_4(NLM4_UNLOCKargs *, void *); -extern NLM4_UNLOCKres * nlm4_unlock_4_svc(NLM4_UNLOCKargs *, struct svc_req *); -#define NLM4_GRANT 5 -extern NLM4_GRANTEDres * nlm4_grant_4(NLM4_GRANTEDargs *, void *); -extern NLM4_GRANTEDres * nlm4_grant_4_svc(NLM4_GRANTEDargs *, struct svc_req *); -#define NLM4_TEST_MSG 6 -extern void * nlm4_test_msg_4(NLM4_TESTargs *, void *); -extern void * nlm4_test_msg_4_svc(NLM4_TESTargs *, struct svc_req *); -#define NLM4_LOCK_MSG 7 -extern void * nlm4_lock_msg_4(NLM4_LOCKargs *, void *); -extern void * nlm4_lock_msg_4_svc(NLM4_LOCKargs *, struct svc_req *); -#define NLM4_CANCEL_MSG 8 -extern void * nlm4_cancel_msg_4(NLM4_CANCargs *, void *); -extern void * nlm4_cancel_msg_4_svc(NLM4_CANCargs *, struct svc_req *); -#define NLM4_UNLOCK_MSG 9 -extern void * nlm4_unlock_msg_4(NLM4_UNLOCKargs *, void *); -extern void * nlm4_unlock_msg_4_svc(NLM4_UNLOCKargs *, struct svc_req *); -#define NLM4_GRANT_MSG 10 -extern void * nlm4_grant_msg_4(NLM4_GRANTEDargs *, void *); -extern void * nlm4_grant_msg_4_svc(NLM4_GRANTEDargs *, struct svc_req *); -#define NLM4_TEST_RES 11 -extern void * nlm4_test_res_4(NLM4_TESTres *, void *); -extern void * nlm4_test_res_4_svc(NLM4_TESTres *, struct svc_req *); -#define NLM4_LOCK_RES 12 -extern void * nlm4_lock_res_4(NLM4_LOCKres *, void *); -extern void * nlm4_lock_res_4_svc(NLM4_LOCKres *, struct svc_req *); -#define NLM4_CANCEL_RES 13 -extern void * nlm4_cancel_res_4(NLM4_CANCres *, void *); -extern void * nlm4_cancel_res_4_svc(NLM4_CANCres *, struct svc_req *); -#define NLM4_UNLOCK_RES 14 -extern void * nlm4_unlock_res_4(NLM4_UNLOCKres *, void *); -extern void * nlm4_unlock_res_4_svc(NLM4_UNLOCKres *, struct svc_req *); -#define NLM4_GRANT_RES 15 -extern void * nlm4_grant_res_4(NLM4_GRANTEDres *, void *); -extern void * nlm4_grant_res_4_svc(NLM4_GRANTEDres *, struct svc_req *); -extern int nlm_program_4_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define NLM4_NULL 0 -extern void * nlm4_null_4(); -extern void * nlm4_null_4_svc(); -#define NLM4_TEST 1 -extern NLM4_TESTres * nlm4_test_4(); -extern NLM4_TESTres * nlm4_test_4_svc(); -#define NLM4_LOCK 2 -extern NLM4_LOCKres * nlm4_lock_4(); -extern NLM4_LOCKres * nlm4_lock_4_svc(); -#define NLM4_CANCEL 3 -extern NLM4_CANCres * nlm4_cancel_4(); -extern NLM4_CANCres * nlm4_cancel_4_svc(); -#define NLM4_UNLOCK 4 -extern NLM4_UNLOCKres * nlm4_unlock_4(); -extern NLM4_UNLOCKres * nlm4_unlock_4_svc(); -#define NLM4_GRANT 5 -extern NLM4_GRANTEDres * nlm4_grant_4(); -extern NLM4_GRANTEDres * nlm4_grant_4_svc(); -#define NLM4_TEST_MSG 6 -extern void * nlm4_test_msg_4(); -extern void * nlm4_test_msg_4_svc(); -#define NLM4_LOCK_MSG 7 -extern void * nlm4_lock_msg_4(); -extern void * nlm4_lock_msg_4_svc(); -#define NLM4_CANCEL_MSG 8 -extern void * nlm4_cancel_msg_4(); -extern void * nlm4_cancel_msg_4_svc(); -#define NLM4_UNLOCK_MSG 9 -extern void * nlm4_unlock_msg_4(); -extern void * nlm4_unlock_msg_4_svc(); -#define NLM4_GRANT_MSG 10 -extern void * nlm4_grant_msg_4(); -extern void * nlm4_grant_msg_4_svc(); -#define NLM4_TEST_RES 11 -extern void * nlm4_test_res_4(); -extern void * nlm4_test_res_4_svc(); -#define NLM4_LOCK_RES 12 -extern void * nlm4_lock_res_4(); -extern void * nlm4_lock_res_4_svc(); -#define NLM4_CANCEL_RES 13 -extern void * nlm4_cancel_res_4(); -extern void * nlm4_cancel_res_4_svc(); -#define NLM4_UNLOCK_RES 14 -extern void * nlm4_unlock_res_4(); -extern void * nlm4_unlock_res_4_svc(); -#define NLM4_GRANT_RES 15 -extern void * nlm4_grant_res_4(); -extern void * nlm4_grant_res_4_svc(); -extern int nlm_program_4_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_nlm_fh4 (ZDR *, nlm_fh4*); -extern uint32_t zdr_nlm4_oh (ZDR *, nlm4_oh*); -extern uint32_t zdr_nlm_cookie (ZDR *, nlm_cookie*); -extern uint32_t zdr_nlmstat4 (ZDR *, nlmstat4*); -extern uint32_t zdr_nlm4_holder (ZDR *, nlm4_holder*); -extern uint32_t zdr_nlm4_lock (ZDR *, nlm4_lock*); -extern uint32_t zdr_nlm4_share (ZDR *, nlm4_share*); -extern uint32_t zdr_nlm4_testres_denied (ZDR *, nlm4_testres_denied*); -extern uint32_t zdr_nlm4_testreply (ZDR *, nlm4_testreply*); -extern uint32_t zdr_NLM4_TESTres (ZDR *, NLM4_TESTres*); -extern uint32_t zdr_NLM4_TESTargs (ZDR *, NLM4_TESTargs*); -extern uint32_t zdr_NLM4_CANCres (ZDR *, NLM4_CANCres*); -extern uint32_t zdr_NLM4_CANCargs (ZDR *, NLM4_CANCargs*); -extern uint32_t zdr_NLM4_UNLOCKres (ZDR *, NLM4_UNLOCKres*); -extern uint32_t zdr_NLM4_UNLOCKargs (ZDR *, NLM4_UNLOCKargs*); -extern uint32_t zdr_NLM4_LOCKres (ZDR *, NLM4_LOCKres*); -extern uint32_t zdr_NLM4_LOCKargs (ZDR *, NLM4_LOCKargs*); -extern uint32_t zdr_NLM4_GRANTEDargs (ZDR *, NLM4_GRANTEDargs*); -extern uint32_t zdr_NLM4_GRANTEDres (ZDR *, NLM4_GRANTEDres*); - -#else /* K&R C */ -extern uint32_t zdr_nlm_fh4 (); -extern uint32_t zdr_nlm4_oh (); -extern uint32_t zdr_nlm_cookie (); -extern uint32_t zdr_nlmstat4 (); -extern uint32_t zdr_nlm4_holder (); -extern uint32_t zdr_nlm4_lock (); -extern uint32_t zdr_nlm4_share (); -extern uint32_t zdr_nlm4_testres_denied (); -extern uint32_t zdr_nlm4_testreply (); -extern uint32_t zdr_NLM4_TESTres (); -extern uint32_t zdr_NLM4_TESTargs (); -extern uint32_t zdr_NLM4_CANCres (); -extern uint32_t zdr_NLM4_CANCargs (); -extern uint32_t zdr_NLM4_UNLOCKres (); -extern uint32_t zdr_NLM4_UNLOCKargs (); -extern uint32_t zdr_NLM4_LOCKres (); -extern uint32_t zdr_NLM4_LOCKargs (); -extern uint32_t zdr_NLM4_GRANTEDargs (); -extern uint32_t zdr_NLM4_GRANTEDres (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NLM_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw-nsm.h b/include/nfsc/libnfs-raw-nsm.h deleted file mode 100644 index e35e0c2..0000000 --- a/include/nfsc/libnfs-raw-nsm.h +++ /dev/null @@ -1,204 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NSM_H_RPCGEN -#define _NSM_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define NSM_MAXSTRLEN 1024 - -enum nsmstat1 { - NSM_STAT_SUCC = 0, - NSM_STAT_FAIL = 1, -}; -typedef enum nsmstat1 nsmstat1; - -struct nsm_my_id { - char *my_name; - int my_prog; - int my_vers; - int my_proc; -}; -typedef struct nsm_my_id nsm_my_id; - -struct nsm_mon_id { - char *mon_name; - struct nsm_my_id my_id; -}; -typedef struct nsm_mon_id nsm_mon_id; - -struct NSM1_STATres { - nsmstat1 res; - int state; -}; -typedef struct NSM1_STATres NSM1_STATres; - -struct NSM1_STATargs { - char *mon_name; -}; -typedef struct NSM1_STATargs NSM1_STATargs; - -struct NSM1_MONres { - nsmstat1 res; - int state; -}; -typedef struct NSM1_MONres NSM1_MONres; - -struct NSM1_MONargs { - struct nsm_mon_id mon_id; - char priv[16]; -}; -typedef struct NSM1_MONargs NSM1_MONargs; - -struct NSM1_UNMONres { - int state; -}; -typedef struct NSM1_UNMONres NSM1_UNMONres; - -struct NSM1_UNMONargs { - struct nsm_mon_id mon_id; -}; -typedef struct NSM1_UNMONargs NSM1_UNMONargs; - -struct NSM1_UNMONALLres { - int state; -}; -typedef struct NSM1_UNMONALLres NSM1_UNMONALLres; - -struct NSM1_UNMONALLargs { - struct nsm_my_id my_id; -}; -typedef struct NSM1_UNMONALLargs NSM1_UNMONALLargs; - -struct NSM1_NOTIFYargs { - char *mon_name; - int state; -}; -typedef struct NSM1_NOTIFYargs NSM1_NOTIFYargs; - -#define NSM_PROGRAM 100024 -#define NSM_V1 1 - -#if defined(__STDC__) || defined(__cplusplus) -#define NSM1_NULL 0 -extern void * nsm1_null_1(void *, void *); -extern void * nsm1_null_1_svc(void *, struct svc_req *); -#define NSM1_STAT 1 -extern struct NSM1_STATres * nsm1_stat_1(struct NSM1_STATargs *, void *); -extern struct NSM1_STATres * nsm1_stat_1_svc(struct NSM1_STATargs *, struct svc_req *); -#define NSM1_MON 2 -extern struct NSM1_MONres * nsm1_mon_1(struct NSM1_MONargs *, void *); -extern struct NSM1_MONres * nsm1_mon_1_svc(struct NSM1_MONargs *, struct svc_req *); -#define NSM1_UNMON 3 -extern struct NSM1_UNMONres * nsm1_unmon_1(struct NSM1_UNMONargs *, void *); -extern struct NSM1_UNMONres * nsm1_unmon_1_svc(struct NSM1_UNMONargs *, struct svc_req *); -#define NSM1_UNMON_ALL 4 -extern struct NSM1_UNMONALLres * nsm1_unmon_all_1(struct NSM1_UNMONALLargs *, void *); -extern struct NSM1_UNMONALLres * nsm1_unmon_all_1_svc(struct NSM1_UNMONALLargs *, struct svc_req *); -#define NSM1_SIMU_CRASH 5 -extern void * nsm1_simu_crash_1(void *, void *); -extern void * nsm1_simu_crash_1_svc(void *, struct svc_req *); -#define NSM1_NOTIFY 6 -extern void * nsm1_notify_1(struct NSM1_NOTIFYargs *, void *); -extern void * nsm1_notify_1_svc(struct NSM1_NOTIFYargs *, struct svc_req *); -extern int nsm_program_1_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define NSM1_NULL 0 -extern void * nsm1_null_1(); -extern void * nsm1_null_1_svc(); -#define NSM1_STAT 1 -extern struct NSM1_STATres * nsm1_stat_1(); -extern struct NSM1_STATres * nsm1_stat_1_svc(); -#define NSM1_MON 2 -extern struct NSM1_MONres * nsm1_mon_1(); -extern struct NSM1_MONres * nsm1_mon_1_svc(); -#define NSM1_UNMON 3 -extern struct NSM1_UNMONres * nsm1_unmon_1(); -extern struct NSM1_UNMONres * nsm1_unmon_1_svc(); -#define NSM1_UNMON_ALL 4 -extern struct NSM1_UNMONALLres * nsm1_unmon_all_1(); -extern struct NSM1_UNMONALLres * nsm1_unmon_all_1_svc(); -#define NSM1_SIMU_CRASH 5 -extern void * nsm1_simu_crash_1(); -extern void * nsm1_simu_crash_1_svc(); -#define NSM1_NOTIFY 6 -extern void * nsm1_notify_1(); -extern void * nsm1_notify_1_svc(); -extern int nsm_program_1_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_nsmstat1 (ZDR *, nsmstat1*); -extern uint32_t zdr_nsm_my_id (ZDR *, nsm_my_id*); -extern uint32_t zdr_nsm_mon_id (ZDR *, nsm_mon_id*); -extern uint32_t zdr_NSM1_STATres (ZDR *, NSM1_STATres*); -extern uint32_t zdr_NSM1_STATargs (ZDR *, NSM1_STATargs*); -extern uint32_t zdr_NSM1_MONres (ZDR *, NSM1_MONres*); -extern uint32_t zdr_NSM1_MONargs (ZDR *, NSM1_MONargs*); -extern uint32_t zdr_NSM1_UNMONres (ZDR *, NSM1_UNMONres*); -extern uint32_t zdr_NSM1_UNMONargs (ZDR *, NSM1_UNMONargs*); -extern uint32_t zdr_NSM1_UNMONALLres (ZDR *, NSM1_UNMONALLres*); -extern uint32_t zdr_NSM1_UNMONALLargs (ZDR *, NSM1_UNMONALLargs*); -extern uint32_t zdr_NSM1_NOTIFYargs (ZDR *, NSM1_NOTIFYargs*); - -#else /* K&R C */ -extern uint32_t zdr_nsmstat1 (); -extern uint32_t zdr_nsm_my_id (); -extern uint32_t zdr_nsm_mon_id (); -extern uint32_t zdr_NSM1_STATres (); -extern uint32_t zdr_NSM1_STATargs (); -extern uint32_t zdr_NSM1_MONres (); -extern uint32_t zdr_NSM1_MONargs (); -extern uint32_t zdr_NSM1_UNMONres (); -extern uint32_t zdr_NSM1_UNMONargs (); -extern uint32_t zdr_NSM1_UNMONALLres (); -extern uint32_t zdr_NSM1_UNMONALLargs (); -extern uint32_t zdr_NSM1_NOTIFYargs (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NSM_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw-portmap.h b/include/nfsc/libnfs-raw-portmap.h deleted file mode 100644 index cbb7af4..0000000 --- a/include/nfsc/libnfs-raw-portmap.h +++ /dev/null @@ -1,348 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _PORTMAP_H_RPCGEN -#define _PORTMAP_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define PMAP_PORT 111 - -struct pmap2_mapping { - u_int prog; - u_int vers; - u_int prot; - u_int port; -}; -typedef struct pmap2_mapping pmap2_mapping; - -struct pmap2_call_args { - u_int prog; - u_int vers; - u_int proc; - struct { - u_int args_len; - char *args_val; - } args; -}; -typedef struct pmap2_call_args pmap2_call_args; - -struct pmap2_call_result { - u_int port; - struct { - u_int res_len; - char *res_val; - } res; -}; -typedef struct pmap2_call_result pmap2_call_result; - -struct pmap2_mapping_list { - pmap2_mapping map; - struct pmap2_mapping_list *next; -}; -typedef struct pmap2_mapping_list pmap2_mapping_list; - -struct pmap2_dump_result { - struct pmap2_mapping_list *list; -}; -typedef struct pmap2_dump_result pmap2_dump_result; - -struct pmap3_string_result { - char *addr; -}; -typedef struct pmap3_string_result pmap3_string_result; - -struct pmap3_mapping { - u_int prog; - u_int vers; - char *netid; - char *addr; - char *owner; -}; -typedef struct pmap3_mapping pmap3_mapping; - -struct pmap3_mapping_list { - pmap3_mapping map; - struct pmap3_mapping_list *next; -}; -typedef struct pmap3_mapping_list pmap3_mapping_list; - -struct pmap3_dump_result { - struct pmap3_mapping_list *list; -}; -typedef struct pmap3_dump_result pmap3_dump_result; - -struct pmap3_call_args { - u_int prog; - u_int vers; - u_int proc; - struct { - u_int args_len; - char *args_val; - } args; -}; -typedef struct pmap3_call_args pmap3_call_args; - -struct pmap3_call_result { - u_int port; - struct { - u_int res_len; - char *res_val; - } res; -}; -typedef struct pmap3_call_result pmap3_call_result; - -struct pmap3_netbuf { - u_int maxlen; - struct { - u_int buf_len; - char *buf_val; - } buf; -}; -typedef struct pmap3_netbuf pmap3_netbuf; - -typedef pmap2_mapping PMAP2SETargs; - -typedef pmap2_mapping PMAP2UNSETargs; - -typedef pmap2_mapping PMAP2GETPORTargs; - -typedef pmap2_call_args PMAP2CALLITargs; - -typedef pmap2_call_result PMAP2CALLITres; - -typedef pmap2_dump_result PMAP2DUMPres; - -typedef pmap3_mapping PMAP3SETargs; - -typedef pmap3_mapping PMAP3UNSETargs; - -typedef pmap3_mapping PMAP3GETADDRargs; - -typedef pmap3_string_result PMAP3GETADDRres; - -typedef pmap3_dump_result PMAP3DUMPres; - -typedef pmap3_call_result PMAP3CALLITargs; - -typedef pmap3_call_result PMAP3CALLITres; - -typedef pmap3_netbuf PMAP3UADDR2TADDRres; - -typedef pmap3_netbuf PMAP3TADDR2UADDRargs; - -typedef pmap3_string_result PMAP3TADDR2UADDRres; - -#define PMAP_PROGRAM 100000 -#define PMAP_V2 2 - -#if defined(__STDC__) || defined(__cplusplus) -#define PMAP2_NULL 0 -extern void * pmap2_null_2(void *, void *); -extern void * pmap2_null_2_svc(void *, struct svc_req *); -#define PMAP2_SET 1 -extern uint32_t * pmap2_set_2(PMAP2SETargs *, void *); -extern uint32_t * pmap2_set_2_svc(PMAP2SETargs *, struct svc_req *); -#define PMAP2_UNSET 2 -extern uint32_t * pmap2_unset_2(PMAP2UNSETargs *, void *); -extern uint32_t * pmap2_unset_2_svc(PMAP2UNSETargs *, struct svc_req *); -#define PMAP2_GETPORT 3 -extern uint32_t * pmap2_getport_2(PMAP2GETPORTargs *, void *); -extern uint32_t * pmap2_getport_2_svc(PMAP2GETPORTargs *, struct svc_req *); -#define PMAP2_DUMP 4 -extern PMAP2DUMPres * pmap2_dump_2(void *, void *); -extern PMAP2DUMPres * pmap2_dump_2_svc(void *, struct svc_req *); -#define PMAP2_CALLIT 5 -extern PMAP2CALLITres * pmap2_callit_2(PMAP2CALLITargs *, void *); -extern PMAP2CALLITres * pmap2_callit_2_svc(PMAP2CALLITargs *, struct svc_req *); -extern int pmap_program_2_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define PMAP2_NULL 0 -extern void * pmap2_null_2(); -extern void * pmap2_null_2_svc(); -#define PMAP2_SET 1 -extern uint32_t * pmap2_set_2(); -extern uint32_t * pmap2_set_2_svc(); -#define PMAP2_UNSET 2 -extern uint32_t * pmap2_unset_2(); -extern uint32_t * pmap2_unset_2_svc(); -#define PMAP2_GETPORT 3 -extern uint32_t * pmap2_getport_2(); -extern uint32_t * pmap2_getport_2_svc(); -#define PMAP2_DUMP 4 -extern PMAP2DUMPres * pmap2_dump_2(); -extern PMAP2DUMPres * pmap2_dump_2_svc(); -#define PMAP2_CALLIT 5 -extern PMAP2CALLITres * pmap2_callit_2(); -extern PMAP2CALLITres * pmap2_callit_2_svc(); -extern int pmap_program_2_freeresult (); -#endif /* K&R C */ -#define PMAP_V3 3 - -#if defined(__STDC__) || defined(__cplusplus) -#define PMAP3_NULL 0 -extern void * pmap3_null_3(void *, void *); -extern void * pmap3_null_3_svc(void *, struct svc_req *); -#define PMAP3_SET 1 -extern uint32_t * pmap3_set_3(PMAP3SETargs *, void *); -extern uint32_t * pmap3_set_3_svc(PMAP3SETargs *, struct svc_req *); -#define PMAP3_UNSET 2 -extern uint32_t * pmap3_unset_3(PMAP3UNSETargs *, void *); -extern uint32_t * pmap3_unset_3_svc(PMAP3UNSETargs *, struct svc_req *); -#define PMAP3_GETADDR 3 -extern PMAP3GETADDRres * pmap3_getaddr_3(PMAP3GETADDRargs *, void *); -extern PMAP3GETADDRres * pmap3_getaddr_3_svc(PMAP3GETADDRargs *, struct svc_req *); -#define PMAP3_DUMP 4 -extern PMAP3DUMPres * pmap3_dump_3(void *, void *); -extern PMAP3DUMPres * pmap3_dump_3_svc(void *, struct svc_req *); -#define PMAP3_CALLIT 5 -extern PMAP3CALLITres * pmap3_callit_3(PMAP3CALLITargs *, void *); -extern PMAP3CALLITres * pmap3_callit_3_svc(PMAP3CALLITargs *, struct svc_req *); -#define PMAP3_GETTIME 6 -extern uint32_t * pmap3_gettime_3(void *, void *); -extern uint32_t * pmap3_gettime_3_svc(void *, struct svc_req *); -#define PMAP3_UADDR2TADDR 7 -extern PMAP3UADDR2TADDRres * pmap3_uaddr2taddr_3(char **, void *); -extern PMAP3UADDR2TADDRres * pmap3_uaddr2taddr_3_svc(char **, struct svc_req *); -#define PMAP3_TADDR2UADDR 8 -extern PMAP3TADDR2UADDRres * pmap3_taddr2uaddr_3(PMAP3TADDR2UADDRargs *, void *); -extern PMAP3TADDR2UADDRres * pmap3_taddr2uaddr_3_svc(PMAP3TADDR2UADDRargs *, struct svc_req *); -extern int pmap_program_3_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define PMAP3_NULL 0 -extern void * pmap3_null_3(); -extern void * pmap3_null_3_svc(); -#define PMAP3_SET 1 -extern uint32_t * pmap3_set_3(); -extern uint32_t * pmap3_set_3_svc(); -#define PMAP3_UNSET 2 -extern uint32_t * pmap3_unset_3(); -extern uint32_t * pmap3_unset_3_svc(); -#define PMAP3_GETADDR 3 -extern PMAP3GETADDRres * pmap3_getaddr_3(); -extern PMAP3GETADDRres * pmap3_getaddr_3_svc(); -#define PMAP3_DUMP 4 -extern PMAP3DUMPres * pmap3_dump_3(); -extern PMAP3DUMPres * pmap3_dump_3_svc(); -#define PMAP3_CALLIT 5 -extern PMAP3CALLITres * pmap3_callit_3(); -extern PMAP3CALLITres * pmap3_callit_3_svc(); -#define PMAP3_GETTIME 6 -extern uint32_t * pmap3_gettime_3(); -extern uint32_t * pmap3_gettime_3_svc(); -#define PMAP3_UADDR2TADDR 7 -extern PMAP3UADDR2TADDRres * pmap3_uaddr2taddr_3(); -extern PMAP3UADDR2TADDRres * pmap3_uaddr2taddr_3_svc(); -#define PMAP3_TADDR2UADDR 8 -extern PMAP3TADDR2UADDRres * pmap3_taddr2uaddr_3(); -extern PMAP3TADDR2UADDRres * pmap3_taddr2uaddr_3_svc(); -extern int pmap_program_3_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_pmap2_mapping (ZDR *, pmap2_mapping*); -extern uint32_t zdr_pmap2_call_args (ZDR *, pmap2_call_args*); -extern uint32_t zdr_pmap2_call_result (ZDR *, pmap2_call_result*); -extern uint32_t zdr_pmap2_mapping_list (ZDR *, pmap2_mapping_list*); -extern uint32_t zdr_pmap2_dump_result (ZDR *, pmap2_dump_result*); -extern uint32_t zdr_pmap3_string_result (ZDR *, pmap3_string_result*); -extern uint32_t zdr_pmap3_mapping (ZDR *, pmap3_mapping*); -extern uint32_t zdr_pmap3_mapping_list (ZDR *, pmap3_mapping_list*); -extern uint32_t zdr_pmap3_dump_result (ZDR *, pmap3_dump_result*); -extern uint32_t zdr_pmap3_call_args (ZDR *, pmap3_call_args*); -extern uint32_t zdr_pmap3_call_result (ZDR *, pmap3_call_result*); -extern uint32_t zdr_pmap3_netbuf (ZDR *, pmap3_netbuf*); -extern uint32_t zdr_PMAP2SETargs (ZDR *, PMAP2SETargs*); -extern uint32_t zdr_PMAP2UNSETargs (ZDR *, PMAP2UNSETargs*); -extern uint32_t zdr_PMAP2GETPORTargs (ZDR *, PMAP2GETPORTargs*); -extern uint32_t zdr_PMAP2CALLITargs (ZDR *, PMAP2CALLITargs*); -extern uint32_t zdr_PMAP2CALLITres (ZDR *, PMAP2CALLITres*); -extern uint32_t zdr_PMAP2DUMPres (ZDR *, PMAP2DUMPres*); -extern uint32_t zdr_PMAP3SETargs (ZDR *, PMAP3SETargs*); -extern uint32_t zdr_PMAP3UNSETargs (ZDR *, PMAP3UNSETargs*); -extern uint32_t zdr_PMAP3GETADDRargs (ZDR *, PMAP3GETADDRargs*); -extern uint32_t zdr_PMAP3GETADDRres (ZDR *, PMAP3GETADDRres*); -extern uint32_t zdr_PMAP3DUMPres (ZDR *, PMAP3DUMPres*); -extern uint32_t zdr_PMAP3CALLITargs (ZDR *, PMAP3CALLITargs*); -extern uint32_t zdr_PMAP3CALLITres (ZDR *, PMAP3CALLITres*); -extern uint32_t zdr_PMAP3UADDR2TADDRres (ZDR *, PMAP3UADDR2TADDRres*); -extern uint32_t zdr_PMAP3TADDR2UADDRargs (ZDR *, PMAP3TADDR2UADDRargs*); -extern uint32_t zdr_PMAP3TADDR2UADDRres (ZDR *, PMAP3TADDR2UADDRres*); - -#else /* K&R C */ -extern uint32_t zdr_pmap2_mapping (); -extern uint32_t zdr_pmap2_call_args (); -extern uint32_t zdr_pmap2_call_result (); -extern uint32_t zdr_pmap2_mapping_list (); -extern uint32_t zdr_pmap2_dump_result (); -extern uint32_t zdr_pmap3_string_result (); -extern uint32_t zdr_pmap3_mapping (); -extern uint32_t zdr_pmap3_mapping_list (); -extern uint32_t zdr_pmap3_dump_result (); -extern uint32_t zdr_pmap3_call_args (); -extern uint32_t zdr_pmap3_call_result (); -extern uint32_t zdr_pmap3_netbuf (); -extern uint32_t zdr_PMAP2SETargs (); -extern uint32_t zdr_PMAP2UNSETargs (); -extern uint32_t zdr_PMAP2GETPORTargs (); -extern uint32_t zdr_PMAP2CALLITargs (); -extern uint32_t zdr_PMAP2CALLITres (); -extern uint32_t zdr_PMAP2DUMPres (); -extern uint32_t zdr_PMAP3SETargs (); -extern uint32_t zdr_PMAP3UNSETargs (); -extern uint32_t zdr_PMAP3GETADDRargs (); -extern uint32_t zdr_PMAP3GETADDRres (); -extern uint32_t zdr_PMAP3DUMPres (); -extern uint32_t zdr_PMAP3CALLITargs (); -extern uint32_t zdr_PMAP3CALLITres (); -extern uint32_t zdr_PMAP3UADDR2TADDRres (); -extern uint32_t zdr_PMAP3TADDR2UADDRargs (); -extern uint32_t zdr_PMAP3TADDR2UADDRres (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_PORTMAP_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw-rquota.h b/include/nfsc/libnfs-raw-rquota.h deleted file mode 100644 index 27ea104..0000000 --- a/include/nfsc/libnfs-raw-rquota.h +++ /dev/null @@ -1,177 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _RQUOTA_H_RPCGEN -#define _RQUOTA_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define RQUOTAPATHLEN 1024 - -enum rquotastat { - RQUOTA_OK = 1, - RQUOTA_NOQUOTA = 2, - RQUOTA_EPERM = 3, -}; -typedef enum rquotastat rquotastat; - -typedef char *exportpath; - -struct GETQUOTA1args { - exportpath export; - int uid; -}; -typedef struct GETQUOTA1args GETQUOTA1args; - -enum quotatype { - RQUOTA_TYPE_UID = 0, - RQUOTA_TYPE_GID = 1, -}; -typedef enum quotatype quotatype; - -struct GETQUOTA2args { - exportpath export; - quotatype type; - int uid; -}; -typedef struct GETQUOTA2args GETQUOTA2args; - -struct GETQUOTA1res_ok { - int bsize; - int active; - int bhardlimit; - int bsoftlimit; - int curblocks; - int fhardlimit; - int fsoftlimit; - int curfiles; - int btimeleft; - int ftimeleft; -}; -typedef struct GETQUOTA1res_ok GETQUOTA1res_ok; - -struct GETQUOTA1res { - rquotastat status; - union { - GETQUOTA1res_ok quota; - } GETQUOTA1res_u; -}; -typedef struct GETQUOTA1res GETQUOTA1res; - -#define RQUOTA_PROGRAM 100011 -#define RQUOTA_V1 1 - -#if defined(__STDC__) || defined(__cplusplus) -#define RQUOTA1_NULL 0 -extern void * rquota1_null_1(void *, void *); -extern void * rquota1_null_1_svc(void *, struct svc_req *); -#define RQUOTA1_GETQUOTA 1 -extern GETQUOTA1res * rquota1_getquota_1(GETQUOTA1args *, void *); -extern GETQUOTA1res * rquota1_getquota_1_svc(GETQUOTA1args *, struct svc_req *); -#define RQUOTA1_GETACTIVEQUOTA 2 -extern GETQUOTA1res * rquota1_getactivequota_1(GETQUOTA1args *, void *); -extern GETQUOTA1res * rquota1_getactivequota_1_svc(GETQUOTA1args *, struct svc_req *); -extern int rquota_program_1_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define RQUOTA1_NULL 0 -extern void * rquota1_null_1(); -extern void * rquota1_null_1_svc(); -#define RQUOTA1_GETQUOTA 1 -extern GETQUOTA1res * rquota1_getquota_1(); -extern GETQUOTA1res * rquota1_getquota_1_svc(); -#define RQUOTA1_GETACTIVEQUOTA 2 -extern GETQUOTA1res * rquota1_getactivequota_1(); -extern GETQUOTA1res * rquota1_getactivequota_1_svc(); -extern int rquota_program_1_freeresult (); -#endif /* K&R C */ -#define RQUOTA_V2 2 - -#if defined(__STDC__) || defined(__cplusplus) -#define RQUOTA2_NULL 0 -extern void * rquota2_null_2(void *, void *); -extern void * rquota2_null_2_svc(void *, struct svc_req *); -#define RQUOTA2_GETQUOTA 1 -extern GETQUOTA1res * rquota2_getquota_2(GETQUOTA2args *, void *); -extern GETQUOTA1res * rquota2_getquota_2_svc(GETQUOTA2args *, struct svc_req *); -#define RQUOTA2_GETACTIVEQUOTA 2 -extern GETQUOTA1res * rquota2_getactivequota_2(GETQUOTA2args *, void *); -extern GETQUOTA1res * rquota2_getactivequota_2_svc(GETQUOTA2args *, struct svc_req *); -extern int rquota_program_2_freeresult (void *, zdrproc_t, caddr_t); - -#else /* K&R C */ -#define RQUOTA2_NULL 0 -extern void * rquota2_null_2(); -extern void * rquota2_null_2_svc(); -#define RQUOTA2_GETQUOTA 1 -extern GETQUOTA1res * rquota2_getquota_2(); -extern GETQUOTA1res * rquota2_getquota_2_svc(); -#define RQUOTA2_GETACTIVEQUOTA 2 -extern GETQUOTA1res * rquota2_getactivequota_2(); -extern GETQUOTA1res * rquota2_getactivequota_2_svc(); -extern int rquota_program_2_freeresult (); -#endif /* K&R C */ - -/* the zdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern uint32_t zdr_rquotastat (ZDR *, rquotastat*); -extern uint32_t zdr_exportpath (ZDR *, exportpath*); -extern uint32_t zdr_GETQUOTA1args (ZDR *, GETQUOTA1args*); -extern uint32_t zdr_quotatype (ZDR *, quotatype*); -extern uint32_t zdr_GETQUOTA2args (ZDR *, GETQUOTA2args*); -extern uint32_t zdr_GETQUOTA1res_ok (ZDR *, GETQUOTA1res_ok*); -extern uint32_t zdr_GETQUOTA1res (ZDR *, GETQUOTA1res*); - -#else /* K&R C */ -extern uint32_t zdr_rquotastat (); -extern uint32_t zdr_exportpath (); -extern uint32_t zdr_GETQUOTA1args (); -extern uint32_t zdr_quotatype (); -extern uint32_t zdr_GETQUOTA2args (); -extern uint32_t zdr_GETQUOTA1res_ok (); -extern uint32_t zdr_GETQUOTA1res (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_RQUOTA_H_RPCGEN */ diff --git a/include/nfsc/libnfs-raw.h b/include/nfsc/libnfs-raw.h deleted file mode 100644 index 1fa3f56..0000000 --- a/include/nfsc/libnfs-raw.h +++ /dev/null @@ -1,2298 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * This is the lowlevel interface to access NFS resources. - * Through this interface you have access to the full gamut of nfs and nfs - * related protocol as well as the XDR encoded/decoded structures. - */ -#ifndef _LIBNFS_RAW_H_ -#define _LIBNFS_RAW_H_ - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -struct rpc_data { - int size; - char *data; -}; - -struct rpc_context; - struct rpc_context *rpc_init_context(void); - void rpc_destroy_context(struct rpc_context *rpc); - - void rpc_set_auth(struct rpc_context *rpc, struct AUTH *auth); - -/* - * Used for interfacing the api into an al eventsystem. - * - * rpc_get_fd() returns the file descriptor to poll. - * - * rpc_which_events() returns which events that we need to poll for. - * This is a combination of the POLLIN and POLLOUT flags. - * - * rpc_service() is called everytime there are events that needs to be - * processed. - * revents is a combination of POLLIN/POLLOUT/POLLHUP/POLLERR - * - * This function returns 0 on success or -1 on error. If it returns -1 it - * means that the socket is in an unrecoverable error state (disconnected?) - * and that no further commands can be used. - * When this happens the application should destroy the now errored context - * re-create a new context and reconnect. - * - * - * rpc_service() will both process the events indicated by revents and also - * check for and terminate any RPCs that have timed out. - * Thus, if using rpc timeouts, you will need to ensure that rpc_service() - * is invoked on a regular basis so that the timeout processing can take place. - * The easiest way to do this is to call rpc_service() once every 100ms from - * your event system and passing revents as 0. - */ - int rpc_get_fd(struct rpc_context *rpc); - int rpc_which_events(struct rpc_context *rpc); - int rpc_service(struct rpc_context *rpc, int revents); - -/* - * Returns the number of commands in-flight. Can be used by the application - * to check if there are any more responses we are awaiting from the server - * or if the connection is completely idle. - */ - int rpc_queue_length(struct rpc_context *rpc); - -/* - * Set which UID/GID to use in the authenticator. - * By default libnfs will use getuid()/getgid() where available - * and 65534/65534 where not. - */ - void rpc_set_uid(struct rpc_context *rpc, int uid); - void rpc_set_gid(struct rpc_context *rpc, int gid); - -/* - * Create a server context. - */ - struct rpc_context *rpc_init_server_context(int s); - -/* This is the callback functions for server contexts. - * These are invoked from the library when a CALL has been received and a - * service procedure has been found that matches the rpc - * program/version/procedure. - * - * The rpc arguments are stored in call->body.cbody.args; - * Example: - * static int pmap2_getport_proc(struct rpc_context *rpc, struct rpc_msg *call) - * { - * pmap2_mapping *args = call->body.cbody.args; - * ... - * - * struct service_proc pmap2_pt[] = { - * {PMAP2_GETPORT, pmap2_getport_proc, - * (zdrproc_t)zdr_pmap2_mapping, sizeof(pmap2_mapping)}, - * ... - * - * - * The return value is: - * 0: Procedure was completed normally. - * !0: An abnormal error has occured. It is unrecoverable and the only - * meaningful action is to tear down the connection to the server. - */ -typedef int (*service_fn)(struct rpc_context *rpc, struct rpc_msg *call); - -struct service_proc { - int proc; - service_fn func; - zdrproc_t decode_fn; - int decode_buf_size; -}; - -/* - * Register a service callback table for program/version. - * Can only be used with contexts created with rpc_init_server_context() - */ - int rpc_register_service(struct rpc_context *rpc, int program, - int version, struct service_proc *procs, - int num_procs); - - int rpc_send_reply(struct rpc_context *rpc, struct rpc_msg *call, - void *reply, zdrproc_t encode_fn, - int alloc_hint); - -/* - * When an operation failed, this function can extract a detailed error string. - */ - char *rpc_get_error(struct rpc_context *rpc); - -/* Utility function to get an RPC context from a NFS context. Useful for doing - * low level NFSACL calls on a NFS context. - */ - struct rpc_context *nfs_get_rpc_context(struct nfs_context *nfs); - -/* This function returns the nfs_fh structure from a nfsfh structure. - This allows to use a file opened with nfs_open() together with low-level - rpc functions that thake a nfs filehandle -*/ - struct nfs_fh *nfs_get_fh(struct nfsfh *nfsfh); - -/* Control what the next XID value to be used on the context will be. - This can be used when multiple contexts are used to the same server - to avoid that the two contexts have xid collissions. - */ - void rpc_set_next_xid(struct rpc_context *rpc, uint32_t xid); - -/* This function can be used to set the file descriptor used for - * the RPC context. It is primarily useful when emulating dup2() - * and similar or where you want full control of the filedescriptor numbers - * used by the rpc socket. - * - * ... - * oldfd = rpc_get_fd(rpc); - * dup2(oldfd, newfd); - * rpc_set_fd(rpc, newfd); - * close(oldfd); - * ... - */ - void rpc_set_fd(struct rpc_context *rpc, int fd); - -#define RPC_STATUS_SUCCESS 0 -#define RPC_STATUS_ERROR 1 -#define RPC_STATUS_CANCEL 2 -#define RPC_STATUS_TIMEOUT 3 - -/* - * Async connection to the tcp port at server:port. - * Function returns - * 0 : The connection was initiated. The callback will be invoked once the - * connection establish finishes. - * <0 : An error occured when trying to set up the connection. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : The tcp connection was successfully established. - * data is NULL. - * RPC_STATUS_ERROR : The connection failed to establish. - * data is the error string. - * RPC_STATUS_CANCEL : The connection attempt was aborted before it could - * complete. - * : data is NULL. - */ - int rpc_connect_async(struct rpc_context *rpc, const char *server, - int port, rpc_cb cb, void *private_data); - -/* - * Async function to connect to a specific RPC program/version - * Function returns - * 0 : The connection was initiated. The callback will be invoked once the - * connection establish finishes. - * <0 : An error occured when trying to set up the connection. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : The tcp connection was successfully established. - * data is NULL. - * RPC_STATUS_ERROR : The connection failed to establish. - * data is the error string. - * RPC_STATUS_CANCEL : The connection attempt was aborted before it could - * complete. - * : data is NULL. - */ - int rpc_connect_program_async(struct rpc_context *rpc, - const char *server, - int program, int version, - rpc_cb cb, void *private_data); - -/* - * Async function to connect to a specific RPC program/version. - * This connects directly to the specified port without using portmapper. - * - * Function returns - * 0 : The connection was initiated. The callback will be invoked once the - * connection establish finishes. - * <0 : An error occured when trying to set up the connection. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : The tcp connection was successfully established. - * data is NULL. - * RPC_STATUS_ERROR : The connection failed to establish. - * data is the error string. - * RPC_STATUS_CANCEL : The connection attempt was aborted before it could - * complete. - * : data is NULL. - */ - int rpc_connect_port_async(struct rpc_context *rpc, const char *server, - int port, - int program, int version, - rpc_cb cb, void *private_data); - -/* - * When disconnecting a connection all commands in flight will be - * called with a callback status RPC_STATUS_ERROR. Data will be the - * error string for the disconnection. - */ - int rpc_disconnect(struct rpc_context *rpc, const char *error); - - -/* - * PORTMAP v2 FUNCTIONS - */ - -/* - * Call PORTMAPPER2/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap2_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - - -/* - * Call PORTMAPPER2/GETPORT. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a (uint32_t *), containing the port returned. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap2_getport_async(struct rpc_context *rpc, int program, - int version, int protocol, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER2/SET - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a (uint32_t *), containing status - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap2_set_async(struct rpc_context *rpc, int program, - int version, int protocol, int port, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER2/UNSET - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a (uint32_t *), containing status - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap2_unset_async(struct rpc_context *rpc, int program, - int version, int protocol, int port, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER2/DUMP. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is struct pmap2_dump_result. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap2_dump_async(struct rpc_context *rpc, rpc_cb cb, - void *private_data); - -/* - * Call PORTMAPPER2/CALLIT. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a 'pmap2_call_result' pointer. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap2_callit_async(struct rpc_context *rpc, int program, - int version, int procedure, - char *data, int datalen, - rpc_cb cb, void *private_data); - -/* - * PORTMAP v3 FUNCTIONS - */ - -/* - * Call PORTMAPPER3/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/SET. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is uint32_t * containing status. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct pmap3_mapping; - int rpc_pmap3_set_async(struct rpc_context *rpc, - struct pmap3_mapping *map, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/UNSET. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is uint32_t * containing status. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_unset_async(struct rpc_context *rpc, - struct pmap3_mapping *map, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/GETADDR. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is struct pmap3_string_result. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_getaddr_async(struct rpc_context *rpc, - struct pmap3_mapping *map, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/DUMP. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is struct pmap3_dump_result. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_dump_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/CALLIT. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a 'pmap3_call_result' pointer. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_callit_async(struct rpc_context *rpc, int program, - int version, int procedure, - char *data, int datalen, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/GETTIME. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a uint32_t * containing status. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_gettime_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/UADDR2TADDR. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a struct pmap3_netbuf *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_pmap3_uaddr2taddr_async(struct rpc_context *rpc, char *uaddr, - rpc_cb cb, void *private_data); - -/* - * Call PORTMAPPER3/TADDR2UADDR. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a struct pmap3_string_result *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct pmap3_netbuf; - int rpc_pmap3_taddr2uaddr_async(struct rpc_context *rpc, - struct pmap3_netbuf *netbuf, - rpc_cb cb, void *private_data); - -/* - * MOUNT v3 FUNCTIONS - */ - char *mountstat3_to_str(int stat); - int mountstat3_to_errno(int error); - -/* - * Call MOUNT3/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount3_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - int rpc_mount_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call MOUNT3/MNT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is union mountres3. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount3_mnt_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, void *private_data); - int rpc_mount_mnt_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, void *private_data); - -/* - * Call MOUNT3/DUMP - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a mountlist. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount3_dump_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - int rpc_mount_dump_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call MOUNT3/UMNT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount3_umnt_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, - void *private_data); - int rpc_mount_umnt_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, - void *private_data); - -/* - * Call MOUNT3/UMNTALL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount3_umntall_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - int rpc_mount_umntall_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call MOUNT3/EXPORT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is exports *: - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount3_export_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - int rpc_mount_export_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * MOUNT v1 FUNCTIONS (Used with NFSv2) - */ -/* - * Call MOUNT1/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount1_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call MOUNT1/MNT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is union mountres1. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount1_mnt_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, - void *private_data); - -/* - * Call MOUNT1/DUMP - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is a mountlist. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount1_dump_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call MOUNT1/UMNT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount1_umnt_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, - void *private_data); - -/* - * Call MOUNT1/UMNTALL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount1_umntall_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call MOUNT1/EXPORT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is exports *: - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_mount1_export_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - - -/* - * NFS v3 FUNCTIONS - */ -struct nfs_fh3; - char *nfsstat3_to_str(int error); - int nfsstat3_to_errno(int error); - -/* - * Call NFS3/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nfs3_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - int rpc_nfs_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call NFS3/GETATTR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETATTR3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct GETATTR3args; - int rpc_nfs3_getattr_async(struct rpc_context *rpc, rpc_cb cb, - struct GETATTR3args *args, - void *private_data); - int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - void *private_data); - -/* - * Call NFS3/PATHCONF - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is PATHCONF3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct PATHCONF3args; - int rpc_nfs3_pathconf_async(struct rpc_context *rpc, rpc_cb cb, - struct PATHCONF3args *args, - void *private_data); - int rpc_nfs_pathconf_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - void *private_data); - -/* - * Call NFS3/LOOKUP - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is LOOKUP3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct LOOKUP3args; - int rpc_nfs3_lookup_async(struct rpc_context *rpc, rpc_cb cb, - struct LOOKUP3args *args, - void *private_data); - int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, char *name, - void *private_data); - -/* - * Call NFS3/ACCESS - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is ACCESS3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct ACCESS3args; - int rpc_nfs3_access_async(struct rpc_context *rpc, rpc_cb cb, - struct ACCESS3args *args, - void *private_data); - int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, int access, - void *private_data); - -/* - * Call NFS3/READ - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READ3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READ3args; - int rpc_nfs3_read_async(struct rpc_context *rpc, rpc_cb cb, - struct READ3args *args, - void *private_data); - int rpc_nfs_read_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - uint64_t offset, uint64_t count, - void *private_data); - -/* - * Call NFS3/WRITE - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is WRITE3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct WRITE3args; - int rpc_nfs3_write_async(struct rpc_context *rpc, rpc_cb cb, - struct WRITE3args *args, - void *private_data); - int rpc_nfs_write_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - char *buf, uint64_t offset, uint64_t count, - int stable_how, - void *private_data); - -/* - * Call NFS3/COMMIT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is COMMIT3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct COMMIT3args; - int rpc_nfs3_commit_async(struct rpc_context *rpc, rpc_cb cb, - struct COMMIT3args *args, - void *private_data); - int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - void *private_data); - -/* - * Call NFS3/SETATTR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is SETATTR3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct SETATTR3args; - int rpc_nfs3_setattr_async(struct rpc_context *rpc, rpc_cb cb, - struct SETATTR3args *args, - void *private_data); - int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, - struct SETATTR3args *args, - void *private_data); - -/* - * Call NFS3/MKDIR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is MKDIR3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct MKDIR3args; - int rpc_nfs3_mkdir_async(struct rpc_context *rpc, rpc_cb cb, - struct MKDIR3args *args, - void *private_data); - int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, - struct MKDIR3args *args, - void *private_data); - -/* - * Call NFS3/RMDIR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is RMDIR3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct RMDIR3args; - int rpc_nfs3_rmdir_async(struct rpc_context *rpc, rpc_cb cb, - struct RMDIR3args *args, - void *private_data); - int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, char *dir, - void *private_data); - -/* - * Call NFS3/CREATE - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is CREATE3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct CREATE3args; - int rpc_nfs3_create_async(struct rpc_context *rpc, rpc_cb cb, - struct CREATE3args *args, - void *private_data); - int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, - struct CREATE3args *args, - void *private_data); - -/* - * Call NFS3/MKNOD - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is MKNOD3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct MKNOD3args; - int rpc_nfs3_mknod_async(struct rpc_context *rpc, rpc_cb cb, - struct MKNOD3args *args, - void *private_data); - int rpc_nfs_mknod_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - char *file, int mode, int major, int minor, - void *private_data); - -/* - * Call NFS3/REMOVE - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is REMOVE3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct REMOVE3args; - int rpc_nfs3_remove_async(struct rpc_context *rpc, rpc_cb cb, - struct REMOVE3args *args, - void *private_data); - int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, char *name, - void *private_data); - -/* - * Call NFS3/READDIR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READDIR3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READDIR3args; - int rpc_nfs3_readdir_async(struct rpc_context *rpc, rpc_cb cb, - struct READDIR3args *args, - void *private_data); - int rpc_nfs_readdir_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, uint64_t cookie, - char *cookieverf, int count, - void *private_data); - -/* - * Call NFS3/READDIRPLUS - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READDIRPLUS3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READDIRPLUS3args; - int rpc_nfs3_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, - struct READDIRPLUS3args *args, - void *private_data); - int rpc_nfs_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, uint64_t cookie, - char *cookieverf, int count, - void *private_data); - -/* - * Call NFS3/FSSTAT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is FSSTAT3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct FSSTAT3args; - int rpc_nfs3_fsstat_async(struct rpc_context *rpc, rpc_cb cb, - struct FSSTAT3args *args, - void *private_data); - int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - void *private_data); - -/* - * Call NFS3/FSINFO - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is FSINFO3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct FSINFO3args; - int rpc_nfs3_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, - struct FSINFO3args *args, - void *private_data); - int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *fh, - void *private_data); - -/* - * Call NFS3/READLINK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READLINK3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READLINK3args; - int rpc_nfs3_readlink_async(struct rpc_context *rpc, rpc_cb cb, - struct READLINK3args *args, - void *private_data); - int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, - struct READLINK3args *args, - void *private_data); - -/* - * Call NFS3/SYMLINK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is SYMLINK3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct SYMLINK3args; - int rpc_nfs3_symlink_async(struct rpc_context *rpc, rpc_cb cb, - struct SYMLINK3args *args, - void *private_data); - int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, - struct SYMLINK3args *args, - void *private_data); - -/* - * Call NFS3/RENAME - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is RENAME3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct RENAME3args; - int rpc_nfs3_rename_async(struct rpc_context *rpc, rpc_cb cb, - struct RENAME3args *args, - void *private_data); - int rpc_nfs_rename_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *olddir, char *oldname, - struct nfs_fh3 *newdir, char *newname, - void *private_data); - -/* - * Call NFS3/LINK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is LINK3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct LINK3args; - int rpc_nfs3_link_async(struct rpc_context *rpc, rpc_cb cb, - struct LINK3args *args, - void *private_data); - int rpc_nfs_link_async(struct rpc_context *rpc, rpc_cb cb, - struct nfs_fh3 *file, struct nfs_fh3 *newdir, - char *newname, - void *private_data); - -/* - * NFS v2 FUNCTIONS - */ - -/* - * Call NFS2/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nfs2_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call NFS2/GETATTR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETATTR2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct GETATTR2args; - int rpc_nfs2_getattr_async(struct rpc_context *rpc, rpc_cb cb, - struct GETATTR2args *args, - void *private_data); - -/* - * Call NFS2/SETATTR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is SETATTR2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct SETATTR2args; - int rpc_nfs2_setattr_async(struct rpc_context *rpc, rpc_cb cb, - struct SETATTR2args *args, - void *private_data); - -/* - * Call NFS2/LOOKUP - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is LOOKUP2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct LOOKUP2args; - int rpc_nfs2_lookup_async(struct rpc_context *rpc, rpc_cb cb, - struct LOOKUP2args *args, - void *private_data); - -/* - * Call NFS2/READLINK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READLINK2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READLINK2args; - int rpc_nfs2_readlink_async(struct rpc_context *rpc, rpc_cb cb, - struct READLINK2args *args, - void *private_data); - -/* - * Call NFS2/READ - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READ2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READ2args; - int rpc_nfs2_read_async(struct rpc_context *rpc, rpc_cb cb, - struct READ2args *args, - void *private_data); - -/* - * Call NFS2/WRITE - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is WRITE2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct WRITE2args; - int rpc_nfs2_write_async(struct rpc_context *rpc, rpc_cb cb, - struct WRITE2args *args, - void *private_data); - -/* - * Call NFS2/CREATE - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is CREATE2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct CREATE2args; - int rpc_nfs2_create_async(struct rpc_context *rpc, rpc_cb cb, - struct CREATE2args *args, - void *private_data); - -/* - * Call NFS2/REMOVE - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is REMOVE2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct REMOVE2args; - int rpc_nfs2_remove_async(struct rpc_context *rpc, rpc_cb cb, - struct REMOVE2args *args, - void *private_data); - -/* - * Call NFS2/RENAME - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is RENAME2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct RENAME2args; - int rpc_nfs2_rename_async(struct rpc_context *rpc, rpc_cb cb, - struct RENAME2args *args, - void *private_data); - -/* - * Call NFS2/LINK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is LINK2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct LINK2args; - int rpc_nfs2_link_async(struct rpc_context *rpc, rpc_cb cb, - struct LINK2args *args, - void *private_data); - -/* - * Call NFS2/SYMLINK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is SYMLINK2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct SYMLINK2args; - int rpc_nfs2_symlink_async(struct rpc_context *rpc, rpc_cb cb, - struct SYMLINK2args *args, - void *private_data); - -/* - * Call NFS2/MKDIR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is MKDIR2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct MKDIR2args; - int rpc_nfs2_mkdir_async(struct rpc_context *rpc, rpc_cb cb, - struct MKDIR2args *args, - void *private_data); - -/* - * Call NFS2/RMDIR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is RMDIR2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct RMDIR2args; - int rpc_nfs2_rmdir_async(struct rpc_context *rpc, rpc_cb cb, - struct RMDIR2args *args, - void *private_data); - -/* - * Call NFS2/READDIR - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is READDIR2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct READDIR2args; - int rpc_nfs2_readdir_async(struct rpc_context *rpc, rpc_cb cb, - struct READDIR2args *args, - void *private_data); - -/* - * Call NFS2/STATFS - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is STATFS2res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct STATFS2args; - int rpc_nfs2_statfs_async(struct rpc_context *rpc, rpc_cb cb, - struct STATFS2args *args, - void *private_data); - -/* - * RQUOTA FUNCTIONS - */ - char *rquotastat_to_str(int error); - int rquotastat_to_errno(int error); - -/* - * Call RQUOTA1/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_rquota1_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call RQUOTA1/GETQUOTA - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETQUOTA1res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_rquota1_getquota_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, int uid, - void *private_data); - -/* - * Call RQUOTA1/GETACTIVEQUOTA - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETQUOTA1res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_rquota1_getactivequota_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, int uid, - void *private_data); - - -/* - * Call RQUOTA2/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_rquota2_null_async(struct rpc_context *rpc, - rpc_cb cb, void *private_data); - -/* - * Call RQUOTA2/GETQUOTA - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETQUOTA1res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_rquota2_getquota_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, int type, int uid, - void *private_data); - -/* - * Call RQUOTA2/GETACTIVEQUOTA - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETQUOTA1res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_rquota2_getactivequota_async(struct rpc_context *rpc, rpc_cb cb, - char *exportname, int type, int uid, - void *private_data); - - -/* - * NFSACL functions - */ - -/* - * Call NFSACL/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nfsacl_null_async(struct rpc_context *rpc, rpc_cb cb, - void *private_data); - -/* - * Call NFSACL/GETACL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is GETACL3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct GETACL3args; - int rpc_nfsacl_getacl_async(struct rpc_context *rpc, rpc_cb cb, - struct GETACL3args *args, - void *private_data); - -/* - * Call NFSACL/SETACL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is SETACL3res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct SETACL3args; - int rpc_nfsacl_setacl_async(struct rpc_context *rpc, rpc_cb cb, - struct SETACL3args *args, - void *private_data); - - - - -/* - * NLM functions - */ - char *nlmstat4_to_str(int stat); - -/* - * Call NLM/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nlm4_null_async(struct rpc_context *rpc, rpc_cb cb, - void *private_data); - -/* - * Call NLM/TEST - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NLM4_TESTres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NLM4_TESTargs; - int rpc_nlm4_test_async(struct rpc_context *rpc, rpc_cb cb, - struct NLM4_TESTargs *args, - void *private_data); - -/* - * Call NLM/LOCK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NLM4_LOCKres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NLM4_LOCKargs; - int rpc_nlm4_lock_async(struct rpc_context *rpc, rpc_cb cb, - struct NLM4_LOCKargs *args, - void *private_data); - -/* - * Call NLM/CANCEL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NLM4_CANCres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NLM4_CANCargs; - int rpc_nlm4_cancel_async(struct rpc_context *rpc, rpc_cb cb, - struct NLM4_CANCargs *args, - void *private_data); - -/* - * Call NLM/UNLOCK - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NLM4_UNLOCKres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NLM4_UNLOCKargs; - int rpc_nlm4_unlock_async(struct rpc_context *rpc, rpc_cb cb, - struct NLM4_UNLOCKargs *args, - void *private_data); - -/* - * NSM functions - */ - char *nsmstat1_to_str(int stat); - -/* - * Call NSM/NULL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nsm1_null_async(struct rpc_context *rpc, rpc_cb cb, - void *private_data); - -/* - * Call NSM/STAT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NSM1_STATres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NSM1_STATargs; - int rpc_nsm1_stat_async(struct rpc_context *rpc, rpc_cb cb, - struct NSM1_STATargs *args, - void *private_data); - -/* - * Call NSM/MON - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NSM1_MONres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NSM1_MONargs; - int rpc_nsm1_mon_async(struct rpc_context *rpc, rpc_cb cb, - struct NSM1_MONargs *args, - void *private_data); - -/* - * Call NSM/UNMON - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NSM1_UNMONres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NSM1_UNMONargs; - int rpc_nsm1_unmon_async(struct rpc_context *rpc, rpc_cb cb, - struct NSM1_UNMONargs *args, - void *private_data); - -/* - * Call NSM/UNMONALL - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NSM1_UNMONALLres *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NSM1_UNMONALLargs; - int rpc_nsm1_unmonall_async(struct rpc_context *rpc, rpc_cb cb, - struct NSM1_UNMONALLargs *args, - void *private_data); - -/* - * Call NSM/SIMUCRASH - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nsm1_simucrash_async(struct rpc_context *rpc, rpc_cb cb, - void *private_data); - -/* - * Call NSM/NOTIFY - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct NSM1_NOTIFYargs; - int rpc_nsm1_notify_async(struct rpc_context *rpc, rpc_cb cb, - struct NSM1_NOTIFYargs *args, - void *private_data); - -/* - * NFS v4 FUNCTIONS - */ - char *nfsstat4_to_str(int error); - int nfsstat4_to_errno(int error); - -/* - * Call NFS4/NULL - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_nfs4_null_async(struct rpc_context *rpc, rpc_cb cb, - void *private_data); - -/* - * Call NFS4/COMPOUND - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is COMPOUND4res *. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ -struct COMPOUND4args; - int rpc_nfs4_compound_async(struct rpc_context *rpc, rpc_cb cb, - struct COMPOUND4args *args, - void *private_data); - -/* - * Call /NULL - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * RPC_STATUS_SUCCESS : We got a successful response from the server. - * data is NULL. - * RPC_STATUS_ERROR : The command failed with an error. - * data is the error string. - * RPC_STATUS_CANCEL : The command was cancelled. - * data is NULL. - */ - int rpc_null_async(struct rpc_context *rpc, int program, int version, - rpc_cb cb, void *private_data); - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/nfsc/libnfs-zdr.h b/include/nfsc/libnfs-zdr.h deleted file mode 100644 index 61603d9..0000000 --- a/include/nfsc/libnfs-zdr.h +++ /dev/null @@ -1,292 +0,0 @@ -/* - Copyright (C) 2012 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * This file contains definitions for the built in ZDR implementation. - * This is a very limited ZDR subset that can only marshal to/from a momory buffer, - * i.e. zdrmem_create() buffers. - * It aims to be compatible with normal rpcgen generated functions. - */ - -/************************************************************ - * Definitions copied from RFC 5531 - * and slightly modified. - ************************************************************/ - -#ifndef _LIBNFS_ZDR_H_ -#define _LIBNFS_ZDR_H_ - -#ifdef WIN32 -#ifndef CADDR_T_DEFINED -#define CADDR_T_DEFINED -typedef char *caddr_t; -#endif -#endif - -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define _RPC_RPC_H 1 -#define _RPC_ZDR_H 1 -#define _RPC_AUTH_H 1 - -/* we dont need these */ -typedef void CLIENT; -struct svc_req { - int _dummy_; -}; -typedef void SVCXPRT; - - - - - -#define ZDR_INLINE(...) NULL -#define IZDR_PUT_U_LONG(...) assert(0) -#define IZDR_GET_U_LONG(...) (assert(0), 0) -#define IZDR_PUT_LONG(...) assert(0) -#define IZDR_GET_LONG(...) (assert(0), 0) -#define IZDR_PUT_BOOL(...) assert(0) -#define IZDR_GET_BOOL(...) (assert(0), 0) - -#ifndef TRUE -#define TRUE 1 -#endif -#ifndef FALSE -#define FALSE 0 -#endif - -enum zdr_op { - ZDR_ENCODE = 0, - ZDR_DECODE = 1 -}; - -struct zdr_mem; - -struct ZDR { - enum zdr_op x_op; - caddr_t buf; - int size; - int pos; - struct zdr_mem *mem; -}; -typedef struct ZDR ZDR; - - -typedef uint32_t u_int; -typedef uint32_t enum_t; -typedef uint32_t bool_t; - -typedef uint32_t (*zdrproc_t) (ZDR *, void *,...); - -#define AUTH_NONE 0 -#define AUTH_NULL 0 -#define AUTH_UNIX 1 - -struct opaque_auth { - uint32_t oa_flavor; - caddr_t oa_base; - uint32_t oa_length; -}; -extern struct opaque_auth _null_auth; - -struct AUTH { - struct opaque_auth ah_cred; - struct opaque_auth ah_verf; - caddr_t ah_private; -}; - -#define RPC_MSG_VERSION 2 - -enum msg_type { - CALL = 0, - REPLY = 1 -}; - -enum reply_stat { - MSG_ACCEPTED=0, - MSG_DENIED=1 -}; - -enum accept_stat { - SUCCESS = 0, - PROG_UNAVAIL = 1, - PROG_MISMATCH = 2, - PROC_UNAVAIL = 3, - GARBAGE_ARGS = 4, - SYSTEM_ERR = 5 -}; - -enum reject_stat { - RPC_MISMATCH = 0, - AUTH_ERROR = 1 -}; - -enum auth_stat { - AUTH_OK=0, - /* - * failed at remote end - */ - AUTH_BADCRED = 1, /* bogus credentials (seal broken) */ - AUTH_REJECTEDCRED = 2, /* client should begin new session */ - AUTH_BADVERF = 3, /* bogus verifier (seal broken) */ - AUTH_REJECTEDVERF = 4, /* verifier expired or was replayed */ - AUTH_TOOWEAK = 5, /* rejected due to security reasons */ - /* - * failed locally - */ - AUTH_INVALIDRESP = 6, /* bogus response verifier */ - AUTH_FAILED = 7 /* some unknown reason */ -}; - -struct call_body { - uint32_t rpcvers; - uint32_t prog; - uint32_t vers; - uint32_t proc; - struct opaque_auth cred; - struct opaque_auth verf; - void *args; -}; - -struct accepted_reply { - struct opaque_auth verf; - uint32_t stat; - union { - struct { - caddr_t where; - zdrproc_t proc; - } results; - struct { - uint32_t low; - uint32_t high; - } mismatch_info; - } reply_data; -}; - -struct rejected_reply { - enum reject_stat stat; - union { - struct { - uint32_t low; - uint32_t high; - } mismatch_info; - enum auth_stat stat; - } reject_data; -}; - -struct reply_body { - uint32_t stat; - union { - struct accepted_reply areply; - struct rejected_reply rreply; - } reply; -}; - -struct rpc_msg { - uint32_t xid; - - uint32_t direction; - union { - struct call_body cbody; - struct reply_body rbody; - } body; -}; - -#define zdrmem_create libnfs_zdrmem_create -void libnfs_zdrmem_create(ZDR *zdrs, const caddr_t addr, uint32_t size, enum zdr_op xop); - -#define zdr_destroy libnfs_zdr_destroy -void libnfs_zdr_destroy(ZDR *zdrs); - -#define zdr_bytes libnfs_zdr_bytes -bool_t libnfs_zdr_bytes(ZDR *zdrs, char **bufp, uint32_t *size, uint32_t maxsize); - -#define zdr_u_int libnfs_zdr_u_int -#define zdr_uint32_t libnfs_zdr_u_int -bool_t libnfs_zdr_u_int(ZDR *zdrs, uint32_t *u); - -#define zdr_int libnfs_zdr_int -#define zdr_int32_t libnfs_zdr_int -bool_t libnfs_zdr_int(ZDR *zdrs, int32_t *i); - -#define zdr_uint64_t libnfs_zdr_uint64_t -bool_t libnfs_zdr_uint64_t(ZDR *zdrs, uint64_t *u); - -#define zdr_int64_t libnfs_zdr_int64_t -bool_t libnfs_zdr_int64_t(ZDR *zdrs, int64_t *i); - -#define zdr_enum libnfs_zdr_enum -bool_t libnfs_zdr_enum(ZDR *zdrs, enum_t *e); - -#define zdr_bool libnfs_zdr_bool -bool_t libnfs_zdr_bool(ZDR *zdrs, bool_t *b); - -#define zdr_void libnfs_zdr_void -bool_t libnfs_zdr_void(ZDR *zdrs, void *); - -#define zdr_pointer libnfs_zdr_pointer -bool_t libnfs_zdr_pointer(ZDR *zdrs, char **objp, uint32_t size, zdrproc_t proc); - -#define zdr_opaque libnfs_zdr_opaque -bool_t libnfs_zdr_opaque(ZDR *zdrs, char *objp, uint32_t size); - -#define zdr_string libnfs_zdr_string -bool_t libnfs_zdr_string(ZDR *zdrs, char **strp, uint32_t maxsize); - -#define zdr_array libnfs_zdr_array -bool_t libnfs_zdr_array(ZDR *zdrs, char **arrp, uint32_t *size, uint32_t maxsize, uint32_t elsize, zdrproc_t proc); - -#define zdr_setpos libnfs_zdr_setpos -bool_t libnfs_zdr_setpos(ZDR *zdrs, uint32_t pos); - -#define zdr_getpos libnfs_zdr_getpos -uint32_t libnfs_zdr_getpos(ZDR *zdrs); - -#define zdr_free libnfs_zdr_free -void libnfs_zdr_free(zdrproc_t proc, char *objp); - -struct rpc_context; - -#define zdr_callmsg libnfs_zdr_callmsg -bool_t libnfs_zdr_callmsg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg); - -#define zdr_replymsg libnfs_zdr_replymsg -bool_t libnfs_zdr_replymsg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg); - -#define authnone_create libnfs_authnone_create -struct AUTH *libnfs_authnone_create(void); - -#define authunix_create libnfs_authunix_create -struct AUTH *libnfs_authunix_create(const char *host, uint32_t uid, uint32_t gid, uint32_t len, uint32_t *groups); - -#define authunix_create_default libnfs_authunix_create_default -struct AUTH *libnfs_authunix_create_default(void); - -#define auth_destroy libnfs_auth_destroy -void libnfs_auth_destroy(struct AUTH *auth); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/nfsc/libnfs.h b/include/nfsc/libnfs.h deleted file mode 100755 index 3561ac4..0000000 --- a/include/nfsc/libnfs.h +++ /dev/null @@ -1,1967 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * This is the high-level interface to access NFS resources using posix-like - * functions. - */ - -#ifndef _LIBNFS_H_ -#define _LIBNFS_H_ - -#include -#if defined(__ANDROID__) || defined(AROS) \ - || ( defined(__APPLE__) && defined(__MACH__) ) \ - || defined(__PS4__) -#include -#else -#include -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -#define LIBNFS_FEATURE_READAHEAD -#define LIBNFS_FEATURE_PAGECACHE -#define LIBNFS_FEATURE_DEBUG -#define LIBNFS_FEATURE_UMOUNT - -#define NFS_BLKSIZE 4096 -#define NFS_PAGECACHE_DEFAULT_TTL 5 - -#define DEBUGNETLEVEL 0 - -struct nfs_context; -struct rpc_context; - -struct nfs_url { - char *server; - char *path; - char *file; -}; - - -//#define EXTERN - - -#ifdef WIN32 -#ifdef HAVE_FUSE_H -#include -#else -struct statvfs { - uint32_t f_bsize; - uint32_t f_frsize; - uint64_t f_blocks; - uint64_t f_bfree; - uint64_t f_bavail; - uint32_t f_files; - uint32_t f_ffree; - uint32_t f_favail; - uint32_t f_fsid; - uint32_t f_flag; - uint32_t f_namemax; -}; -#endif -#if !defined(__MINGW32__) -struct utimbuf { - time_t actime; - time_t modtime; -}; -#endif -#define R_OK 4 -#define W_OK 2 -#define X_OK 1 -#endif - -/* - * Used for interfacing the async version of the api into an external - * eventsystem. - * - * nfs_get_fd() returns the file descriptor for the context we need to - * listen for events from. - * - * nfs_which_events() returns which events that we need to poll for. - * This is a combination of the POLLIN and POLLOUT flags. - * - * nfs_service() This function should be called once there are events triggered - * for the filedescriptor. This function takes POLLIN/POLLOUT/POLLHUP/POLLERR - * as arguments. - * This function returns 0 on success or -1 on error. If it returns -1 it - * means that the socket is in an unrecoverable error state (disconnected?) - * and that no further commands can be used. - * When this happens the application should destroy the now errored context - * re-create a new context and reconnect. - * - * - * If using the async interface and nfs timeouts, i.e. nfs_set_timeout(), - * you will need to ensure to call nfs_service() on a regular basis as - * the timeout handling is done as part of that function. - * For example calling nfs_service() with revents == 0 once every 100ms - * or so from your event loop. - * You only need this for the async interface. The sync interface already - * do this in their built-in event loops. - */ - int nfs_get_fd(struct nfs_context *nfs); - int nfs_which_events(struct nfs_context *nfs); - int nfs_service(struct nfs_context *nfs, int revents); - -/* - * Returns the number of commands in-flight. Can be used by the application - * to check if there are any more responses we are awaiting for the server - * or if the connection is completely idle. - */ - int nfs_queue_length(struct nfs_context *nfs); - -/* - * Used if you need different credentials than the default for the current user. - */ -struct AUTH; - void nfs_set_auth(struct nfs_context *nfs, struct AUTH *auth); - -/* - * Used if you need to bind to a specific interface. - * Only available on platforms that support SO_BINDTODEVICE. - */ - void nfs_set_interface(struct nfs_context *nfs, const char *ifname); - -/* - * When an operation failed, this function can extract a detailed error string. - */ - char *nfs_get_error(struct nfs_context *nfs); - - -/* - * Callback for all ASYNC nfs functions - */ -typedef void (*nfs_cb)(int err, struct nfs_context *nfs, void *data, - void *private_data); - -/* - * Callback for all ASYNC rpc functions - */ -typedef void (*rpc_cb)(struct rpc_context *rpc, int status, void *data, - void *private_data); - - - -/* - * NFS CONTEXT. - */ -/* - * Create an NFS context. - * Function returns - * NULL : Failed to create a context. - * *nfs : A pointer to an nfs context. - */ - struct nfs_context *nfs_init_context(void); -/* - * Destroy an nfs context. - */ - void nfs_destroy_context(struct nfs_context *nfs); - - -/* - * URL parsing functions. - * These functions all parse a URL of the form - * nfs://server/path/file?argv=val[&arg=val]* - * and returns a nfs_url. - * - * Apart from parsing the URL the functions will also update - * the nfs context to reflect settings controlled via url arguments. - * - * Current URL arguments are : - * tcp-syncnt= : Number of SYNs to send during the session establish - * before failing setting up the TCP connection to the - * server. - * uid= : UID value to use when talking to the server. - * default is 65534 on Windows and getuid() on unixen. - * gid= : GID value to use when talking to the server. - * default is 65534 on Windows and getgid() on unixen. - * readahead= : Enable readahead for files and set the maximum amount - * of readahead to bytes. - * auto-traverse-mounts=<0|1> - * : Should libnfs try to traverse across nested mounts - * automatically or not. Default is 1 == enabled. - * dircache=<0|1> : Disable/enable directory caching. Enabled by default. - * autoreconnect=<-1|0|>=1> - * : Control the auto-reconnect behaviour to the NFS session. - * -1 : Try to reconnect forever on session failures. - * Just like normal NFS clients do. - * 0 : Disable auto-reconnect completely and immediately - * return a failure to the application. - * >=1 : Retry to connect back to the server this many - * times before failing and returing an error back - * to the application. - * version=<3|4> : NFS version. Default is 3. - * Version 4 is not yet functional. Do not use. - * nfsport= : Use this port for NFS instead of using the portmapper. - * mountport= : Use this port for the MOUNT protocol instead of - * using portmapper. This argument is ignored for NFSv4 - * as it does not use the MOUNT protocol. - */ -/* - * Parse a complete NFS URL including, server, path and - * filename. Fail if any component is missing. - */ - struct nfs_url *nfs_parse_url_full(struct nfs_context *nfs, - const char *url); - -/* - * Parse an NFS URL, but do not split path and file. File - * in the resulting struct remains NULL. - */ - struct nfs_url *nfs_parse_url_dir(struct nfs_context *nfs, - const char *url); - -/* - * Parse an NFS URL, but do not fail if file, path or even server is missing. - * Check elements of the resulting struct for NULL. - */ - struct nfs_url *nfs_parse_url_incomplete(struct nfs_context *nfs, - const char *url); - - -/* - * Free the URL struct returned by the nfs_parse_url_* functions. - */ - void nfs_destroy_url(struct nfs_url *url); - - -struct nfsfh; - -/* - * Get the maximum supported READ3 size by the server - */ - uint64_t nfs_get_readmax(struct nfs_context *nfs); - -/* - * Get the maximum supported WRITE3 size by the server - */ - uint64_t nfs_get_writemax(struct nfs_context *nfs); - -/* - * MODIFY CONNECT PARAMETERS - */ - - void nfs_set_tcp_syncnt(struct nfs_context *nfs, int v); - void nfs_set_uid(struct nfs_context *nfs, int uid); - void nfs_set_gid(struct nfs_context *nfs, int gid); - void nfs_set_pagecache(struct nfs_context *nfs, uint32_t v); - void nfs_set_pagecache_ttl(struct nfs_context *nfs, uint32_t v); - void nfs_set_readahead(struct nfs_context *nfs, uint32_t v); - void nfs_set_debug(struct nfs_context *nfs, int level); - void nfs_set_dircache(struct nfs_context *nfs, int enabled); - void nfs_set_autoreconnect(struct nfs_context *nfs, int num_retries); - -/* - * Set NFS version. Supported versions are - * NFS_V3 (default) - * NFS_V4 - */ - int nfs_set_version(struct nfs_context *nfs, int version); - -/* - * Invalidate the pagecache - */ - void nfs_pagecache_invalidate(struct nfs_context *nfs, - struct nfsfh *nfsfh); - -/* - * Initialize the pagecache - */ - void nfs_pagecache_init(struct nfs_context *nfs, - struct nfsfh *nfsfh); - -/* - * MOUNT THE EXPORT - */ -/* - * Async nfs mount. - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_mount_async(struct nfs_context *nfs, const char *server, - const char *exportname, nfs_cb cb, - void *private_data); -/* - * Sync nfs mount. - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_mount(struct nfs_context *nfs, const char *server, - const char *exportname); - - -/* - * UNMOUNT THE EXPORT - */ -/* - * Async nfs umount. - * For NFSv4 this is a NO-OP. - * For NFSv3 this function returns unregisters the mount from the MOUNT Daemon. - * - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_umount_async(struct nfs_context *nfs, nfs_cb cb, - void *private_data); -/* - * Sync nfs umount. - * For NFSv4 this is a NO-OP. - * For NFSv3 this function returns unregisters the mount from the MOUNT Daemon. - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_umount(struct nfs_context *nfs); - - - - -/* - * STAT() - */ -/* - * Async stat() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct stat * - * -errno : An error occured. - * data is the error string. - */ -/* This function is deprecated. Use nfs_stat64_async() instead */ -struct stat; - int nfs_stat_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data); -/* - * Sync stat() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ -/* This function is deprecated. Use nfs_stat64() instead */ -#ifdef WIN32 - int nfs_stat(struct nfs_context *nfs, const char *path, - struct __stat64 *st); -#else - int nfs_stat(struct nfs_context *nfs, const char *path, struct stat *st); -#endif - - -/* nfs_stat64 - * 64 bit version if stat. All fields are always 64bit. - * Use these functions instead of nfs_stat[_async](), especially if you - * have weird stat structures. - */ -/* - * STAT() - */ -struct nfs_stat_64 { - uint64_t nfs_dev; - uint64_t nfs_ino; - uint64_t nfs_mode; - uint64_t nfs_nlink; - uint64_t nfs_uid; - uint64_t nfs_gid; - uint64_t nfs_rdev; - uint64_t nfs_size; - uint64_t nfs_blksize; - uint64_t nfs_blocks; - uint64_t nfs_atime; - uint64_t nfs_mtime; - uint64_t nfs_ctime; - uint64_t nfs_atime_nsec; - uint64_t nfs_mtime_nsec; - uint64_t nfs_ctime_nsec; - uint64_t nfs_used; -}; - -/* - * Async stat() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct nfs_stat_64 * - * -errno : An error occured. - * data is the error string. - */ - int nfs_stat64_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync stat() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_stat64(struct nfs_context *nfs, const char *path, - struct nfs_stat_64 *st); - -/* - * Async stat() - * - * Like stat except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct nfs_stat_64 * - * -errno : An error occured. - * data is the error string. - */ - int nfs_lstat64_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync stat() - * - * Like stat except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_lstat64(struct nfs_context *nfs, const char *path, - struct nfs_stat_64 *st); - -/* - * FSTAT() - */ -/* - * Async fstat(nfsfh *) - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct stat * - * -errno : An error occured. - * data is the error string. - */ -/* This function is deprecated. Use nfs_fstat64_async() instead */ - int nfs_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - nfs_cb cb, void *private_data); -/* - * Sync fstat(nfsfh *) - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ -#ifdef WIN32 - int nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, - struct __stat64 *st); -#else - int nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, - struct stat *st); -#endif - -/* nfs_fstat64 - * 64 bit version of fstat. All fields are always 64bit. - * Use these functions instead of nfs_fstat[_async](), especially if you - * have weird stat structures. - */ -/* - * FSTAT() - */ -/* - * Async fstat(nfsfh *) - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct stat * - * -errno : An error occured. - * data is the error string. - */ - int nfs_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - nfs_cb cb, void *private_data); -/* - * Sync fstat(nfsfh *) - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_fstat64(struct nfs_context *nfs, struct nfsfh *nfsfh, - struct nfs_stat_64 *st); - -/* - * UMASK() never blocks, so no special aync/async versions are available - */ -/* - * Sync umask() - * Function returns the old mask. - */ - uint16_t nfs_umask(struct nfs_context *nfs, uint16_t mask); - -/* - * OPEN() - */ -/* - * Async open() - * - * mode is a combination of the flags : - * O_RDONLY, O_WRONLY, O_RDWR , O_SYNC, O_APPEND, O_TRUNC, O_NOFOLLOW, - * O_CREAT - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * Supported flags are - * O_NOFOLLOW - * O_APPEND - * O_CREAT - * O_RDONLY - * O_WRONLY - * O_RDWR - * O_SYNC - * O_TRUNC (Only valid with O_RDWR or O_WRONLY. Ignored otherwise.) - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is a struct *nfsfh; - * The nfsfh is close using nfs_close(). - * -errno : An error occured. - * data is the error string. - */ - int nfs_open_async(struct nfs_context *nfs, const char *path, int flags, - nfs_cb cb, void *private_data); - int nfs_open2_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data); -/* - * Sync open() - * Function returns - * 0 : The operation was successful. *nfsfh is filled in. - * -errno : The command failed. - */ - int nfs_open(struct nfs_context *nfs, const char *path, int flags, - struct nfsfh **nfsfh); - int nfs_open2(struct nfs_context *nfs, const char *path, int flags, - int mode, struct nfsfh **nfsfh); - - - - -/* - * CLOSE - */ -/* - * Async close(nfsfh) - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL. - * -errno : An error occured. - * data is the error string. - */ - int nfs_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - nfs_cb cb, void *private_data); -/* - * Sync close(nfsfh) - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_close(struct nfs_context *nfs, struct nfsfh *nfsfh); - - -/* - * PREAD() - */ -/* - * Async pread() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * >=0 : Success. - * status is numer of bytes read. - * data is a pointer to the returned data. - * -errno : An error occured. - * data is the error string. - */ - int nfs_pread_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, uint64_t count, nfs_cb cb, - void *private_data); -/* - * Sync pread() - * Function returns - * >=0 : numer of bytes read. - * -errno : An error occured. - */ - int nfs_pread(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, uint64_t count, void *buf); - - - -/* - * READ() - */ -/* - * Async read() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * >=0 : Success. - * status is numer of bytes read. - * data is a pointer to the returned data. - * -errno : An error occured. - * data is the error string. - */ - int nfs_read_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t count, nfs_cb cb, void *private_data); -/* - * Sync read() - * Function returns - * >=0 : numer of bytes read. - * -errno : An error occured. - */ - int nfs_read(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t count, void *buf); - - - - -/* - * PWRITE() - */ -/* - * Async pwrite() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * >=0 : Success. - * status is numer of bytes written. - * -errno : An error occured. - * data is the error string. - */ - int nfs_pwrite_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, uint64_t count, const void *buf, - nfs_cb cb, void *private_data); -/* - * Sync pwrite() - * Function returns - * >=0 : numer of bytes written. - * -errno : An error occured. - */ - int nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, uint64_t count, const void *buf); - - -/* - * WRITE() - */ -/* - * Async write() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * >=0 : Success. - * status is numer of bytes written. - * -errno : An error occured. - * data is the error string. - */ - int nfs_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t count, const void *buf, nfs_cb cb, - void *private_data); -/* - * Sync write() - * Function returns - * >=0 : numer of bytes written. - * -errno : An error occured. - */ - int nfs_write(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t count, const void *buf); - - -/* - * LSEEK() - */ -/* - * Async lseek() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * >=0 : Success. - * data is uint64_t * for the current position. - * -errno : An error occured. - * data is the error string. - */ - int nfs_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - int64_t offset, int whence, nfs_cb cb, - void *private_data); -/* - * Sync lseek() - * Function returns - * >=0 : numer of bytes read. - * -errno : An error occured. - */ - int nfs_lseek(struct nfs_context *nfs, struct nfsfh *nfsfh, - int64_t offset, int whence, uint64_t *current_offset); - - -/* - * LOCKF() - */ -/* - * Async lockf() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ -enum nfs4_lock_op { - NFS4_F_LOCK = 0, - NFS4_F_TLOCK = 1, - NFS4_F_ULOCK = 2, - NFS4_F_TEST = 3, -}; - int nfs_lockf_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_lock_op op, uint64_t count, - nfs_cb cb, void *private_data); -/* - * Sync lockf() - * Function returns - * 0 : Success. - * -errno : An error occured. - */ - int nfs_lockf(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_lock_op op, uint64_t count); - -/* - * FCNTL() - */ -/* - * Async fcntl() - * Supported commands are : - * NFS4_F_SETLK - * NFS4_F_SETLKW - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ -enum nfs4_fcntl_op { - NFS4_F_SETLK = 0, - NFS4_F_SETLKW, -}; -struct nfs4_flock { - int l_type; /* F_RDLCK, F_WRLCK or F_UNLCK */ - int l_whence; /* SEEK_SET, SEEK_CUR or SEEK_END */ - uint32_t l_pid; - uint64_t l_start; - uint64_t l_len; -}; - - int nfs_fcntl_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_fcntl_op cmd, void *arg, - nfs_cb cb, void *private_data); -/* - * Sync lockf() - * Function returns - * 0 : Success. - * -errno : An error occured. - */ - int nfs_fcntl(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_fcntl_op cmd, void *arg); - -/* - * FSYNC() - */ -/* - * Async fsync() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_fsync_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - nfs_cb cb, void *private_data); -/* - * Sync fsync() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_fsync(struct nfs_context *nfs, struct nfsfh *nfsfh); - - - -/* - * TRUNCATE() - */ -/* - * Async truncate() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_truncate_async(struct nfs_context *nfs, const char *path, - uint64_t length, nfs_cb cb, void *private_data); -/* - * Sync truncate() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_truncate(struct nfs_context *nfs, const char *path, - uint64_t length); - - - -/* - * FTRUNCATE() - */ -/* - * Async ftruncate() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_ftruncate_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t length, nfs_cb cb, void *private_data); -/* - * Sync ftruncate() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_ftruncate(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t length); - - - - - - -/* - * MKDIR() - */ -/* - * Async mkdir() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_mkdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync mkdir() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_mkdir(struct nfs_context *nfs, const char *path); - -/* - * Async mkdir2() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_mkdir2_async(struct nfs_context *nfs, const char *path, - int mode, nfs_cb cb, void *private_data); -/* - * Sync mkdir2() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_mkdir2(struct nfs_context *nfs, const char *path, int mode); - - - -/* - * RMDIR() - */ -/* - * Async rmdir() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_rmdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync rmdir() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_rmdir(struct nfs_context *nfs, const char *path); - - - - -/* - * CREAT() - */ -/* - * Async creat() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is a struct *nfsfh; - * -errno : An error occured. - * data is the error string. - */ - int nfs_creat_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data); -/* - * Sync creat() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_creat(struct nfs_context *nfs, const char *path, int mode, - struct nfsfh **nfsfh); - -/* - * Async create() - * - * Same as nfs_creat_async but allows passing flags: - * O_NOFOLLOW - * O_APPEND - * O_SYNC - * O_EXCL - * O_TRUNC - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is a struct *nfsfh; - * -errno : An error occured. - * data is the error string. - */ - int nfs_create_async(struct nfs_context *nfs, const char *path, - int flags, int mode, nfs_cb cb, void *private_data); -/* - * Sync create() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_create(struct nfs_context *nfs, const char *path, int flags, - int mode, struct nfsfh **nfsfh); - - -/* - * MKNOD() - */ -/* - * Async mknod() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * -errno : An error occured. - * data is the error string. - */ - int nfs_mknod_async(struct nfs_context *nfs, const char *path, int mode, - int dev, nfs_cb cb, void *private_data); -/* - * Sync mknod() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_mknod(struct nfs_context *nfs, const char *path, int mode, - int dev); - - - -/* - * UNLINK() - */ -/* - * Async unlink() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_unlink_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync unlink() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_unlink(struct nfs_context *nfs, const char *path); - - - - -/* - * OPENDIR() - */ -struct nfsdir; -/* - * Async opendir() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When struct nfsdir * is returned, this resource is closed/freed by calling nfs_closedir() - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct nfsdir * - * -errno : An error occured. - * data is the error string. - */ - int nfs_opendir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync opendir() - * Function returns - * 0 : Success - * -errno : An error occured. - */ - int nfs_opendir(struct nfs_context *nfs, const char *path, - struct nfsdir **nfsdir); - - - -/* - * READDIR() - */ -struct nfsdirent { - struct nfsdirent *next; - char *name; - uint64_t inode; - - /* Some extra fields we get for free through the READDIRPLUS3 call. - You need libnfs-raw-nfs.h for type/mode constants */ - uint32_t type; /* NF3REG, NF3DIR, NF3BLK, ... */ - uint32_t mode; - uint64_t size; - struct timeval atime; - struct timeval mtime; - struct timeval ctime; - uint32_t uid; - uint32_t gid; - uint32_t nlink; - uint64_t dev; - uint64_t rdev; - uint64_t blksize; - uint64_t blocks; - uint64_t used; - uint32_t atime_nsec; - uint32_t mtime_nsec; - uint32_t ctime_nsec; -}; -/* - * nfs_readdir() never blocks, so no special sync/async versions are available - */ - struct nfsdirent *nfs_readdir(struct nfs_context *nfs, - struct nfsdir *nfsdir); - - -/* - * SEEKDIR() - */ -/* - * This function will never block so there is no need for an async version. - */ - void nfs_seekdir(struct nfs_context *nfs, struct nfsdir *nfsdir, - long loc); - -/* - * TELLDIR() - */ -/* - * On success, nfs_telldir() will return a location as a value >= 0. - * On failure, nfs_telldir() will return -1. - * - * This function will never block so there is no need for an async version. - */ - long nfs_telldir(struct nfs_context *nfs, struct nfsdir *nfsdir); - - -/* - * REWINDDIR() - */ -/* - * nfs_rewinddir() cancel all previous nfs_readdir() side effects. - * This function will never block so there is no need for an async version. - */ - void nfs_rewinddir(struct nfs_context *nfs, struct nfsdir *nfsdir); - - -/* - * CLOSEDIR() - */ -/* - * nfs_closedir() never blocks, so no special sync/async versions are available - */ - void nfs_closedir(struct nfs_context *nfs, struct nfsdir *nfsdir); - - -/* - * CHDIR() - */ -/* - * Async chdir() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL; - * -errno : An error occured. - * data is the error string. - */ - int nfs_chdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync chdir() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_chdir(struct nfs_context *nfs, const char *path); - -/* - * GETCWD() - */ -/* - * nfs_getcwd() never blocks, so no special sync/async versions are available - */ -/* - * Sync getcwd() - * This function returns a pointer to the current working directory. - * This pointer is only stable until the next [f]chdir or when the - * context is destroyed. - * - * Function returns - * 0 : The operation was successful and *cwd is filled in. - * -errno : The command failed. - */ - void nfs_getcwd(struct nfs_context *nfs, const char **cwd); - - -/* - * STATVFS() - */ -struct nfs_statvfs_64 { - uint64_t f_bsize; - uint64_t f_frsize; - uint64_t f_blocks; - uint64_t f_bfree; - uint64_t f_bavail; - uint64_t f_files; - uint64_t f_ffree; - uint64_t f_favail; - uint64_t f_fsid; - uint64_t f_flag; - uint64_t f_namemax; -}; -/* - * Async statvfs() - * This function is deprecated. Use nfs_statvfs64_async() instead. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct statvfs * - * -errno : An error occured. - * data is the error string. - */ -struct statvfs; - int nfs_statvfs_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync statvfs() - * This function is deprecated. Use nfs_statvfs64() instead. - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_statvfs(struct nfs_context *nfs, const char *path, - struct statvfs *svfs); -/* - * Async statvfs64() - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is struct nfs_statvfs_64 * - * -errno : An error occured. - * data is the error string. - */ - int nfs_statvfs64_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync statvfs64() - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_statvfs64(struct nfs_context *nfs, const char *path, - struct nfs_statvfs_64 *svfs); - -/* - * READLINK() - */ -/* - * Async readlink() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is a char * - * data is only valid during the callback and is automatically freed - * when the callback returns. - * -errno : An error occured. - * data is the error string. - */ - int nfs_readlink_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync readlink() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_readlink(struct nfs_context *nfs, const char *path, char *buf, - int bufsize); - -/* - * Sync readlink2() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - * *bufptr : NULL if the command failed, otherwise the contents of the symlink. - * The caller must free the buffer. - */ - int nfs_readlink2(struct nfs_context *nfs, const char *path, - char **bufptr); - - - -/* - * CHMOD() - */ -/* - * Async chmod() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_chmod_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data); -/* - * Sync chmod() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_chmod(struct nfs_context *nfs, const char *path, int mode); -/* - * Async chmod() - * - * Like chmod except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_lchmod_async(struct nfs_context *nfs, const char *path, - int mode, nfs_cb cb, void *private_data); -/* - * Sync chmod() - * - * Like chmod except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_lchmod(struct nfs_context *nfs, const char *path, int mode); - - - -/* - * FCHMOD() - */ -/* - * Async fchmod() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_fchmod_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - int mode, nfs_cb cb, void *private_data); -/* - * Sync fchmod() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_fchmod(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode); - - - -/* - * CHOWN() - */ -/* - * Async chown() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_chown_async(struct nfs_context *nfs, const char *path, int uid, - int gid, nfs_cb cb, void *private_data); -/* - * Sync chown() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_chown(struct nfs_context *nfs, const char *path, int uid, - int gid); -/* - * Async chown() - * - * Like chown except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_lchown_async(struct nfs_context *nfs, const char *path, int uid, - int gid, nfs_cb cb, void *private_data); -/* - * Sync chown() - * - * Like chown except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_lchown(struct nfs_context *nfs, const char *path, int uid, - int gid); - - - -/* - * FCHOWN() - */ -/* - * Async fchown() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_fchown_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - int uid, int gid, nfs_cb cb, void *private_data); -/* - * Sync fchown() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_fchown(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, - int gid); - - - - -/* - * UTIMES() - */ -/* - * Async utimes() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_utimes_async(struct nfs_context *nfs, const char *path, - struct timeval *times, nfs_cb cb, - void *private_data); -/* - * Sync utimes() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_utimes(struct nfs_context *nfs, const char *path, - struct timeval *times); -/* - * Async utimes() - * - * Like utimes except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_lutimes_async(struct nfs_context *nfs, const char *path, - struct timeval *times, nfs_cb cb, - void *private_data); -/* - * Sync utimes() - * - * Like utimes except if the destination is a symbolic link, it acts on the - * symbolic link itself. - * - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_lutimes(struct nfs_context *nfs, const char *path, - struct timeval *times); - - -/* - * UTIME() - */ -/* - * Async utime() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ -struct utimbuf; - int nfs_utime_async(struct nfs_context *nfs, const char *path, - struct utimbuf *times, nfs_cb cb, - void *private_data); -/* - * Sync utime() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_utime(struct nfs_context *nfs, const char *path, - struct utimbuf *times); - - - - -/* - * ACCESS() - */ -/* - * Async access() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_access_async(struct nfs_context *nfs, const char *path, - int mode, nfs_cb cb, void *private_data); -/* - * Sync access() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_access(struct nfs_context *nfs, const char *path, int mode); - - - - - -/* - * ACCESS2() - */ -/* - * Async access2() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * >= 0 : A mask of R_OK, W_OK and X_OK indicating which permissions are - * available. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_access2_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data); -/* - * Sync access() - * Function returns - * >= 0 : A mask of R_OK, W_OK and X_OK indicating which permissions are - * available. - * -errno : The command failed. - */ - int nfs_access2(struct nfs_context *nfs, const char *path); - - - - -/* - * SYMLINK() - */ -/* - * Async symlink() - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_symlink_async(struct nfs_context *nfs, const char *target, - const char *linkname, nfs_cb cb, - void *private_data); -/* - * Sync symlink() - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_symlink(struct nfs_context *nfs, const char *target, - const char *linkname); - - -/* - * RENAME() - */ -/* - * Async rename(, ) - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_rename_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -/* - * Sync rename(, ) - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_rename(struct nfs_context *nfs, const char *oldpath, - const char *newpath); - - - -/* - * LINK() - */ -/* - * Async link(, ) - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is NULL - * -errno : An error occured. - * data is the error string. - */ - int nfs_link_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data); -/* - * Sync link(, ) - * Function returns - * 0 : The operation was successful. - * -errno : The command failed. - */ - int nfs_link(struct nfs_context *nfs, const char *oldpath, - const char *newpath); - - -/* - * GETEXPORTS() - */ -/* - * Async getexports() - * NOTE: You must include 'libnfs-raw-mount.h' to get the definitions of the - * returned structures. - * - * This function will return the list of exports from an NFS server. - * - * Function returns - * 0 : The command was queued successfully. The callback will be invoked once - * the command completes. - * <0 : An error occured when trying to queue the command. - * The callback will not be invoked. - * - * When the callback is invoked, status indicates the result: - * 0 : Success. - * data is a pointer to an exports pointer: - * exports export = *(exports *)data; - * -errno : An error occured. - * data is the error string. - */ - int mount_getexports_async(struct rpc_context *rpc, const char *server, - rpc_cb cb, void *private_data); -/* - * Sync getexports() - * Function returns - * NULL : something failed - * exports export : a linked list of exported directories - * - * returned data must be freed by calling mount_free_export_list(exportnode); - */ - struct exportnode *mount_getexports(const char *server); - - void mount_free_export_list(struct exportnode *exports); - - -struct nfs_server_list { - struct nfs_server_list *next; - char *addr; -}; - -/* - * Sync find_local_servers() - * This function will probe all local networks for NFS server. - * This function will block for one second while awaiting for all nfs servers - * to respond. - * - * Function returns - * NULL : something failed - * - * struct nfs_server_list : a linked list of all discovered servers - * - * returned data must be freed by nfs_free_srvr_list(srv); - */ -struct nfs_server_list *nfs_find_local_servers(void); -void free_nfs_srvr_list(struct nfs_server_list *srv); - -/* - * sync nfs_set_timeout() - * This function sets the timeout used for nfs rpc calls. - * - * Function returns nothing. - * - * int milliseconds : timeout to be applied in milliseconds (-1 no timeout) - * timeouts must currently be set in whole seconds, - * i.e. units of 1000 - */ - void nfs_set_timeout(struct nfs_context *nfs, int milliseconds); - -/* - * sync nfs_get_timeout() - * This function gets the timeout used for nfs rpc calls. - * - * Function returns - * -1 : No timeout applied - * > 0 : Timeout in milliseconds - */ - int nfs_get_timeout(struct nfs_context *nfs); - -/* - * Set the client name for NFSv4. - */ - void nfs4_set_client_name(struct nfs_context *nfs, const char *id); - -/* - * Set the client verifier for NFSv4. - * This an 8 byte array of random data. - */ - void nfs4_set_verifier(struct nfs_context *nfs, const char *verifier); - -#ifdef __cplusplus -} -#endif - -#endif /* !_LIBNFS_H_ */ diff --git a/include/orbisAudio.h b/include/orbisAudio.h deleted file mode 100644 index 1856bf4..0000000 --- a/include/orbisAudio.h +++ /dev/null @@ -1,99 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under Mit license -# Review README & LICENSE files for further details. -*/ - -#pragma once -#include - -//#include // ScePthread and (not really needed) "friends" -#include // posix threads and standard friends - -#ifdef __cplusplus -extern "C" { -#endif - - -#define ORBISAUDIO_ALIGN_SAMPLE(x,y) ((((x)+((y)-1))/(y))*(y)) -#define ORBISAUDIO_MIN_LEN 256 -#define ORBISAUDIO_MAX_LEN 2048 -#define ORBISAUDIO_CHANNELS 5 -#define ORBISAUDIO_CHANNEL_MAIN 0 -#define ORBISAUDIO_CHANNEL_BGM 1 -#define ORBISAUDIO_CHANNEL_VOICE 2 -#define ORBISAUDIO_CHANNEL_PERSONAL 3 -#define ORBISAUDIO_CHANNEL_AUX 4 -#define ORBISAUDIO_NUM_BUFFERS 2 -#define ORBISAUDIO_VOLUME_MAX 32768 -#define ORBISAUDIO_VOLUME_FLAG_LEFT_CHANNEL 0 -#define ORBISAUDIO_VOLUME_FLAG_RIGHT_CHANNEL 1 -#define ORBISAUDIO_FORMAT_S16_MONO 0 -#define ORBISAUDIO_FORMAT_S16_STEREO 1 - -typedef struct OrbisAudioStereoSample -{ - short l; - short r; -} OrbisAudioStereoSample; - -typedef struct OrbisAudioMonoSample -{ - short ch; -} OrbisAudioMonoSample; - -typedef union OrbisAudioSample -{ - OrbisAudioStereoSample stereo; - OrbisAudioMonoSample mono; -} OrbisAudioSample; - -typedef void (*OrbisAudioCallback)(OrbisAudioSample *buffer,unsigned int samples,void *user_data); - -typedef struct OrbisAudioChannel -{ - //ScePthread threadHandle; - pthread_t threadHandle; - int audioHandle; - unsigned int leftVol; - unsigned int rightVol; - OrbisAudioCallback callback; - void *userData; - short *sampleBuffer[2]; - unsigned int samples[2]; - unsigned char paused; - unsigned char stereo; - unsigned int currentBuffer; - int orbisaudiochannel_initialized; -}OrbisAudioChannel; - -typedef struct OrbisAudioConfig -{ - OrbisAudioChannel *channels[ORBISAUDIO_CHANNELS]; - unsigned char orbisaudio_stop; - int orbisaudio_initialized; -} OrbisAudioConfig; - - -int orbisAudioInit(); -void orbisAudioFinish(); -int orbisAudioGetStatus(); -int orbisAudioGetChannelStatus(int chan); -int orbisAudioGetHandle(int chan); -int orbisAudioPlayBlock(unsigned int channel,unsigned int vol1,unsigned int vol2,void *buf); -int orbisAudioInitChannelWithoutCallback(unsigned int channel, unsigned int samples, unsigned int frequency, int format); -int orbisAudioInitChannel(unsigned int channel, unsigned int samples, unsigned int frequency, int format); -int orbisAudioPause(unsigned int channel); -int orbisAudioResume(unsigned int channel); -int orbisAudioStop(); -int orbisAudioSetCallback(unsigned int channel,OrbisAudioCallback callback,void *userdata); -int orbisAudioInitWithConf(OrbisAudioConfig *conf); -OrbisAudioConfig *orbisAudioGetConf(); - -#ifdef __cplusplus -} -#endif diff --git a/include/orbisKeyboard.h b/include/orbisKeyboard.h deleted file mode 100644 index 5e2c4b7..0000000 --- a/include/orbisKeyboard.h +++ /dev/null @@ -1,133 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#pragma once - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define ORBIS_IME_MODULE 0x0095 - -typedef enum OrbisKeyboardEventId{ - ORBIS_KEYBOARD_EVENT_OPEN = 256, - ORBIS_KEYBOARD_EVENT_KEYCODE_DOWN = 257, - ORBIS_KEYBOARD_EVENT_KEYCODE_UP = 258, - ORBIS_KEYBOARD_EVENT_KEYCODE_REPEAT = 259, - ORBIS_KEYBOARD_EVENT_CONNECTION = 260, - ORBIS_KEYBOARD_EVENT_DISCONNECTION = 261, - ORBIS_KEYBOARD_EVENT_ABORT = 262, -} OrbisKeyboardEventId; - -typedef struct OrbisKeyboardConfig -{ - SceUserServiceUserId userId; - int status; - int caps_key; - int control_key_left; - int control_key_right; - int shift_key_left; - int shift_key_right; - int alt_key_left; - int alt_key_right; - int cmd_key_left; - int cmd_key_right; - uint8_t key; - uint8_t key_status; - int orbiskeyboard_initialized; - -}OrbisKeyboardConfig; - - -typedef struct -{ - SceUserServiceUserId userId; - uint32_t resourceId[5]; -} OrbisKeyboardResourceIdArray; - -typedef struct -{ - uint16_t keycode; - uint16_t unknown; - uint32_t status;//1.76 - uint32_t unknown1; - SceUserServiceUserId userId; - uint32_t resourceId; - uint32_t unknown2; - uint64_t timestamp; -} OrbisKeyboardKeycode; - -typedef union -{ - int8_t notused[84]; - OrbisKeyboardKeycode keycode; - OrbisKeyboardResourceIdArray resourceIdArray; - void *candidateWord; - int32_t candidateIndex; - int32_t deviceType; - uint32_t inputMethodState; - int8_t reserved[64]; -} OrbisKeyboardEventParam; - -typedef struct OrbisKeyboardEvent { - OrbisKeyboardEventId id; - OrbisKeyboardEventParam param; -} OrbisKeyboardEvent; - -typedef void (*OrbisKeyboardEventHandler)( - void *arg, - const OrbisKeyboardEvent *e -); - -typedef struct OrbisKeyboardParam { - uint32_t option; - int8_t unknown1[4]; - void *arg; - OrbisKeyboardEventHandler handler; - int8_t unknown2[8]; -} OrbisKeyboardParam; - - -int orbisKeyboardInit(); -void orbisKeyboardFinish(); -int orbisKeyboardOpen(); -OrbisKeyboardConfig * orbisKeyboardGetConf(); -int orbisKeyboardSetConf(OrbisKeyboardConfig *conf); -int orbisKeyboardInitWithConf(OrbisKeyboardConfig *conf); -int orbisKeyboardRegisterUpdateHandler(void *arg,OrbisKeyboardEventHandler handler); -void orbisKeybordGetSpecialKeys(const OrbisKeyboardEvent *e); -uint8_t orbisKeyboardGetSpecials(); -int orbisKeyboardGetHandle(); -int orbisKeyboardGetStatus(); -uint8_t orbisKeyboardGetKey(); -int orbisKeyboardGetCapsKey(); -int orbisKeyboardGetControlKeyLeft(); -int orbisKeyboardGetControlKeyRight(); -int orbisKeyboardGetShiftKeyLeft(); -int orbisKeyboardGetShiftKeyRight(); -int orbisKeyboardGetAltKeyLeft(); -int orbisKeyboardGetAltKeyRight(); -int orbisKeyboardGetCmdKeyLeft(); -int orbisKeyboardGetCmdKeyRight(); -uint8_t orbisKeyboardGetMsxKey(); -uint8_t orbisKeyboardGetMsxKeyShift(); -uint8_t orbisKeyboardGetMsxKeyCtrl(); -uint8_t orbisKeyboardGetMsxKeyStatus(); -void orbisKeyboardUpdate(); -int sceImeUpdate(OrbisKeyboardEventHandler handler); -int sceImeKeyboardOpen(SceUserServiceUserId userId,const OrbisKeyboardParam *param); -int sceImeKeyboardClose(SceUserServiceUserId userId); - -#ifdef __cplusplus -} -#endif diff --git a/include/orbisNfs.h b/include/orbisNfs.h deleted file mode 100644 index 5b278fa..0000000 --- a/include/orbisNfs.h +++ /dev/null @@ -1,173 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ -#ifndef _ORBISNFS_H_ -#define _ORBISNFS_H_ - -#include // SEEK_* -#include -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define ORBISNFS_MAX_OPEN_DESCRIPTORS 10 - -#define ROOT_PATH "root" -#define DIR_UP ".." -#define DIR_ACT "." - -#define MAX_PATH_LENGTH 1024 -#define MAX_NAME_LENGTH 256 -#define MAX_SHORT_NAME_LENGTH 64 -#define MAX_MOUNT_POINT_LENGTH 2 - -// Max entries -#define MAX_POSITION 27 -#define MAX_ENTRIES 28 -#define MAX_DIR_LEVELS 1024 - -enum FileTypes { - FILE_TYPE_UNKNOWN, - FILE_TYPE_FOLDER, - FILE_TYPE_ROM, - FILE_TYPE_SYSTEM_ROM, - FILE_TYPE_GAME_ROM, - FILE_TYPE_DSK, - FILE_TYPE_GAME_DSK, - FILE_TYPE_CAS, - FILE_TYPE_CONFIG, -}; - - -enum SortFlags { - SORT_NONE, - SORT_BY_NAME_AND_FOLDER, -}; - - -#define NUM_DEVICES (sizeof(mydevices) / sizeof(char **)) - -typedef struct OrbisNfsBrowserDataTime -{ - unsigned short year; - unsigned short month; - unsigned short day; - unsigned short hour; - unsigned short minute; - unsigned short second; - int microsecond; -}OrbisNfsBrowserDataTime; - -typedef struct OrbisNfsBrowserDirEntry -{ - int namelen; - unsigned char type; /* entry type */ - unsigned char customtype; - int mode; - unsigned int size; /* file size, in bytes */ - OrbisNfsBrowserDataTime atime; /* time of last access */ - OrbisNfsBrowserDataTime mtime; /* time of last data modification */ - OrbisNfsBrowserDataTime ctime; /* time of last file status change */ - char name[MAX_PATH_LENGTH]; -}OrbisNfsBrowserDirEntry; - -typedef struct OrbisNfsBrowserListEntry { - struct OrbisNfsBrowserListEntry *next; - struct OrbisNfsBrowserListEntry *previous; - struct OrbisNfsBrowserDirEntry *dir; -} OrbisNfsBrowserListEntry; - -typedef struct OrbisNfsBrowserList { - OrbisNfsBrowserListEntry *head; - OrbisNfsBrowserListEntry *tail; - int length; - char path[MAX_PATH_LENGTH]; -} OrbisNfsBrowserList; - -typedef struct ExtensionTypes { - char *extension; - int type; -} ExtensionTypes; - -typedef struct OrbisNfsEntry -{ - int fd; - struct nfsfh* fileHandle; - struct nfsdir* dirHandle; - int64_t size; - char path[MAX_NAME_LENGTH]; -}OrbisNfsEntry; - -typedef struct OrbisNfsConfig -{ - struct nfs_context *nfsHandle; - struct nfs_url *urls; - int readChunkSize; - int writeChunkSize; - int openDescriptors[ORBISNFS_MAX_OPEN_DESCRIPTORS]; - OrbisNfsEntry *openEntries[ORBISNFS_MAX_OPEN_DESCRIPTORS]; - OrbisNfsBrowserList *browserList; - int basePos; - int relPos; - int basePosList[MAX_DIR_LEVELS]; - int relPosList[MAX_DIR_LEVELS]; - int dirLevel; - int orbisnfs_initialized; -}OrbisNfsConfig; - - - - - -int orbisNfsOpen(const char *file, int flags, int mode); -int orbisNfsClose(int fd); -int orbisNfsRead(int fd, void *data, size_t size); -int orbisNfsWrite(int fd, const void *data, size_t size); -int orbisNfsLseek(int fd, int offset, int whence); -int orbisNfsDopen(const char *path); -int orbisNfsDclose(int dfd); -int orbisNfsDread(int dfd, OrbisNfsBrowserDirEntry *entry); -int orbisNfsMkdir(const char *path, int mode); -unsigned char * orbisNfsGetFileContent(const char *file); -int orbisNfsInit(const char *nfsurl); -void orbisNfsFinish(); -int orbisNfsInitWithConf(OrbisNfsConfig *conf); -int orbisNfsSetConf(OrbisNfsConfig *conf); -OrbisNfsConfig *orbisNfsGetConf(); -int orbisNfsCreateConf(); -char * orbisNfsGetExportPath(); -int orbisNfsBrowserGetDirLevel(); -int orbisNfsBrowserGetBasePos(); -int orbisNfsBrowserGetRelPos(); -char * orbisNfsBrowserGetListPath(); -int orbisNfsBrowserGetListLength(); -void orbisNfsBrowserSetListPath(char *path); -void orbisNfsBrowserEntryDown(); -void orbisNfsBrowserEntryUp(); -int orbisNfsBrowserGetFileType(char *file); -void orbisNfsBrowserDirLevelUp(char *path); -void orbisNfsBrowserDirLevelDown(); -void orbisNfsBrowserListClean(); -int orbisNfsBrowserListRefresh(); -OrbisNfsBrowserListEntry *orbisNfsBrowserListGetNthEntry(int n); -void orbisNfsBrowserListAddEntry(OrbisNfsBrowserListEntry *entry,int sort); -int orbisNfsBrowserGetDirectoryEntries(char *path); -int orbisNfsBrowserGetDevices(); -int orbisNfsBrowserListGetEntries(char *path); - - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/orbisPad.h b/include/orbisPad.h deleted file mode 100644 index 4709c7f..0000000 --- a/include/orbisPad.h +++ /dev/null @@ -1,73 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#pragma once - -#include -#include - -//#include -//#include -//#include -#include -#ifdef __cplusplus -extern "C" { -#endif - -#define ORBISPAD_L3 0x00000002 -#define ORBISPAD_R3 0x00000004 -#define ORBISPAD_OPTIONS 0x00000008 -#define ORBISPAD_UP 0x00000010 -#define ORBISPAD_RIGHT 0x00000020 -#define ORBISPAD_DOWN 0x00000040 -#define ORBISPAD_LEFT 0x00000080 -#define ORBISPAD_L2 0x00000100 -#define ORBISPAD_R2 0x00000200 -#define ORBISPAD_L1 0x00000400 -#define ORBISPAD_R1 0x00000800 -#define ORBISPAD_TRIANGLE 0x00001000 -#define ORBISPAD_CIRCLE 0x00002000 -#define ORBISPAD_CROSS 0x00004000 -#define ORBISPAD_SQUARE 0x00008000 -#define ORBISPAD_TOUCH_PAD 0x00100000 -#define ORBISPAD_INTERCEPTED 0x80000000 - - -typedef struct OrbisPadConfig -{ - SceUserServiceUserId userId; - ScePadData *padDataCurrent; - ScePadData *padDataLast; - unsigned int buttonsPressed; - unsigned int buttonsReleased; - unsigned int buttonsHold; - int padHandle; - int orbispad_initialized; - -}OrbisPadConfig; - -int orbisPadInit(); -void orbisPadFinish(); -OrbisPadConfig *orbisPadGetConf(); -int orbisPadCreateConf(); -int orbisPadSetConf(OrbisPadConfig *conf); -int orbisPadInitWithConf(OrbisPadConfig *conf); -bool orbisPadGetButtonHold(unsigned int filter); -bool orbisPadGetButtonPressed(unsigned int filter); -bool orbisPadGetButtonReleased(unsigned int filter); -unsigned int orbisPadGetCurrentButtonsPressed(); -unsigned int orbisPadGetCurrentButtonsReleased(); -void orbisPadSetCurrentButtonsPressed(unsigned int buttons); -void orbisPadSetCurrentButtonsReleased(unsigned int buttons); -int orbisPadUpdate(); - -#ifdef __cplusplus -} -#endif diff --git a/include/orbislink.h b/include/orbislink.h deleted file mode 100644 index bea1386..0000000 --- a/include/orbislink.h +++ /dev/null @@ -1,57 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#ifndef _ORBIS_ORBISLINK_H_ -#define _ORBIS_ORBISLINK_H_ - -#include -#include -#include -#include -#include -#include -#include - -typedef struct OrbisGlobalConf -{ - void *conf; //deprecated - OrbisPadConfig *confPad; - OrbisAudioConfig *confAudio; - OrbisKeyboardConfig *confKeyboard; - void *confLink; //deprecated - int orbisLinkFlag; - debugNetConfiguration *confDebug; - OrbisNfsConfig *confNfs; -}OrbisGlobalConf; - -typedef void module_patch_cb_t(void *arg, uint8_t *base, uint64_t size); - - -#ifdef __cplusplus -extern "C" { -#endif - - -int initOrbisLinkApp(void); -int initOrbisLinkAppInternal(void); -int initOrbisLinkAppVanilla(void); -int initOrbisLinkAppVanillaGl(void); -int initOrbisLinkAppVanillaGlMSX(void); -OrbisGlobalConf *orbisLinkGetGlobalConf(void); -void finishOrbisLinkApp(void); - -bool patch_module(const char *name, module_patch_cb_t *cb, void *arg, int level); -int loadModulesVanilla(void); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/pl_ini.h b/include/pl_ini.h deleted file mode 100644 index 8e07284..0000000 --- a/include/pl_ini.h +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright 2007-2015 Akop Karapetyan -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef _PL_INI_H -#define _PL_INI_H - -#ifdef __cplusplus -extern "C" { -#endif - -struct pl_ini_section_t; - -typedef struct pl_ini_file_t -{ - struct pl_ini_section_t *head; -} pl_ini_file; - -int pl_ini_create(pl_ini_file *file); -void pl_ini_destroy(pl_ini_file *file); -int pl_ini_load(pl_ini_file *file, - const char *path); -int pl_ini_load_from_nfs(pl_ini_file *file, - const char *path); -int pl_ini_load_from_data(pl_ini_file *file, - const char *path); -int pl_ini_save(const pl_ini_file *file, - const char *path); -int pl_ini_get_int(const pl_ini_file *file, - const char *section, - const char *key, - const int default_value); -void pl_ini_set_int(pl_ini_file *file, - const char *section, - const char *key, - int value); -int pl_ini_get_string(const pl_ini_file *file, - const char *section, - const char *key, - const char *default_value, - char *copy_to, - int dest_len); -void pl_ini_set_string(pl_ini_file *file, - const char *section, - const char *key, - const char *string); - -#ifdef __cplusplus -} -#endif - -#endif // _PL_INI_H diff --git a/include/png.h b/include/png.h deleted file mode 100644 index 974fa44..0000000 --- a/include/png.h +++ /dev/null @@ -1,2681 +0,0 @@ - -/* png.h - header file for PNG reference library - * - * libpng version 1.5.10 - March 29, 2012 - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license (See LICENSE, below) - * - * Authors and maintainers: - * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat - * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger - * libpng versions 0.97, January 1998, through 1.5.10 - March 29, 2012: Glenn - * See also "Contributing Authors", below. - * - * Note about libpng version numbers: - * - * Due to various miscommunications, unforeseen code incompatibilities - * and occasional factors outside the authors' control, version numbering - * on the library has not always been consistent and straightforward. - * The following table summarizes matters since version 0.89c, which was - * the first widely used release: - * - * source png.h png.h shared-lib - * version string int version - * ------- ------ ----- ---------- - * 0.89c "1.0 beta 3" 0.89 89 1.0.89 - * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] - * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] - * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] - * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] - * 0.97c 0.97 97 2.0.97 - * 0.98 0.98 98 2.0.98 - * 0.99 0.99 98 2.0.99 - * 0.99a-m 0.99 99 2.0.99 - * 1.00 1.00 100 2.1.0 [100 should be 10000] - * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] - * 1.0.1 png.h string is 10001 2.1.0 - * 1.0.1a-e identical to the 10002 from here on, the shared library - * 1.0.2 source version) 10002 is 2.V where V is the source code - * 1.0.2a-b 10003 version, except as noted. - * 1.0.3 10003 - * 1.0.3a-d 10004 - * 1.0.4 10004 - * 1.0.4a-f 10005 - * 1.0.5 (+ 2 patches) 10005 - * 1.0.5a-d 10006 - * 1.0.5e-r 10100 (not source compatible) - * 1.0.5s-v 10006 (not binary compatible) - * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) - * 1.0.6d-f 10007 (still binary incompatible) - * 1.0.6g 10007 - * 1.0.6h 10007 10.6h (testing xy.z so-numbering) - * 1.0.6i 10007 10.6i - * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) - * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) - * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) - * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) - * 1.0.7 1 10007 (still compatible) - * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 - * 1.0.8rc1 1 10008 2.1.0.8rc1 - * 1.0.8 1 10008 2.1.0.8 - * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 - * 1.0.9rc1 1 10009 2.1.0.9rc1 - * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 - * 1.0.9rc2 1 10009 2.1.0.9rc2 - * 1.0.9 1 10009 2.1.0.9 - * 1.0.10beta1 1 10010 2.1.0.10beta1 - * 1.0.10rc1 1 10010 2.1.0.10rc1 - * 1.0.10 1 10010 2.1.0.10 - * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 - * 1.0.11rc1 1 10011 2.1.0.11rc1 - * 1.0.11 1 10011 2.1.0.11 - * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 - * 1.0.12rc1 2 10012 2.1.0.12rc1 - * 1.0.12 2 10012 2.1.0.12 - * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) - * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 - * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 - * 1.2.0rc1 3 10200 3.1.2.0rc1 - * 1.2.0 3 10200 3.1.2.0 - * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 - * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 - * 1.2.1 3 10201 3.1.2.1 - * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 - * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 - * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 - * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 - * 1.0.13 10 10013 10.so.0.1.0.13 - * 1.2.2 12 10202 12.so.0.1.2.2 - * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 - * 1.2.3 12 10203 12.so.0.1.2.3 - * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 - * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 - * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 - * 1.0.14 10 10014 10.so.0.1.0.14 - * 1.2.4 13 10204 12.so.0.1.2.4 - * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 - * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 - * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 - * 1.0.15 10 10015 10.so.0.1.0.15 - * 1.2.5 13 10205 12.so.0.1.2.5 - * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 - * 1.0.16 10 10016 10.so.0.1.0.16 - * 1.2.6 13 10206 12.so.0.1.2.6 - * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 - * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 - * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 - * 1.0.17 10 10017 12.so.0.1.0.17 - * 1.2.7 13 10207 12.so.0.1.2.7 - * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 - * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 - * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 - * 1.0.18 10 10018 12.so.0.1.0.18 - * 1.2.8 13 10208 12.so.0.1.2.8 - * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 - * 1.2.9beta4-11 13 10209 12.so.0.9[.0] - * 1.2.9rc1 13 10209 12.so.0.9[.0] - * 1.2.9 13 10209 12.so.0.9[.0] - * 1.2.10beta1-7 13 10210 12.so.0.10[.0] - * 1.2.10rc1-2 13 10210 12.so.0.10[.0] - * 1.2.10 13 10210 12.so.0.10[.0] - * 1.4.0beta1-5 14 10400 14.so.0.0[.0] - * 1.2.11beta1-4 13 10211 12.so.0.11[.0] - * 1.4.0beta7-8 14 10400 14.so.0.0[.0] - * 1.2.11 13 10211 12.so.0.11[.0] - * 1.2.12 13 10212 12.so.0.12[.0] - * 1.4.0beta9-14 14 10400 14.so.0.0[.0] - * 1.2.13 13 10213 12.so.0.13[.0] - * 1.4.0beta15-36 14 10400 14.so.0.0[.0] - * 1.4.0beta37-87 14 10400 14.so.14.0[.0] - * 1.4.0rc01 14 10400 14.so.14.0[.0] - * 1.4.0beta88-109 14 10400 14.so.14.0[.0] - * 1.4.0rc02-08 14 10400 14.so.14.0[.0] - * 1.4.0 14 10400 14.so.14.0[.0] - * 1.4.1beta01-03 14 10401 14.so.14.1[.0] - * 1.4.1rc01 14 10401 14.so.14.1[.0] - * 1.4.1beta04-12 14 10401 14.so.14.1[.0] - * 1.4.1 14 10401 14.so.14.1[.0] - * 1.4.2 14 10402 14.so.14.2[.0] - * 1.4.3 14 10403 14.so.14.3[.0] - * 1.4.4 14 10404 14.so.14.4[.0] - * 1.5.0beta01-58 15 10500 15.so.15.0[.0] - * 1.5.0rc01-07 15 10500 15.so.15.0[.0] - * 1.5.0 15 10500 15.so.15.0[.0] - * 1.5.1beta01-11 15 10501 15.so.15.1[.0] - * 1.5.1rc01-02 15 10501 15.so.15.1[.0] - * 1.5.1 15 10501 15.so.15.1[.0] - * 1.5.2beta01-03 15 10502 15.so.15.2[.0] - * 1.5.2rc01-03 15 10502 15.so.15.2[.0] - * 1.5.2 15 10502 15.so.15.2[.0] - * 1.5.3beta01-10 15 10503 15.so.15.3[.0] - * 1.5.3rc01-02 15 10503 15.so.15.3[.0] - * 1.5.3beta11 15 10503 15.so.15.3[.0] - * 1.5.3 [omitted] - * 1.5.4beta01-08 15 10504 15.so.15.4[.0] - * 1.5.4rc01 15 10504 15.so.15.4[.0] - * 1.5.4 15 10504 15.so.15.4[.0] - * 1.5.5beta01-08 15 10505 15.so.15.5[.0] - * 1.5.5rc01 15 10505 15.so.15.5[.0] - * 1.5.5 15 10505 15.so.15.5[.0] - * 1.5.6beta01-07 15 10506 15.so.15.6[.0] - * 1.5.6rc01-03 15 10506 15.so.15.6[.0] - * 1.5.6 15 10506 15.so.15.6[.0] - * 1.5.7beta01-05 15 10507 15.so.15.7[.0] - * 1.5.7rc01-03 15 10507 15.so.15.7[.0] - * 1.5.7 15 10507 15.so.15.7[.0] - * 1.5.8beta01 15 10508 15.so.15.8[.0] - * 1.5.8rc01 15 10508 15.so.15.8[.0] - * 1.5.8 15 10508 15.so.15.8[.0] - * 1.5.9beta01-02 15 10509 15.so.15.9[.0] - * 1.5.9rc01 15 10509 15.so.15.9[.0] - * 1.5.9 15 10509 15.so.15.9[.0] - * 1.5.10beta01-05 15 10510 15.so.15.10[.0] - * 1.5.10 15 10510 15.so.15.10[.0] - * - * Henceforth the source version will match the shared-library major - * and minor numbers; the shared-library major version number will be - * used for changes in backward compatibility, as it is intended. The - * PNG_LIBPNG_VER macro, which is not used within libpng but is available - * for applications, is an unsigned integer of the form xyyzz corresponding - * to the source version x.y.z (leading zeros in y and z). Beta versions - * were given the previous public release number plus a letter, until - * version 1.0.6j; from then on they were given the upcoming public - * release number plus "betaNN" or "rcNN". - * - * Binary incompatibility exists only when applications make direct access - * to the info_ptr or png_ptr members through png.h, and the compiled - * application is loaded with a different version of the library. - * - * DLLNUM will change each time there are forward or backward changes - * in binary compatibility (e.g., when a new feature is added). - * - * See libpng-manual.txt or libpng.3 for more information. The PNG - * specification is available as a W3C Recommendation and as an ISO - * Specification, -# endif - - /* Need the time information for converting tIME chunks, it - * defines struct tm: - */ -# ifdef PNG_CONVERT_tIME_SUPPORTED - /* "time.h" functions are not supported on all operating systems */ -# include -# endif -# endif - -/* Machine specific configuration. */ -# include "pngconf.h" -#endif - -/* - * Added at libpng-1.2.8 - * - * Ref MSDN: Private as priority over Special - * VS_FF_PRIVATEBUILD File *was not* built using standard release - * procedures. If this value is given, the StringFileInfo block must - * contain a PrivateBuild string. - * - * VS_FF_SPECIALBUILD File *was* built by the original company using - * standard release procedures but is a variation of the standard - * file of the same version number. If this value is given, the - * StringFileInfo block must contain a SpecialBuild string. - */ - -#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */ -# define PNG_LIBPNG_BUILD_TYPE \ - (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) -#else -# ifdef PNG_LIBPNG_SPECIALBUILD -# define PNG_LIBPNG_BUILD_TYPE \ - (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) -# else -# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) -# endif -#endif - -#ifndef PNG_VERSION_INFO_ONLY - -/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* Version information for C files, stored in png.c. This had better match - * the version above. - */ -#define png_libpng_ver png_get_header_ver(NULL) - -/* This file is arranged in several sections: - * - * 1. Any configuration options that can be specified by for the application - * code when it is built. (Build time configuration is in pnglibconf.h) - * 2. Type definitions (base types are defined in pngconf.h), structure - * definitions. - * 3. Exported library functions. - * - * The library source code has additional files (principally pngpriv.h) that - * allow configuration of the library. - */ -/* Section 1: run time configuration - * See pnglibconf.h for build time configuration - * - * Run time configuration allows the application to choose between - * implementations of certain arithmetic APIs. The default is set - * at build time and recorded in pnglibconf.h, but it is safe to - * override these (and only these) settings. Note that this won't - * change what the library does, only application code, and the - * settings can (and probably should) be made on a per-file basis - * by setting the #defines before including png.h - * - * Use macros to read integers from PNG data or use the exported - * functions? - * PNG_USE_READ_MACROS: use the macros (see below) Note that - * the macros evaluate their argument multiple times. - * PNG_NO_USE_READ_MACROS: call the relevant library function. - * - * Use the alternative algorithm for compositing alpha samples that - * does not use division? - * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division' - * algorithm. - * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm. - * - * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is - * false? - * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error - * APIs to png_warning. - * Otherwise the calls are mapped to png_error. - */ - -/* Section 2: type definitions, including structures and compile time - * constants. - * See pngconf.h for base types that vary by machine/system - */ - -/* This triggers a compiler error in png.c, if png.c and png.h - * do not agree upon the version number. - */ -typedef char* png_libpng_version_1_5_10; - -/* Three color definitions. The order of the red, green, and blue, (and the - * exact size) is not important, although the size of the fields need to - * be png_byte or png_uint_16 (as defined below). - */ -typedef struct png_color_struct -{ - png_byte red; - png_byte green; - png_byte blue; -} png_color; -typedef png_color FAR * png_colorp; -typedef PNG_CONST png_color FAR * png_const_colorp; -typedef png_color FAR * FAR * png_colorpp; - -typedef struct png_color_16_struct -{ - png_byte index; /* used for palette files */ - png_uint_16 red; /* for use in red green blue files */ - png_uint_16 green; - png_uint_16 blue; - png_uint_16 gray; /* for use in grayscale files */ -} png_color_16; -typedef png_color_16 FAR * png_color_16p; -typedef PNG_CONST png_color_16 FAR * png_const_color_16p; -typedef png_color_16 FAR * FAR * png_color_16pp; - -typedef struct png_color_8_struct -{ - png_byte red; /* for use in red green blue files */ - png_byte green; - png_byte blue; - png_byte gray; /* for use in grayscale files */ - png_byte alpha; /* for alpha channel files */ -} png_color_8; -typedef png_color_8 FAR * png_color_8p; -typedef PNG_CONST png_color_8 FAR * png_const_color_8p; -typedef png_color_8 FAR * FAR * png_color_8pp; - -/* - * The following two structures are used for the in-core representation - * of sPLT chunks. - */ -typedef struct png_sPLT_entry_struct -{ - png_uint_16 red; - png_uint_16 green; - png_uint_16 blue; - png_uint_16 alpha; - png_uint_16 frequency; -} png_sPLT_entry; -typedef png_sPLT_entry FAR * png_sPLT_entryp; -typedef PNG_CONST png_sPLT_entry FAR * png_const_sPLT_entryp; -typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; - -/* When the depth of the sPLT palette is 8 bits, the color and alpha samples - * occupy the LSB of their respective members, and the MSB of each member - * is zero-filled. The frequency member always occupies the full 16 bits. - */ - -typedef struct png_sPLT_struct -{ - png_charp name; /* palette name */ - png_byte depth; /* depth of palette samples */ - png_sPLT_entryp entries; /* palette entries */ - png_int_32 nentries; /* number of palette entries */ -} png_sPLT_t; -typedef png_sPLT_t FAR * png_sPLT_tp; -typedef PNG_CONST png_sPLT_t FAR * png_const_sPLT_tp; -typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; - -#ifdef PNG_TEXT_SUPPORTED -/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, - * and whether that contents is compressed or not. The "key" field - * points to a regular zero-terminated C string. The "text" fields can be a - * regular C string, an empty string, or a NULL pointer. - * However, the structure returned by png_get_text() will always contain - * the "text" field as a regular zero-terminated C string (possibly - * empty), never a NULL pointer, so it can be safely used in printf() and - * other string-handling functions. Note that the "itxt_length", "lang", and - * "lang_key" members of the structure only exist when the library is built - * with iTXt chunk support. Prior to libpng-1.4.0 the library was built by - * default without iTXt support. Also note that when iTXt *is* supported, - * the "lang" and "lang_key" fields contain NULL pointers when the - * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or - * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the - * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag" - * which is always 0 or 1, or its "compression method" which is always 0. - */ -typedef struct png_text_struct -{ - int compression; /* compression value: - -1: tEXt, none - 0: zTXt, deflate - 1: iTXt, none - 2: iTXt, deflate */ - png_charp key; /* keyword, 1-79 character description of "text" */ - png_charp text; /* comment, may be an empty string (ie "") - or a NULL pointer */ - png_size_t text_length; /* length of the text string */ - png_size_t itxt_length; /* length of the itxt string */ - png_charp lang; /* language code, 0-79 characters - or a NULL pointer */ - png_charp lang_key; /* keyword translated UTF-8 string, 0 or more - chars or a NULL pointer */ -} png_text; -typedef png_text FAR * png_textp; -typedef PNG_CONST png_text FAR * png_const_textp; -typedef png_text FAR * FAR * png_textpp; -#endif - -/* Supported compression types for text in PNG files (tEXt, and zTXt). - * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ -#define PNG_TEXT_COMPRESSION_NONE_WR -3 -#define PNG_TEXT_COMPRESSION_zTXt_WR -2 -#define PNG_TEXT_COMPRESSION_NONE -1 -#define PNG_TEXT_COMPRESSION_zTXt 0 -#define PNG_ITXT_COMPRESSION_NONE 1 -#define PNG_ITXT_COMPRESSION_zTXt 2 -#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ - -/* png_time is a way to hold the time in an machine independent way. - * Two conversions are provided, both from time_t and struct tm. There - * is no portable way to convert to either of these structures, as far - * as I know. If you know of a portable way, send it to me. As a side - * note - PNG has always been Year 2000 compliant! - */ -typedef struct png_time_struct -{ - png_uint_16 year; /* full year, as in, 1995 */ - png_byte month; /* month of year, 1 - 12 */ - png_byte day; /* day of month, 1 - 31 */ - png_byte hour; /* hour of day, 0 - 23 */ - png_byte minute; /* minute of hour, 0 - 59 */ - png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ -} png_time; -typedef png_time FAR * png_timep; -typedef PNG_CONST png_time FAR * png_const_timep; -typedef png_time FAR * FAR * png_timepp; - -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ - defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) -/* png_unknown_chunk is a structure to hold queued chunks for which there is - * no specific support. The idea is that we can use this to queue - * up private chunks for output even though the library doesn't actually - * know about their semantics. - */ -typedef struct png_unknown_chunk_t -{ - png_byte name[5]; - png_byte *data; - png_size_t size; - - /* libpng-using applications should NOT directly modify this byte. */ - png_byte location; /* mode of operation at read time */ -} - - -png_unknown_chunk; -typedef png_unknown_chunk FAR * png_unknown_chunkp; -typedef PNG_CONST png_unknown_chunk FAR * png_const_unknown_chunkp; -typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; -#endif - -/* Values for the unknown chunk location byte */ - -#define PNG_HAVE_IHDR 0x01 -#define PNG_HAVE_PLTE 0x02 -#define PNG_AFTER_IDAT 0x08 - -/* The complete definition of png_info has, as of libpng-1.5.0, - * been moved into a separate header file that is not accessible to - * applications. Read libpng-manual.txt or libpng.3 for more info. - */ -typedef struct png_info_def png_info; -typedef png_info FAR * png_infop; -typedef PNG_CONST png_info FAR * png_const_infop; -typedef png_info FAR * FAR * png_infopp; - -/* Maximum positive integer used in PNG is (2^31)-1 */ -#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) -#define PNG_UINT_32_MAX ((png_uint_32)(-1)) -#define PNG_SIZE_MAX ((png_size_t)(-1)) - -/* These are constants for fixed point values encoded in the - * PNG specification manner (x100000) - */ -#define PNG_FP_1 100000 -#define PNG_FP_HALF 50000 -#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL) -#define PNG_FP_MIN (-PNG_FP_MAX) - -/* These describe the color_type field in png_info. */ -/* color type masks */ -#define PNG_COLOR_MASK_PALETTE 1 -#define PNG_COLOR_MASK_COLOR 2 -#define PNG_COLOR_MASK_ALPHA 4 - -/* color types. Note that not all combinations are legal */ -#define PNG_COLOR_TYPE_GRAY 0 -#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) -#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) -#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) -#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) -/* aliases */ -#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA -#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA - -/* This is for compression type. PNG 1.0-1.2 only define the single type. */ -#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ -#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE - -/* This is for filter type. PNG 1.0-1.2 only define the single type. */ -#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ -#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ -#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE - -/* These are for the interlacing type. These values should NOT be changed. */ -#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ -#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ -#define PNG_INTERLACE_LAST 2 /* Not a valid value */ - -/* These are for the oFFs chunk. These values should NOT be changed. */ -#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ -#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ -#define PNG_OFFSET_LAST 2 /* Not a valid value */ - -/* These are for the pCAL chunk. These values should NOT be changed. */ -#define PNG_EQUATION_LINEAR 0 /* Linear transformation */ -#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ -#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ -#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ -#define PNG_EQUATION_LAST 4 /* Not a valid value */ - -/* These are for the sCAL chunk. These values should NOT be changed. */ -#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ -#define PNG_SCALE_METER 1 /* meters per pixel */ -#define PNG_SCALE_RADIAN 2 /* radians per pixel */ -#define PNG_SCALE_LAST 3 /* Not a valid value */ - -/* These are for the pHYs chunk. These values should NOT be changed. */ -#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ -#define PNG_RESOLUTION_METER 1 /* pixels/meter */ -#define PNG_RESOLUTION_LAST 2 /* Not a valid value */ - -/* These are for the sRGB chunk. These values should NOT be changed. */ -#define PNG_sRGB_INTENT_PERCEPTUAL 0 -#define PNG_sRGB_INTENT_RELATIVE 1 -#define PNG_sRGB_INTENT_SATURATION 2 -#define PNG_sRGB_INTENT_ABSOLUTE 3 -#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ - -/* This is for text chunks */ -#define PNG_KEYWORD_MAX_LENGTH 79 - -/* Maximum number of entries in PLTE/sPLT/tRNS arrays */ -#define PNG_MAX_PALETTE_LENGTH 256 - -/* These determine if an ancillary chunk's data has been successfully read - * from the PNG header, or if the application has filled in the corresponding - * data in the info_struct to be written into the output file. The values - * of the PNG_INFO_ defines should NOT be changed. - */ -#define PNG_INFO_gAMA 0x0001 -#define PNG_INFO_sBIT 0x0002 -#define PNG_INFO_cHRM 0x0004 -#define PNG_INFO_PLTE 0x0008 -#define PNG_INFO_tRNS 0x0010 -#define PNG_INFO_bKGD 0x0020 -#define PNG_INFO_hIST 0x0040 -#define PNG_INFO_pHYs 0x0080 -#define PNG_INFO_oFFs 0x0100 -#define PNG_INFO_tIME 0x0200 -#define PNG_INFO_pCAL 0x0400 -#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ -#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ -#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ -#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ -#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */ - -/* This is used for the transformation routines, as some of them - * change these values for the row. It also should enable using - * the routines for other purposes. - */ -typedef struct png_row_info_struct -{ - png_uint_32 width; /* width of row */ - png_size_t rowbytes; /* number of bytes in row */ - png_byte color_type; /* color type of row */ - png_byte bit_depth; /* bit depth of row */ - png_byte channels; /* number of channels (1, 2, 3, or 4) */ - png_byte pixel_depth; /* bits per pixel (depth * channels) */ -} png_row_info; - -typedef png_row_info FAR * png_row_infop; -typedef png_row_info FAR * FAR * png_row_infopp; - -/* The complete definition of png_struct has, as of libpng-1.5.0, - * been moved into a separate header file that is not accessible to - * applications. Read libpng-manual.txt or libpng.3 for more info. - */ -typedef struct png_struct_def png_struct; -typedef PNG_CONST png_struct FAR * png_const_structp; -typedef png_struct FAR * png_structp; - -/* These are the function types for the I/O functions and for the functions - * that allow the user to override the default I/O functions with his or her - * own. The png_error_ptr type should match that of user-supplied warning - * and error functions, while the png_rw_ptr type should match that of the - * user read/write data functions. Note that the 'write' function must not - * modify the buffer it is passed. The 'read' function, on the other hand, is - * expected to return the read data in the buffer. - */ -typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); -typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); -typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); -typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, - int)); -typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, - int)); - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); -typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); - -/* The following callback receives png_uint_32 row_number, int pass for the - * png_bytep data of the row. When transforming an interlaced image the - * row number is the row number within the sub-image of the interlace pass, so - * the value will increase to the height of the sub-image (not the full image) - * then reset to 0 for the next pass. - * - * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to - * find the output pixel (x,y) given an interlaced sub-image pixel - * (row,col,pass). (See below for these macros.) - */ -typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, - png_uint_32, int)); -#endif - -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, - png_bytep)); -#endif - -#ifdef PNG_USER_CHUNKS_SUPPORTED -typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, - png_unknown_chunkp)); -#endif -#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED -typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); -#endif - -#ifdef PNG_SETJMP_SUPPORTED -/* This must match the function definition in , and the application - * must include this before png.h to obtain the definition of jmp_buf. The - * function is required to be PNG_NORETURN, but this is not checked. If the - * function does return the application will crash via an abort() or similar - * system level call. - * - * If you get a warning here while building the library you may need to make - * changes to ensure that pnglibconf.h records the calling convention used by - * your compiler. This may be very difficult - try using a different compiler - * to build the library! - */ -PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); -#endif - -/* Transform masks for the high-level interface */ -#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ -#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ -#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ -#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ -#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ -#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ -#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ -#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ -#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ -#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ -#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ -#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ -#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ -/* Added to libpng-1.2.34 */ -#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER -#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ -/* Added to libpng-1.4.0 */ -#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ -/* Added to libpng-1.5.4 */ -#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ -#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ - -/* Flags for MNG supported features */ -#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 -#define PNG_FLAG_MNG_FILTER_64 0x04 -#define PNG_ALL_MNG_FEATURES 0x05 - -/* NOTE: prior to 1.5 these functions had no 'API' style declaration, - * this allowed the zlib default functions to be used on Windows - * platforms. In 1.5 the zlib default malloc (which just calls malloc and - * ignores the first argument) should be completely compatible with the - * following. - */ -typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, - png_alloc_size_t)); -typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); - -typedef png_struct FAR * FAR * png_structpp; - - -/* ***************************************************************** */ -/* Added by Paul Pedriana so that we can override default allocation */ -typedef png_voidp (*png_default_malloc_ptr)(png_size_t); -typedef void (*png_default_free_ptr)(png_voidp); - -void png_set_default_mem_fn(png_default_malloc_ptr malloc_fn, png_default_free_ptr free_fn); -/* End of additions by Paul Pedriana */ -/* ***************************************************************** */ - - -/* Section 3: exported functions - * Here are the function definitions most commonly used. This is not - * the place to find out how to use libpng. See libpng-manual.txt for the - * full explanation, see example.c for the summary. This just provides - * a simple one line description of the use of each function. - * - * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in - * pngconf.h and in the *.dfn files in the scripts directory. - * - * PNG_EXPORT(ordinal, type, name, (args)); - * - * ordinal: ordinal that is used while building - * *.def files. The ordinal value is only - * relevant when preprocessing png.h with - * the *.dfn files for building symbol table - * entries, and are removed by pngconf.h. - * type: return type of the function - * name: function name - * args: function arguments, with types - * - * When we wish to append attributes to a function prototype we use - * the PNG_EXPORTA() macro instead. - * - * PNG_EXPORTA(ordinal, type, name, (args), attributes); - * - * ordinal, type, name, and args: same as in PNG_EXPORT(). - * attributes: function attributes - */ - -/* Returns the version number of the library */ -PNG_EXPORT(1, png_uint_32, png_access_version_number, (void)); - -/* Tell lib we have already handled the first magic bytes. - * Handling more than 8 bytes from the beginning of the file is an error. - */ -PNG_EXPORT(2, void, png_set_sig_bytes, (png_structp png_ptr, int num_bytes)); - -/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a - * PNG file. Returns zero if the supplied bytes match the 8-byte PNG - * signature, and non-zero otherwise. Having num_to_check == 0 or - * start > 7 will always fail (ie return non-zero). - */ -PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start, - png_size_t num_to_check)); - -/* Simple signature checking function. This is the same as calling - * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). - */ -#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) - -/* Allocate and initialize png_ptr struct for reading, and any other memory. */ -PNG_EXPORTA(4, png_structp, png_create_read_struct, - (png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn), - PNG_ALLOCATED); - -/* Allocate and initialize png_ptr struct for writing, and any other memory */ -PNG_EXPORTA(5, png_structp, png_create_write_struct, - (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, - png_error_ptr warn_fn), - PNG_ALLOCATED); - -PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, - (png_const_structp png_ptr)); - -PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr, - png_size_t size)); - -/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp - * match up. - */ -#ifdef PNG_SETJMP_SUPPORTED -/* This function returns the jmp_buf built in to *png_ptr. It must be - * supplied with an appropriate 'longjmp' function to use on that jmp_buf - * unless the default error function is overridden in which case NULL is - * acceptable. The size of the jmp_buf is checked against the actual size - * allocated by the library - the call will return NULL on a mismatch - * indicating an ABI mismatch. - */ -PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr, - png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); -# define png_jmpbuf(png_ptr) \ - (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf))) -#else -# define png_jmpbuf(png_ptr) \ - (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) -#endif -/* This function should be used by libpng applications in place of - * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it - * will use it; otherwise it will call PNG_ABORT(). This function was - * added in libpng-1.5.0. - */ -PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val), - PNG_NORETURN); - -#ifdef PNG_READ_SUPPORTED -/* Reset the compression stream */ -PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr)); -#endif - -/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ -#ifdef PNG_USER_MEM_SUPPORTED -PNG_EXPORTA(11, png_structp, png_create_read_struct_2, - (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, - png_error_ptr warn_fn, - png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), - PNG_ALLOCATED); -PNG_EXPORTA(12, png_structp, png_create_write_struct_2, - (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, - png_error_ptr warn_fn, - png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), - PNG_ALLOCATED); -#endif - -/* Write the PNG file signature. */ -PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr)); - -/* Write a PNG chunk - size, type, (optional) data, CRC. */ -PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep - chunk_name, png_const_bytep data, png_size_t length)); - -/* Write the start of a PNG chunk - length and chunk name. */ -PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr, - png_const_bytep chunk_name, png_uint_32 length)); - -/* Write the data of a PNG chunk started with png_write_chunk_start(). */ -PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr, - png_const_bytep data, png_size_t length)); - -/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ -PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr)); - -/* Allocate and initialize the info structure */ -PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr), - PNG_ALLOCATED); - -PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr, - png_size_t png_info_struct_size)); - -/* Writes all the PNG information before the image. */ -PNG_EXPORT(20, void, png_write_info_before_PLTE, - (png_structp png_ptr, png_infop info_ptr)); -PNG_EXPORT(21, void, png_write_info, - (png_structp png_ptr, png_infop info_ptr)); - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read the information before the actual image data. */ -PNG_EXPORT(22, void, png_read_info, - (png_structp png_ptr, png_infop info_ptr)); -#endif - -#ifdef PNG_TIME_RFC1123_SUPPORTED -PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123, - (png_structp png_ptr, - png_const_timep ptime)); -#endif - -#ifdef PNG_CONVERT_tIME_SUPPORTED -/* Convert from a struct tm to png_time */ -PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, - PNG_CONST struct tm FAR * ttime)); - -/* Convert from time_t to png_time. Uses gmtime() */ -PNG_EXPORT(25, void, png_convert_from_time_t, - (png_timep ptime, time_t ttime)); -#endif /* PNG_CONVERT_tIME_SUPPORTED */ - -#ifdef PNG_READ_EXPAND_SUPPORTED -/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ -PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr)); -PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr)); -PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr)); -PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr)); -#endif - -#ifdef PNG_READ_EXPAND_16_SUPPORTED -/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion - * of a tRNS chunk if present. - */ -PNG_EXPORT(221, void, png_set_expand_16, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) -/* Use blue, green, red order for pixels. */ -PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr)); -#endif - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED -/* Expand the grayscale to 24-bit RGB if necessary. */ -PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr)); -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED -/* Reduce RGB to grayscale. */ -#define PNG_ERROR_ACTION_NONE 1 -#define PNG_ERROR_ACTION_WARN 2 -#define PNG_ERROR_ACTION_ERROR 3 -#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/ - -PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr, - int error_action, double red, double green)); -PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr, - int error_action, png_fixed_point red, png_fixed_point green)); - -PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp - png_ptr)); -#endif - -#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED -PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, - png_colorp palette)); -#endif - -#ifdef PNG_READ_ALPHA_MODE_SUPPORTED -/* How the alpha channel is interpreted - this affects how the color channels of - * a PNG file are returned when an alpha channel, or tRNS chunk in a palette - * file, is present. - * - * This has no effect on the way pixels are written into a PNG output - * datastream. The color samples in a PNG datastream are never premultiplied - * with the alpha samples. - * - * The default is to return data according to the PNG specification: the alpha - * channel is a linear measure of the contribution of the pixel to the - * corresponding composited pixel. The gamma encoded color channels must be - * scaled according to the contribution and to do this it is necessary to undo - * the encoding, scale the color values, perform the composition and reencode - * the values. This is the 'PNG' mode. - * - * The alternative is to 'associate' the alpha with the color information by - * storing color channel values that have been scaled by the alpha. The - * advantage is that the color channels can be resampled (the image can be - * scaled) in this form. The disadvantage is that normal practice is to store - * linear, not (gamma) encoded, values and this requires 16-bit channels for - * still images rather than the 8-bit channels that are just about sufficient if - * gamma encoding is used. In addition all non-transparent pixel values, - * including completely opaque ones, must be gamma encoded to produce the final - * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the - * latter being the two common names for associated alpha color channels.) - * - * Since it is not necessary to perform arithmetic on opaque color values so - * long as they are not to be resampled and are in the final color space it is - * possible to optimize the handling of alpha by storing the opaque pixels in - * the PNG format (adjusted for the output color space) while storing partially - * opaque pixels in the standard, linear, format. The accuracy required for - * standard alpha composition is relatively low, because the pixels are - * isolated, therefore typically the accuracy loss in storing 8-bit linear - * values is acceptable. (This is not true if the alpha channel is used to - * simulate transparency over large areas - use 16 bits or the PNG mode in - * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is - * treated as opaque only if the alpha value is equal to the maximum value. - * - * The final choice is to gamma encode the alpha channel as well. This is - * broken because, in practice, no implementation that uses this choice - * correctly undoes the encoding before handling alpha composition. Use this - * choice only if other serious errors in the software or hardware you use - * mandate it; the typical serious error is for dark halos to appear around - * opaque areas of the composited PNG image because of arithmetic overflow. - * - * The API function png_set_alpha_mode specifies which of these choices to use - * with an enumerated 'mode' value and the gamma of the required output: - */ -#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ -#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ -#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ -#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ -#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ -#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ - -PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structp png_ptr, int mode, - double output_gamma)); -PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structp png_ptr, - int mode, png_fixed_point output_gamma)); -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) -/* The output_gamma value is a screen gamma in libpng terminology: it expresses - * how to decode the output values, not how they are encoded. The values used - * correspond to the normal numbers used to describe the overall gamma of a - * computer display system; for example 2.2 for an sRGB conformant system. The - * values are scaled by 100000 in the _fixed version of the API (so 220000 for - * sRGB.) - * - * The inverse of the value is always used to provide a default for the PNG file - * encoding if it has no gAMA chunk and if png_set_gamma() has not been called - * to override the PNG gamma information. - * - * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode - * opaque pixels however pixels with lower alpha values are not encoded, - * regardless of the output gamma setting. - * - * When the standard Porter Duff handling is requested with mode 1 the output - * encoding is set to be linear and the output_gamma value is only relevant - * as a default for input data that has no gamma information. The linear output - * encoding will be overridden if png_set_gamma() is called - the results may be - * highly unexpected! - * - * The following numbers are derived from the sRGB standard and the research - * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of - * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing - * correction required to take account of any differences in the color - * environment of the original scene and the intended display environment; the - * value expresses how to *decode* the image for display, not how the original - * data was *encoded*. - * - * sRGB provides a peg for the PNG standard by defining a viewing environment. - * sRGB itself, and earlier TV standards, actually use a more complex transform - * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is - * limited to simple power laws.) By saying that an image for direct display on - * an sRGB conformant system should be stored with a gAMA chunk value of 45455 - * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification - * makes it possible to derive values for other display systems and - * environments. - * - * The Mac value is deduced from the sRGB based on an assumption that the actual - * extra viewing correction used in early Mac display systems was implemented as - * a power 1.45 lookup table. - * - * Any system where a programmable lookup table is used or where the behavior of - * the final display device characteristics can be changed requires system - * specific code to obtain the current characteristic. However this can be - * difficult and most PNG gamma correction only requires an approximate value. - * - * By default, if png_set_alpha_mode() is not called, libpng assumes that all - * values are unencoded, linear, values and that the output device also has a - * linear characteristic. This is only very rarely correct - it is invariably - * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the - * default if you don't know what the right answer is! - * - * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS - * 10.6) which used a correction table to implement a somewhat lower gamma on an - * otherwise sRGB system. - * - * Both these values are reserved (not simple gamma values) in order to allow - * more precise correction internally in the future. - * - * NOTE: the following values can be passed to either the fixed or floating - * point APIs, but the floating point API will also accept floating point - * values. - */ -#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ -#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ -#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ -#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ -#endif - -/* The following are examples of calls to png_set_alpha_mode to achieve the - * required overall gamma correction and, where necessary, alpha - * premultiplication. - * - * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); - * This is the default libpng handling of the alpha channel - it is not - * pre-multiplied into the color components. In addition the call states - * that the output is for a sRGB system and causes all PNG files without gAMA - * chunks to be assumed to be encoded using sRGB. - * - * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); - * In this case the output is assumed to be something like an sRGB conformant - * display preceeded by a power-law lookup table of power 1.45. This is how - * early Mac systems behaved. - * - * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); - * This is the classic Jim Blinn approach and will work in academic - * environments where everything is done by the book. It has the shortcoming - * of assuming that input PNG data with no gamma information is linear - this - * is unlikely to be correct unless the PNG files where generated locally. - * Most of the time the output precision will be so low as to show - * significant banding in dark areas of the image. - * - * png_set_expand_16(pp); - * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); - * This is a somewhat more realistic Jim Blinn inspired approach. PNG files - * are assumed to have the sRGB encoding if not marked with a gamma value and - * the output is always 16 bits per component. This permits accurate scaling - * and processing of the data. If you know that your input PNG files were - * generated locally you might need to replace PNG_DEFAULT_sRGB with the - * correct value for your system. - * - * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); - * If you just need to composite the PNG image onto an existing background - * and if you control the code that does this you can use the optimization - * setting. In this case you just copy completely opaque pixels to the - * output. For pixels that are not completely transparent (you just skip - * those) you do the composition math using png_composite or png_composite_16 - * below then encode the resultant 8-bit or 16-bit values to match the output - * encoding. - * - * Other cases - * If neither the PNG nor the standard linear encoding work for you because - * of the software or hardware you use then you have a big problem. The PNG - * case will probably result in halos around the image. The linear encoding - * will probably result in a washed out, too bright, image (it's actually too - * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably - * substantially reduce the halos. Alternatively try: - * - * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); - * This option will also reduce the halos, but there will be slight dark - * halos round the opaque parts of the image where the background is light. - * In the OPTIMIZED mode the halos will be light halos where the background - * is dark. Take your pick - the halos are unavoidable unless you can get - * your hardware/software fixed! (The OPTIMIZED approach is slightly - * faster.) - * - * When the default gamma of PNG files doesn't match the output gamma. - * If you have PNG files with no gamma information png_set_alpha_mode allows - * you to provide a default gamma, but it also sets the ouput gamma to the - * matching value. If you know your PNG files have a gamma that doesn't - * match the output you can take advantage of the fact that - * png_set_alpha_mode always sets the output gamma but only sets the PNG - * default if it is not already set: - * - * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); - * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); - * The first call sets both the default and the output gamma values, the - * second call overrides the output gamma without changing the default. This - * is easier than achieving the same effect with png_set_gamma. You must use - * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will - * fire if more than one call to png_set_alpha_mode and png_set_background is - * made in the same read operation, however multiple calls with PNG_ALPHA_PNG - * are ignored. - */ - -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED -PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ - defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) -PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ - defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) -/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ -PNG_EXPORT(39, void, png_set_filler, (png_structp png_ptr, png_uint_32 filler, - int flags)); -/* The values of the PNG_FILLER_ defines should NOT be changed */ -# define PNG_FILLER_BEFORE 0 -# define PNG_FILLER_AFTER 1 -/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ -PNG_EXPORT(40, void, png_set_add_alpha, - (png_structp png_ptr, png_uint_32 filler, - int flags)); -#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ - -#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) -/* Swap bytes in 16-bit depth files. */ -PNG_EXPORT(41, void, png_set_swap, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) -/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ -PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ - defined(PNG_WRITE_PACKSWAP_SUPPORTED) -/* Swap packing order of pixels in bytes. */ -PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) -/* Converts files to legal bit depths. */ -PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_color_8p - true_bits)); -#endif - -#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ - defined(PNG_WRITE_INTERLACING_SUPPORTED) -/* Have the code handle the interlacing. Returns the number of passes. - * MUST be called before png_read_update_info or png_start_read_image, - * otherwise it will not have the desired effect. Note that it is still - * necessary to call png_read_row or png_read_rows png_get_image_height - * times for each pass. -*/ -PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr)); -#endif - -#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) -/* Invert monochrome files */ -PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr)); -#endif - -#ifdef PNG_READ_BACKGROUND_SUPPORTED -/* Handle alpha and tRNS by replacing with a background color. Prior to - * libpng-1.5.4 this API must not be called before the PNG file header has been - * read. Doing so will result in unexpected behavior and possible warnings or - * errors if the PNG file contains a bKGD chunk. - */ -PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr, - png_const_color_16p background_color, int background_gamma_code, - int need_expand, double background_gamma)); -PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr, - png_const_color_16p background_color, int background_gamma_code, - int need_expand, png_fixed_point background_gamma)); -#endif -#ifdef PNG_READ_BACKGROUND_SUPPORTED -# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 -# define PNG_BACKGROUND_GAMMA_SCREEN 1 -# define PNG_BACKGROUND_GAMMA_FILE 2 -# define PNG_BACKGROUND_GAMMA_UNIQUE 3 -#endif - -#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED -/* Scale a 16-bit depth file down to 8-bit, accurately. */ -PNG_EXPORT(229, void, png_set_scale_16, (png_structp png_ptr)); -#endif - -#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED -#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ -/* Strip the second byte of information from a 16-bit depth file. */ -PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr)); -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED -/* Turn on quantizing, and reduce the palette to the number of colors - * available. - */ -PNG_EXPORT(49, void, png_set_quantize, - (png_structp png_ptr, png_colorp palette, - int num_palette, int maximum_colors, png_const_uint_16p histogram, - int full_quantize)); -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED -/* The threshold on gamma processing is configurable but hard-wired into the - * library. The following is the floating point variant. - */ -#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) - -/* Handle gamma correction. Screen_gamma=(display_exponent). - * NOTE: this API simply sets the screen and file gamma values. It will - * therefore override the value for gamma in a PNG file if it is called after - * the file header has been read - use with care - call before reading the PNG - * file for best results! - * - * These routines accept the same gamma values as png_set_alpha_mode (described - * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either - * API (floating point or fixed.) Notice, however, that the 'file_gamma' value - * is the inverse of a 'screen gamma' value. - */ -PNG_FP_EXPORT(50, void, png_set_gamma, - (png_structp png_ptr, double screen_gamma, - double override_file_gamma)); -PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr, - png_fixed_point screen_gamma, png_fixed_point override_file_gamma)); -#endif - -#ifdef PNG_WRITE_FLUSH_SUPPORTED -/* Set how many lines between output flushes - 0 for no flushing */ -PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows)); -/* Flush the current PNG output buffer */ -PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr)); -#endif - -/* Optional update palette with requested transformations */ -PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr)); - -/* Optional call to update the users info structure */ -PNG_EXPORT(54, void, png_read_update_info, - (png_structp png_ptr, png_infop info_ptr)); - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read one or more rows of image data. */ -PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row, - png_bytepp display_row, png_uint_32 num_rows)); -#endif - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read a row of data. */ -PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row, - png_bytep display_row)); -#endif - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read the whole image into memory at once. */ -PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image)); -#endif - -/* Write a row of image data */ -PNG_EXPORT(58, void, png_write_row, - (png_structp png_ptr, png_const_bytep row)); - -/* Write a few rows of image data: (*row) is not written; however, the type - * is declared as writeable to maintain compatibility with previous versions - * of libpng and to allow the 'display_row' array from read_rows to be passed - * unchanged to write_rows. - */ -PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row, - png_uint_32 num_rows)); - -/* Write the image data */ -PNG_EXPORT(60, void, png_write_image, - (png_structp png_ptr, png_bytepp image)); - -/* Write the end of the PNG file. */ -PNG_EXPORT(61, void, png_write_end, - (png_structp png_ptr, png_infop info_ptr)); - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read the end of the PNG file. */ -PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr)); -#endif - -/* Free any memory associated with the png_info_struct */ -PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr, - png_infopp info_ptr_ptr)); - -/* Free any memory associated with the png_struct and the png_info_structs */ -PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, - png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); - -/* Free any memory associated with the png_struct and the png_info_structs */ -PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, - png_infopp info_ptr_ptr)); - -/* Set the libpng method of handling chunk CRC errors */ -PNG_EXPORT(66, void, png_set_crc_action, - (png_structp png_ptr, int crit_action, int ancil_action)); - -/* Values for png_set_crc_action() say how to handle CRC errors in - * ancillary and critical chunks, and whether to use the data contained - * therein. Note that it is impossible to "discard" data in a critical - * chunk. For versions prior to 0.90, the action was always error/quit, - * whereas in version 0.90 and later, the action for CRC errors in ancillary - * chunks is warn/discard. These values should NOT be changed. - * - * value action:critical action:ancillary - */ -#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ -#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ -#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ -#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ -#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ -#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ - -/* These functions give the user control over the scan-line filtering in - * libpng and the compression methods used by zlib. These functions are - * mainly useful for testing, as the defaults should work with most users. - * Those users who are tight on memory or want faster performance at the - * expense of compression can modify them. See the compression library - * header file (zlib.h) for an explination of the compression functions. - */ - -/* Set the filtering method(s) used by libpng. Currently, the only valid - * value for "method" is 0. - */ -PNG_EXPORT(67, void, png_set_filter, - (png_structp png_ptr, int method, int filters)); - -/* Flags for png_set_filter() to say which filters to use. The flags - * are chosen so that they don't conflict with real filter types - * below, in case they are supplied instead of the #defined constants. - * These values should NOT be changed. - */ -#define PNG_NO_FILTERS 0x00 -#define PNG_FILTER_NONE 0x08 -#define PNG_FILTER_SUB 0x10 -#define PNG_FILTER_UP 0x20 -#define PNG_FILTER_AVG 0x40 -#define PNG_FILTER_PAETH 0x80 -#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ - PNG_FILTER_AVG | PNG_FILTER_PAETH) - -/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. - * These defines should NOT be changed. - */ -#define PNG_FILTER_VALUE_NONE 0 -#define PNG_FILTER_VALUE_SUB 1 -#define PNG_FILTER_VALUE_UP 2 -#define PNG_FILTER_VALUE_AVG 3 -#define PNG_FILTER_VALUE_PAETH 4 -#define PNG_FILTER_VALUE_LAST 5 - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */ -/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ - * defines, either the default (minimum-sum-of-absolute-differences), or - * the experimental method (weighted-minimum-sum-of-absolute-differences). - * - * Weights are factors >= 1.0, indicating how important it is to keep the - * filter type consistent between rows. Larger numbers mean the current - * filter is that many times as likely to be the same as the "num_weights" - * previous filters. This is cumulative for each previous row with a weight. - * There needs to be "num_weights" values in "filter_weights", or it can be - * NULL if the weights aren't being specified. Weights have no influence on - * the selection of the first row filter. Well chosen weights can (in theory) - * improve the compression for a given image. - * - * Costs are factors >= 1.0 indicating the relative decoding costs of a - * filter type. Higher costs indicate more decoding expense, and are - * therefore less likely to be selected over a filter with lower computational - * costs. There needs to be a value in "filter_costs" for each valid filter - * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't - * setting the costs. Costs try to improve the speed of decompression without - * unduly increasing the compressed image size. - * - * A negative weight or cost indicates the default value is to be used, and - * values in the range [0.0, 1.0) indicate the value is to remain unchanged. - * The default values for both weights and costs are currently 1.0, but may - * change if good general weighting/cost heuristics can be found. If both - * the weights and costs are set to 1.0, this degenerates the WEIGHTED method - * to the UNWEIGHTED method, but with added encoding time/computation. - */ -PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr, - int heuristic_method, int num_weights, png_const_doublep filter_weights, - png_const_doublep filter_costs)); -PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, - (png_structp png_ptr, - int heuristic_method, int num_weights, png_const_fixed_point_p - filter_weights, png_const_fixed_point_p filter_costs)); -#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ - -/* Heuristic used for row filter selection. These defines should NOT be - * changed. - */ -#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ -#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ -#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ -#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ - -#ifdef PNG_WRITE_SUPPORTED -/* Set the library compression level. Currently, valid values range from - * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 - * (0 - no compression, 9 - "maximal" compression). Note that tests have - * shown that zlib compression levels 3-6 usually perform as well as level 9 - * for PNG images, and do considerably fewer caclulations. In the future, - * these values may not correspond directly to the zlib compression levels. - */ -PNG_EXPORT(69, void, png_set_compression_level, - (png_structp png_ptr, int level)); - -PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr, - int mem_level)); - -PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr, - int strategy)); - -/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a - * smaller value of window_bits if it can do so safely. - */ -PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr, - int window_bits)); - -PNG_EXPORT(73, void, png_set_compression_method, (png_structp png_ptr, - int method)); -#endif - -#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED -/* Also set zlib parameters for compressing non-IDAT chunks */ -PNG_EXPORT(222, void, png_set_text_compression_level, - (png_structp png_ptr, int level)); - -PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structp png_ptr, - int mem_level)); - -PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structp png_ptr, - int strategy)); - -/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a - * smaller value of window_bits if it can do so safely. - */ -PNG_EXPORT(225, void, png_set_text_compression_window_bits, (png_structp - png_ptr, int window_bits)); - -PNG_EXPORT(226, void, png_set_text_compression_method, (png_structp png_ptr, - int method)); -#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ - -/* These next functions are called for input/output, memory, and error - * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, - * and call standard C I/O routines such as fread(), fwrite(), and - * fprintf(). These functions can be made to use other I/O routines - * at run time for those applications that need to handle I/O in a - * different manner by calling png_set_???_fn(). See libpng-manual.txt for - * more information. - */ - -#ifdef PNG_STDIO_SUPPORTED -/* Initialize the input/output for the PNG file to the default functions. */ -PNG_EXPORT(74, void, png_init_io, (png_structp png_ptr, png_FILE_p fp)); -#endif - -/* Replace the (error and abort), and warning functions with user - * supplied functions. If no messages are to be printed you must still - * write and use replacement functions. The replacement error_fn should - * still do a longjmp to the last setjmp location if you are using this - * method of error handling. If error_fn or warning_fn is NULL, the - * default function will be used. - */ - -PNG_EXPORT(75, void, png_set_error_fn, - (png_structp png_ptr, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warning_fn)); - -/* Return the user pointer associated with the error functions */ -PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structp png_ptr)); - -/* Replace the default data output functions with a user supplied one(s). - * If buffered output is not used, then output_flush_fn can be set to NULL. - * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time - * output_flush_fn will be ignored (and thus can be NULL). - * It is probably a mistake to use NULL for output_flush_fn if - * write_data_fn is not also NULL unless you have built libpng with - * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's - * default flush function, which uses the standard *FILE structure, will - * be used. - */ -PNG_EXPORT(77, void, png_set_write_fn, (png_structp png_ptr, png_voidp io_ptr, - png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); - -/* Replace the default data input function with a user supplied one. */ -PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr, - png_rw_ptr read_data_fn)); - -/* Return the user pointer associated with the I/O functions */ -PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr)); - -PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr, - png_read_status_ptr read_row_fn)); - -PNG_EXPORT(81, void, png_set_write_status_fn, (png_structp png_ptr, - png_write_status_ptr write_row_fn)); - -#ifdef PNG_USER_MEM_SUPPORTED -/* Replace the default memory allocation functions with user supplied one(s). */ -PNG_EXPORT(82, void, png_set_mem_fn, (png_structp png_ptr, png_voidp mem_ptr, - png_malloc_ptr malloc_fn, png_free_ptr free_fn)); -/* Return the user pointer associated with the memory functions */ -PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr)); -#endif - -#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED -PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr, - png_user_transform_ptr read_user_transform_fn)); -#endif - -#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED -PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr, - png_user_transform_ptr write_user_transform_fn)); -#endif - -#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED -PNG_EXPORT(86, void, png_set_user_transform_info, (png_structp png_ptr, - png_voidp user_transform_ptr, int user_transform_depth, - int user_transform_channels)); -/* Return the user pointer associated with the user transform functions */ -PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, - (png_const_structp png_ptr)); -#endif - -#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED -/* Return information about the row currently being processed. Note that these - * APIs do not fail but will return unexpected results if called outside a user - * transform callback. Also note that when transforming an interlaced image the - * row number is the row number within the sub-image of the interlace pass, so - * the value will increase to the height of the sub-image (not the full image) - * then reset to 0 for the next pass. - * - * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to - * find the output pixel (x,y) given an interlaced sub-image pixel - * (row,col,pass). (See below for these macros.) - */ -PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp)); -PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp)); -#endif - -#ifdef PNG_USER_CHUNKS_SUPPORTED -PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr, - png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); -PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structp png_ptr)); -#endif - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -/* Sets the function callbacks for the push reader, and a pointer to a - * user-defined structure available to the callback functions. - */ -PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structp png_ptr, - png_voidp progressive_ptr, png_progressive_info_ptr info_fn, - png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); - -/* Returns the user pointer associated with the push read functions */ -PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr)); - -/* Function to be called when data becomes available */ -PNG_EXPORT(92, void, png_process_data, - (png_structp png_ptr, png_infop info_ptr, - png_bytep buffer, png_size_t buffer_size)); - -/* A function which may be called *only* within png_process_data to stop the - * processing of any more data. The function returns the number of bytes - * remaining, excluding any that libpng has cached internally. A subsequent - * call to png_process_data must supply these bytes again. If the argument - * 'save' is set to true the routine will first save all the pending data and - * will always return 0. - */ -PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save)); - -/* A function which may be called *only* outside (after) a call to - * png_process_data. It returns the number of bytes of data to skip in the - * input. Normally it will return 0, but if it returns a non-zero value the - * application must skip than number of bytes of input data and pass the - * following data to the next call to png_process_data. - */ -PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp)); - -#ifdef PNG_READ_INTERLACING_SUPPORTED -/* Function that combines rows. 'new_row' is a flag that should come from - * the callback and be non-NULL if anything needs to be done; the library - * stores its own version of the new data internally and ignores the passed - * in value. - */ -PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr, - png_bytep old_row, png_const_bytep new_row)); -#endif /* PNG_READ_INTERLACING_SUPPORTED */ -#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ - -PNG_EXPORTA(94, png_voidp, png_malloc, - (png_structp png_ptr, png_alloc_size_t size), - PNG_ALLOCATED); -/* Added at libpng version 1.4.0 */ -PNG_EXPORTA(95, png_voidp, png_calloc, - (png_structp png_ptr, png_alloc_size_t size), - PNG_ALLOCATED); - -/* Added at libpng version 1.2.4 */ -PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr, - png_alloc_size_t size), PNG_ALLOCATED); - -/* Frees a pointer allocated by png_malloc() */ -PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr)); - -/* Free data that was allocated internally */ -PNG_EXPORT(98, void, png_free_data, - (png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num)); - -/* Reassign responsibility for freeing existing data, whether allocated - * by libpng or by the application */ -PNG_EXPORT(99, void, png_data_freer, - (png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)); - -/* Assignments for png_data_freer */ -#define PNG_DESTROY_WILL_FREE_DATA 1 -#define PNG_SET_WILL_FREE_DATA 1 -#define PNG_USER_WILL_FREE_DATA 2 -/* Flags for png_ptr->free_me and info_ptr->free_me */ -#define PNG_FREE_HIST 0x0008 -#define PNG_FREE_ICCP 0x0010 -#define PNG_FREE_SPLT 0x0020 -#define PNG_FREE_ROWS 0x0040 -#define PNG_FREE_PCAL 0x0080 -#define PNG_FREE_SCAL 0x0100 -#define PNG_FREE_UNKN 0x0200 -#define PNG_FREE_LIST 0x0400 -#define PNG_FREE_PLTE 0x1000 -#define PNG_FREE_TRNS 0x2000 -#define PNG_FREE_TEXT 0x4000 -#define PNG_FREE_ALL 0x7fff -#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ - -#ifdef PNG_USER_MEM_SUPPORTED -PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr, - png_alloc_size_t size), PNG_ALLOCATED); -PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr)); -#endif - -#ifdef PNG_ERROR_TEXT_SUPPORTED -/* Fatal error in PNG image of libpng - can't continue */ -PNG_EXPORTA(102, void, png_error, - (png_structp png_ptr, png_const_charp error_message), - PNG_NORETURN); - -/* The same, but the chunk name is prepended to the error string. */ -PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr, - png_const_charp error_message), PNG_NORETURN); - -#else -/* Fatal error in PNG image of libpng - can't continue */ -PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN); -#endif - -#ifdef PNG_WARNINGS_SUPPORTED -/* Non-fatal error in libpng. Can continue, but may have a problem. */ -PNG_EXPORT(105, void, png_warning, (png_structp png_ptr, - png_const_charp warning_message)); - -/* Non-fatal error in libpng, chunk name is prepended to message. */ -PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr, - png_const_charp warning_message)); -#endif - -#ifdef PNG_BENIGN_ERRORS_SUPPORTED -/* Benign error in libpng. Can continue, but may have a problem. - * User can choose whether to handle as a fatal error or as a warning. */ -# undef png_benign_error -PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr, - png_const_charp warning_message)); - -/* Same, chunk name is prepended to message. */ -# undef png_chunk_benign_error -PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr, - png_const_charp warning_message)); - -PNG_EXPORT(109, void, png_set_benign_errors, - (png_structp png_ptr, int allowed)); -#else -# ifdef PNG_ALLOW_BENIGN_ERRORS -# define png_benign_error png_warning -# define png_chunk_benign_error png_chunk_warning -# else -# define png_benign_error png_error -# define png_chunk_benign_error png_chunk_error -# endif -#endif - -/* The png_set_ functions are for storing values in the png_info_struct. - * Similarly, the png_get_ calls are used to read values from the - * png_info_struct, either storing the parameters in the passed variables, or - * setting pointers into the png_info_struct where the data is stored. The - * png_get_ functions return a non-zero value if the data was available - * in info_ptr, or return zero and do not change any of the parameters if the - * data was not available. - * - * These functions should be used instead of directly accessing png_info - * to avoid problems with future changes in the size and internal layout of - * png_info_struct. - */ -/* Returns "flag" if chunk data is valid in info_ptr. */ -PNG_EXPORT(110, png_uint_32, png_get_valid, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_32 flag)); - -/* Returns number of bytes needed to hold a transformed row. */ -PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -#ifdef PNG_INFO_IMAGE_SUPPORTED -/* Returns row_pointers, which is an array of pointers to scanlines that was - * returned from png_read_png(). - */ -PNG_EXPORT(112, png_bytepp, png_get_rows, - (png_const_structp png_ptr, png_const_infop info_ptr)); -/* Set row_pointers, which is an array of pointers to scanlines for use - * by png_write_png(). - */ -PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr, - png_infop info_ptr, png_bytepp row_pointers)); -#endif - -/* Returns number of color channels in image. */ -PNG_EXPORT(114, png_byte, png_get_channels, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -#ifdef PNG_EASY_ACCESS_SUPPORTED -/* Returns image width in pixels. */ -PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -/* Returns image height in pixels. */ -PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -/* Returns image bit_depth. */ -PNG_EXPORT(117, png_byte, png_get_bit_depth, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -/* Returns image color_type. */ -PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -/* Returns image filter_type. */ -PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -/* Returns image interlace_type. */ -PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -/* Returns image compression_type. */ -PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr, - png_const_infop info_ptr)); - -/* Returns image resolution in pixels per meter, from pHYs chunk data. */ -PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, - (png_const_structp png_ptr, png_const_infop info_ptr)); -PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, - (png_const_structp png_ptr, png_const_infop info_ptr)); -PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -/* Returns pixel aspect ratio, computed from pHYs chunk data. */ -PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, - (png_const_structp png_ptr, png_const_infop info_ptr)); -PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ -PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, - (png_const_structp png_ptr, png_const_infop info_ptr)); -PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, - (png_const_structp png_ptr, png_const_infop info_ptr)); -PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, - (png_const_structp png_ptr, png_const_infop info_ptr)); -PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -#endif /* PNG_EASY_ACCESS_SUPPORTED */ - -/* Returns pointer to signature string read from PNG header */ -PNG_EXPORT(130, png_const_bytep, png_get_signature, - (png_const_structp png_ptr, png_infop info_ptr)); - -#ifdef PNG_bKGD_SUPPORTED -PNG_EXPORT(131, png_uint_32, png_get_bKGD, - (png_const_structp png_ptr, png_infop info_ptr, - png_color_16p *background)); -#endif - -#ifdef PNG_bKGD_SUPPORTED -PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr, - png_const_color_16p background)); -#endif - -#ifdef PNG_cHRM_SUPPORTED -PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr, - png_const_infop info_ptr, double *white_x, double *white_y, double *red_x, - double *red_y, double *green_x, double *green_y, double *blue_x, - double *blue_y)); -PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_structp png_ptr, - png_const_infop info_ptr, double *red_X, double *red_Y, double *red_Z, - double *green_X, double *green_Y, double *green_Z, double *blue_X, - double *blue_Y, double *blue_Z)); -#ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */ -PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, - (png_const_structp png_ptr, - png_const_infop info_ptr, png_fixed_point *int_white_x, - png_fixed_point *int_white_y, png_fixed_point *int_red_x, - png_fixed_point *int_red_y, png_fixed_point *int_green_x, - png_fixed_point *int_green_y, png_fixed_point *int_blue_x, - png_fixed_point *int_blue_y)); -#endif -PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, - (png_structp png_ptr, png_const_infop info_ptr, - png_fixed_point *int_red_X, png_fixed_point *int_red_Y, - png_fixed_point *int_red_Z, png_fixed_point *int_green_X, - png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, - png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, - png_fixed_point *int_blue_Z)); -#endif - -#ifdef PNG_cHRM_SUPPORTED -PNG_FP_EXPORT(135, void, png_set_cHRM, - (png_structp png_ptr, png_infop info_ptr, - double white_x, double white_y, double red_x, double red_y, double green_x, - double green_y, double blue_x, double blue_y)); -PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_structp png_ptr, - png_infop info_ptr, double red_X, double red_Y, double red_Z, - double green_X, double green_Y, double green_Z, double blue_X, - double blue_Y, double blue_Z)); -PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_structp png_ptr, - png_infop info_ptr, png_fixed_point int_white_x, - png_fixed_point int_white_y, png_fixed_point int_red_x, - png_fixed_point int_red_y, png_fixed_point int_green_x, - png_fixed_point int_green_y, png_fixed_point int_blue_x, - png_fixed_point int_blue_y)); -PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_structp png_ptr, - png_infop info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, - png_fixed_point int_red_Z, png_fixed_point int_green_X, - png_fixed_point int_green_Y, png_fixed_point int_green_Z, - png_fixed_point int_blue_X, png_fixed_point int_blue_Y, - png_fixed_point int_blue_Z)); -#endif - -#ifdef PNG_gAMA_SUPPORTED -PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, - (png_const_structp png_ptr, png_const_infop info_ptr, - double *file_gamma)); -PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_fixed_point *int_file_gamma)); -#endif - -#ifdef PNG_gAMA_SUPPORTED -PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr, - png_infop info_ptr, double file_gamma)); -PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr, - png_infop info_ptr, png_fixed_point int_file_gamma)); -#endif - -#ifdef PNG_hIST_SUPPORTED -PNG_EXPORT(141, png_uint_32, png_get_hIST, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_16p *hist)); -#endif - -#ifdef PNG_hIST_SUPPORTED -PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr, - png_infop info_ptr, png_const_uint_16p hist)); -#endif - -PNG_EXPORT(143, png_uint_32, png_get_IHDR, - (png_structp png_ptr, png_infop info_ptr, - png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, - int *interlace_method, int *compression_method, int *filter_method)); - -PNG_EXPORT(144, void, png_set_IHDR, - (png_structp png_ptr, png_infop info_ptr, - png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, - int interlace_method, int compression_method, int filter_method)); - -#ifdef PNG_oFFs_SUPPORTED -PNG_EXPORT(145, png_uint_32, png_get_oFFs, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)); -#endif - -#ifdef PNG_oFFs_SUPPORTED -PNG_EXPORT(146, void, png_set_oFFs, - (png_structp png_ptr, png_infop info_ptr, - png_int_32 offset_x, png_int_32 offset_y, int unit_type)); -#endif - -#ifdef PNG_pCAL_SUPPORTED -PNG_EXPORT(147, png_uint_32, png_get_pCAL, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, - int *nparams, - png_charp *units, png_charpp *params)); -#endif - -#ifdef PNG_pCAL_SUPPORTED -PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr, - png_infop info_ptr, - png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, - int nparams, png_const_charp units, png_charpp params)); -#endif - -#ifdef PNG_pHYs_SUPPORTED -PNG_EXPORT(149, png_uint_32, png_get_pHYs, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); -#endif - -#ifdef PNG_pHYs_SUPPORTED -PNG_EXPORT(150, void, png_set_pHYs, - (png_structp png_ptr, png_infop info_ptr, - png_uint_32 res_x, png_uint_32 res_y, int unit_type)); -#endif - -PNG_EXPORT(151, png_uint_32, png_get_PLTE, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_colorp *palette, int *num_palette)); - -PNG_EXPORT(152, void, png_set_PLTE, - (png_structp png_ptr, png_infop info_ptr, - png_const_colorp palette, int num_palette)); - -#ifdef PNG_sBIT_SUPPORTED -PNG_EXPORT(153, png_uint_32, png_get_sBIT, - (png_const_structp png_ptr, png_infop info_ptr, - png_color_8p *sig_bit)); -#endif - -#ifdef PNG_sBIT_SUPPORTED -PNG_EXPORT(154, void, png_set_sBIT, - (png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit)); -#endif - -#ifdef PNG_sRGB_SUPPORTED -PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr, - png_const_infop info_ptr, int *file_srgb_intent)); -#endif - -#ifdef PNG_sRGB_SUPPORTED -PNG_EXPORT(156, void, png_set_sRGB, - (png_structp png_ptr, png_infop info_ptr, int srgb_intent)); -PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr, - png_infop info_ptr, int srgb_intent)); -#endif - -#ifdef PNG_iCCP_SUPPORTED -PNG_EXPORT(158, png_uint_32, png_get_iCCP, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_charpp name, int *compression_type, png_bytepp profile, - png_uint_32 *proflen)); -#endif - -#ifdef PNG_iCCP_SUPPORTED -PNG_EXPORT(159, void, png_set_iCCP, - (png_structp png_ptr, png_infop info_ptr, - png_const_charp name, int compression_type, png_const_bytep profile, - png_uint_32 proflen)); -#endif - -#ifdef PNG_sPLT_SUPPORTED -PNG_EXPORT(160, png_uint_32, png_get_sPLT, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_sPLT_tpp entries)); -#endif - -#ifdef PNG_sPLT_SUPPORTED -PNG_EXPORT(161, void, png_set_sPLT, - (png_structp png_ptr, png_infop info_ptr, - png_const_sPLT_tp entries, int nentries)); -#endif - -#ifdef PNG_TEXT_SUPPORTED -/* png_get_text also returns the number of text chunks in *num_text */ -PNG_EXPORT(162, png_uint_32, png_get_text, - (png_const_structp png_ptr, png_const_infop info_ptr, - png_textp *text_ptr, int *num_text)); -#endif - -/* Note while png_set_text() will accept a structure whose text, - * language, and translated keywords are NULL pointers, the structure - * returned by png_get_text will always contain regular - * zero-terminated C strings. They might be empty strings but - * they will never be NULL pointers. - */ - -#ifdef PNG_TEXT_SUPPORTED -PNG_EXPORT(163, void, png_set_text, - (png_structp png_ptr, png_infop info_ptr, - png_const_textp text_ptr, int num_text)); -#endif - -#ifdef PNG_tIME_SUPPORTED -PNG_EXPORT(164, png_uint_32, png_get_tIME, - (png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)); -#endif - -#ifdef PNG_tIME_SUPPORTED -PNG_EXPORT(165, void, png_set_tIME, - (png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)); -#endif - -#ifdef PNG_tRNS_SUPPORTED -PNG_EXPORT(166, png_uint_32, png_get_tRNS, - (png_const_structp png_ptr, png_infop info_ptr, - png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)); -#endif - -#ifdef PNG_tRNS_SUPPORTED -PNG_EXPORT(167, void, png_set_tRNS, - (png_structp png_ptr, png_infop info_ptr, - png_const_bytep trans_alpha, int num_trans, - png_const_color_16p trans_color)); -#endif - -#ifdef PNG_sCAL_SUPPORTED -PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, - (png_const_structp png_ptr, png_const_infop info_ptr, - int *unit, double *width, double *height)); -#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED -/* NOTE: this API is currently implemented using floating point arithmetic, - * consequently it can only be used on systems with floating point support. - * In any case the range of values supported by png_fixed_point is small and it - * is highly recommended that png_get_sCAL_s be used instead. - */ -PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, - (png_structp png_ptr, png_const_infop info_ptr, int *unit, - png_fixed_point *width, - png_fixed_point *height)); -#endif -PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, - (png_const_structp png_ptr, png_const_infop info_ptr, - int *unit, png_charpp swidth, png_charpp sheight)); - -PNG_FP_EXPORT(170, void, png_set_sCAL, - (png_structp png_ptr, png_infop info_ptr, - int unit, double width, double height)); -PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr, - png_infop info_ptr, int unit, png_fixed_point width, - png_fixed_point height)); -PNG_EXPORT(171, void, png_set_sCAL_s, - (png_structp png_ptr, png_infop info_ptr, - int unit, png_const_charp swidth, png_const_charp sheight)); -#endif /* PNG_sCAL_SUPPORTED */ - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -/* Provide a list of chunks and how they are to be handled, if the built-in - handling or default unknown chunk handling is not desired. Any chunks not - listed will be handled in the default manner. The IHDR and IEND chunks - must not be listed. Because this turns off the default handling for chunks - that would otherwise be recognized the behavior of libpng transformations may - well become incorrect! - keep = 0: PNG_HANDLE_CHUNK_AS_DEFAULT: follow default behavior - = 1: PNG_HANDLE_CHUNK_NEVER: do not keep - = 2: PNG_HANDLE_CHUNK_IF_SAFE: keep only if safe-to-copy - = 3: PNG_HANDLE_CHUNK_ALWAYS: keep even if unsafe-to-copy -*/ -PNG_EXPORT(172, void, png_set_keep_unknown_chunks, - (png_structp png_ptr, int keep, - png_const_bytep chunk_list, int num_chunks)); - -/* The handling code is returned; the result is therefore true (non-zero) if - * special handling is required, false for the default handling. - */ -PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr, - png_const_bytep chunk_name)); -#endif -#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED -PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr, - png_infop info_ptr, png_const_unknown_chunkp unknowns, - int num_unknowns)); -PNG_EXPORT(175, void, png_set_unknown_chunk_location, - (png_structp png_ptr, png_infop info_ptr, int chunk, int location)); -PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr, - png_const_infop info_ptr, png_unknown_chunkpp entries)); -#endif - -/* Png_free_data() will turn off the "valid" flag for anything it frees. - * If you need to turn it off for a chunk that your application has freed, - * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); - */ -PNG_EXPORT(177, void, png_set_invalid, - (png_structp png_ptr, png_infop info_ptr, int mask)); - -#ifdef PNG_INFO_IMAGE_SUPPORTED -/* The "params" pointer is currently not used and is for future expansion. */ -PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr, - int transforms, png_voidp params)); -PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr, - int transforms, png_voidp params)); -#endif - -PNG_EXPORT(180, png_const_charp, png_get_copyright, - (png_const_structp png_ptr)); -PNG_EXPORT(181, png_const_charp, png_get_header_ver, - (png_const_structp png_ptr)); -PNG_EXPORT(182, png_const_charp, png_get_header_version, - (png_const_structp png_ptr)); -PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, - (png_const_structp png_ptr)); - -#ifdef PNG_MNG_FEATURES_SUPPORTED -PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr, - png_uint_32 mng_features_permitted)); -#endif - -/* For use in png_set_keep_unknown, added to version 1.2.6 */ -#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 -#define PNG_HANDLE_CHUNK_NEVER 1 -#define PNG_HANDLE_CHUNK_IF_SAFE 2 -#define PNG_HANDLE_CHUNK_ALWAYS 3 - -/* Strip the prepended error numbers ("#nnn ") from error and warning - * messages before passing them to the error or warning handler. - */ -#ifdef PNG_ERROR_NUMBERS_SUPPORTED -PNG_EXPORT(185, void, png_set_strip_error_numbers, - (png_structp png_ptr, - png_uint_32 strip_mode)); -#endif - -/* Added in libpng-1.2.6 */ -#ifdef PNG_SET_USER_LIMITS_SUPPORTED -PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr, - png_uint_32 user_width_max, png_uint_32 user_height_max)); -PNG_EXPORT(187, png_uint_32, png_get_user_width_max, - (png_const_structp png_ptr)); -PNG_EXPORT(188, png_uint_32, png_get_user_height_max, - (png_const_structp png_ptr)); -/* Added in libpng-1.4.0 */ -PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr, - png_uint_32 user_chunk_cache_max)); -PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, - (png_const_structp png_ptr)); -/* Added in libpng-1.4.1 */ -PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr, - png_alloc_size_t user_chunk_cache_max)); -PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, - (png_const_structp png_ptr)); -#endif - -#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) -PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, - (png_const_structp png_ptr, png_const_infop info_ptr)); - -PNG_FP_EXPORT(196, float, png_get_x_offset_inches, - (png_const_structp png_ptr, png_const_infop info_ptr)); -#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ -PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, - (png_structp png_ptr, png_const_infop info_ptr)); -#endif - -PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr, - png_const_infop info_ptr)); -#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ -PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, - (png_structp png_ptr, png_const_infop info_ptr)); -#endif - -# ifdef PNG_pHYs_SUPPORTED -PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr, - png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, - int *unit_type)); -# endif /* PNG_pHYs_SUPPORTED */ -#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ - -/* Added in libpng-1.4.0 */ -#ifdef PNG_IO_STATE_SUPPORTED -PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr)); - -PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name, - (png_structp png_ptr), PNG_DEPRECATED); -PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, - (png_const_structp png_ptr)); - -/* The flags returned by png_get_io_state() are the following: */ -# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ -# define PNG_IO_READING 0x0001 /* currently reading */ -# define PNG_IO_WRITING 0x0002 /* currently writing */ -# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ -# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ -# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ -# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ -# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ -# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ -#endif /* ?PNG_IO_STATE_SUPPORTED */ - -/* Interlace support. The following macros are always defined so that if - * libpng interlace handling is turned off the macros may be used to handle - * interlaced images within the application. - */ -#define PNG_INTERLACE_ADAM7_PASSES 7 - -/* Two macros to return the first row and first column of the original, - * full, image which appears in a given pass. 'pass' is in the range 0 - * to 6 and the result is in the range 0 to 7. - */ -#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7) -#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7) - -/* A macro to return the offset between pixels in the output row for a pair of - * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that - * follows. Note that ROW_OFFSET is the offset from one row to the next whereas - * COL_OFFSET is from one column to the next, within a row. - */ -#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8) -#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1)) - -/* Two macros to help evaluate the number of rows or columns in each - * pass. This is expressed as a shift - effectively log2 of the number or - * rows or columns in each 8x8 tile of the original image. - */ -#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) -#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) - -/* Hence two macros to determine the number of rows or columns in a given - * pass of an image given its height or width. In fact these macros may - * return non-zero even though the sub-image is empty, because the other - * dimension may be empty for a small image. - */ -#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) -#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) - -/* For the reader row callbacks (both progressive and sequential) it is - * necessary to find the row in the output image given a row in an interlaced - * image, so two more macros: - */ -#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \ - (((yIn)<>(((7-(off))-(pass))<<2)) & 0xF) | \ - ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0)) - -#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ - ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) -#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ - ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) - -#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED -/* With these routines we avoid an integer divide, which will be slower on - * most machines. However, it does take more operations than the corresponding - * divide method, so it may be slower on a few RISC systems. There are two - * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. - * - * Note that the rounding factors are NOT supposed to be the same! 128 and - * 32768 are correct for the NODIV code; 127 and 32767 are correct for the - * standard method. - * - * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] - */ - - /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ - -# define png_composite(composite, fg, alpha, bg) \ - { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ - * (png_uint_16)(alpha) \ - + (png_uint_16)(bg)*(png_uint_16)(255 \ - - (png_uint_16)(alpha)) + 128); \ - (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } - -# define png_composite_16(composite, fg, alpha, bg) \ - { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ - * (png_uint_32)(alpha) \ - + (png_uint_32)(bg)*(65535 \ - - (png_uint_32)(alpha)) + 32768); \ - (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } - -#else /* Standard method using integer division */ - -# define png_composite(composite, fg, alpha, bg) \ - (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ - (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ - 127) / 255) - -# define png_composite_16(composite, fg, alpha, bg) \ - (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ - (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ - 32767) / 65535) -#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ - -#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED -PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); -PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); -PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); -#endif - -PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr, - png_const_bytep buf)); -/* No png_get_int_16 -- may be added if there's a real need for it. */ - -/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ -#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED -PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); -#endif -#ifdef PNG_SAVE_INT_32_SUPPORTED -PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i)); -#endif - -/* Place a 16-bit number into a buffer in PNG byte order. - * The parameter is declared unsigned int, not png_uint_16, - * just to avoid potential problems on pre-ANSI C compilers. - */ -#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED -PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); -/* No png_save_int_16 -- may be added if there's a real need for it. */ -#endif - -#ifdef PNG_USE_READ_MACROS -/* Inline macros to do direct reads of bytes from the input buffer. - * The png_get_int_32() routine assumes we are using two's complement - * format for negative values, which is almost certainly true. - */ -# define png_get_uint_32(buf) \ - (((png_uint_32)(*(buf)) << 24) + \ - ((png_uint_32)(*((buf) + 1)) << 16) + \ - ((png_uint_32)(*((buf) + 2)) << 8) + \ - ((png_uint_32)(*((buf) + 3)))) - - /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the - * function) incorrectly returned a value of type png_uint_32. - */ -# define png_get_uint_16(buf) \ - ((png_uint_16) \ - (((unsigned int)(*(buf)) << 8) + \ - ((unsigned int)(*((buf) + 1))))) - -# define png_get_int_32(buf) \ - ((png_int_32)((*(buf) & 0x80) \ - ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ - : (png_int_32)png_get_uint_32(buf))) -#endif - -#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ - defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) -PNG_EXPORT(234, void, png_set_check_for_invalid_index, (png_structp png_ptr, - int allowed)); -#endif - -/* Maintainer: Put new public prototypes here ^, in libpng.3, and project - * defs - */ - -/* The last ordinal number (this is the *last* one already used; the next - * one to use is one more than this.) Maintainer, remember to add an entry to - * scripts/symbols.def as well. - */ -#ifdef PNG_EXPORT_LAST_ORDINAL - PNG_EXPORT_LAST_ORDINAL(234); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* PNG_VERSION_INFO_ONLY */ -/* Do not put anything past this line */ -#endif /* PNG_H */ - -#include /* Added by Paul Pedriana for EA, as libpng used to effectively do this, and without it this new version of libpng breaks users. */ -#include /* Added by Paul Pedriana for EA, as libpng used to effectively do this, and without it this new version of libpng breaks users. */ - diff --git a/include/pngconf.h b/include/pngconf.h deleted file mode 100644 index a212b9f..0000000 --- a/include/pngconf.h +++ /dev/null @@ -1,605 +0,0 @@ - -/* pngconf.h - machine configurable file for libpng - * - * libpng version 1.5.10 - March 29, 2012 - * - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - */ - -/* Any machine specific code is near the front of this file, so if you - * are configuring libpng for a machine, you may want to read the section - * starting here down to where it starts to typedef png_color, png_text, - * and png_info. - */ - -#ifndef PNGCONF_H -#define PNGCONF_H - -/* Added by EA to work around broken Apple glibc versions */ -/* http://old.nabble.com/Re%3A--sourceforge---18747%3A-libpng-1.5.2-compile-errors-on-AIX-pngread-pngwrite-td31373457.html */ - -#if defined(__APPLE__) // It would be better to use this if we can know what GLIBC value to check against: (defined(__APPLE__) && (__GLIBC__ < ____)) -# ifndef PNG_PTR_NORETURN -# define PNG_PTR_NORETURN -# endif -#endif - -#ifndef PNG_BUILDING_SYMBOL_TABLE -/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C - * definition file for machine specific limits, this may impact the - * correctness of the definitons below (see uses of INT_MAX). - */ -# ifndef PNG_NO_LIMITS_H -# include -# endif - -/* For the memory copy APIs (i.e. the standard definitions of these), - * because this file defines png_memcpy and so on the base APIs must - * be defined here. - */ -# ifdef BSD -# include -# else -# include -# endif - -/* For png_FILE_p - this provides the standard definition of a - * FILE - */ -# ifdef PNG_STDIO_SUPPORTED -# include -# endif -#endif - -/* This controls optimization of the reading of 16 and 32 bit values - * from PNG files. It can be set on a per-app-file basis - it - * just changes whether a macro is used when the function is called. - * The library builder sets the default; if read functions are not - * built into the library the macro implementation is forced on. - */ -#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED -# define PNG_USE_READ_MACROS -#endif -#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) -# if PNG_DEFAULT_READ_MACROS -# define PNG_USE_READ_MACROS -# endif -#endif - -/* COMPILER SPECIFIC OPTIONS. - * - * These options are provided so that a variety of difficult compilers - * can be used. Some are fixed at build time (e.g. PNG_API_RULE - * below) but still have compiler specific implementations, others - * may be changed on a per-file basis when compiling against libpng. - */ - -/* The PNGARG macro protects us against machines that don't have function - * prototypes (ie K&R style headers). If your compiler does not handle - * function prototypes, define this macro and use the included ansi2knr. - * I've always been able to use _NO_PROTO as the indicator, but you may - * need to drag the empty declaration out in front of here, or change the - * ifdef to suit your own needs. - */ -#ifndef PNGARG - -# ifdef OF /* zlib prototype munger */ -# define PNGARG(arglist) OF(arglist) -# else - -# ifdef _NO_PROTO -# define PNGARG(arglist) () -# else -# define PNGARG(arglist) arglist -# endif /* _NO_PROTO */ - -# endif /* OF */ - -#endif /* PNGARG */ - -/* Function calling conventions. - * ============================= - * Normally it is not necessary to specify to the compiler how to call - * a function - it just does it - however on x86 systems derived from - * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems - * and some others) there are multiple ways to call a function and the - * default can be changed on the compiler command line. For this reason - * libpng specifies the calling convention of every exported function and - * every function called via a user supplied function pointer. This is - * done in this file by defining the following macros: - * - * PNGAPI Calling convention for exported functions. - * PNGCBAPI Calling convention for user provided (callback) functions. - * PNGCAPI Calling convention used by the ANSI-C library (required - * for longjmp callbacks and sometimes used internally to - * specify the calling convention for zlib). - * - * These macros should never be overridden. If it is necessary to - * change calling convention in a private build this can be done - * by setting PNG_API_RULE (which defaults to 0) to one of the values - * below to select the correct 'API' variants. - * - * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. - * This is correct in every known environment. - * PNG_API_RULE=1 Use the operating system convention for PNGAPI and - * the 'C' calling convention (from PNGCAPI) for - * callbacks (PNGCBAPI). This is no longer required - * in any known environment - if it has to be used - * please post an explanation of the problem to the - * libpng mailing list. - * - * These cases only differ if the operating system does not use the C - * calling convention, at present this just means the above cases - * (x86 DOS/Windows sytems) and, even then, this does not apply to - * Cygwin running on those systems. - * - * Note that the value must be defined in pnglibconf.h so that what - * the application uses to call the library matches the conventions - * set when building the library. - */ - -/* Symbol export - * ============= - * When building a shared library it is almost always necessary to tell - * the compiler which symbols to export. The png.h macro 'PNG_EXPORT' - * is used to mark the symbols. On some systems these symbols can be - * extracted at link time and need no special processing by the compiler, - * on other systems the symbols are flagged by the compiler and just - * the declaration requires a special tag applied (unfortunately) in a - * compiler dependent way. Some systems can do either. - * - * A small number of older systems also require a symbol from a DLL to - * be flagged to the program that calls it. This is a problem because - * we do not know in the header file included by application code that - * the symbol will come from a shared library, as opposed to a statically - * linked one. For this reason the application must tell us by setting - * the magic flag PNG_USE_DLL to turn on the special processing before - * it includes png.h. - * - * Four additional macros are used to make this happen: - * - * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from - * the build or imported if PNG_USE_DLL is set - compiler - * and system specific. - * - * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to - * 'type', compiler specific. - * - * PNG_DLL_EXPORT Set to the magic to use during a libpng build to - * make a symbol exported from the DLL. Not used in the - * public header files; see pngpriv.h for how it is used - * in the libpng build. - * - * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come - * from a DLL - used to define PNG_IMPEXP when - * PNG_USE_DLL is set. - */ - -/* System specific discovery. - * ========================== - * This code is used at build time to find PNG_IMPEXP, the API settings - * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL - * import processing is possible. On Windows/x86 systems it also sets - * compiler-specific macros to the values required to change the calling - * conventions of the various functions. - */ -#if ( defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ - defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ) &&\ - ( defined(_X86_) || defined(_X64_) || defined(_M_IX86) ||\ - defined(_M_X64) || defined(_M_IA64) ) - /* Windows system (DOS doesn't support DLLs) running on x86/x64. Includes - * builds under Cygwin or MinGW. Also includes Watcom builds but these need - * special treatment because they are not compatible with GCC or Visual C - * because of different calling conventions. - */ -# if PNG_API_RULE == 2 - /* If this line results in an error, either because __watcall is not - * understood or because of a redefine just below you cannot use *this* - * build of the library with the compiler you are using. *This* build was - * build using Watcom and applications must also be built using Watcom! - */ -# define PNGCAPI __watcall -# endif - -# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) -# define PNGCAPI __cdecl -# if PNG_API_RULE == 1 -# define PNGAPI __stdcall -# endif -# else - /* An older compiler, or one not detected (erroneously) above, - * if necessary override on the command line to get the correct - * variants for the compiler. - */ -# ifndef PNGCAPI -# define PNGCAPI _cdecl -# endif -# if PNG_API_RULE == 1 && !defined(PNGAPI) -# define PNGAPI _stdcall -# endif -# endif /* compiler/api */ - /* NOTE: PNGCBAPI always defaults to PNGCAPI. */ - -# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) - ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed -# endif - -# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ - (defined(__BORLANDC__) && __BORLANDC__ < 0x500) - /* older Borland and MSC - * compilers used '__export' and required this to be after - * the type. - */ -# ifndef PNG_EXPORT_TYPE -# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP -# endif -# define PNG_DLL_EXPORT __export -# else /* newer compiler */ -# define PNG_DLL_EXPORT __declspec(dllexport) -# ifndef PNG_DLL_IMPORT -# define PNG_DLL_IMPORT __declspec(dllimport) -# endif -# endif /* compiler */ - -#else /* !Windows/x86 */ -# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) -# define PNGAPI _System -# else /* !Windows/x86 && !OS/2 */ - /* Use the defaults, or define PNG*API on the command line (but - * this will have to be done for every compile!) - */ -# endif /* other system, !OS/2 */ -#endif /* !Windows/x86 */ - -/* Now do all the defaulting . */ -#ifndef PNGCAPI -# define PNGCAPI -#endif -#ifndef PNGCBAPI -# define PNGCBAPI PNGCAPI -#endif -#ifndef PNGAPI -# define PNGAPI PNGCAPI -#endif - -/* PNG_IMPEXP may be set on the compilation system command line or (if not set) - * then in an internal header file when building the library, otherwise (when - * using the library) it is set here. - */ -#ifndef PNG_IMPEXP -# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) - /* This forces use of a DLL, disallowing static linking */ -# define PNG_IMPEXP PNG_DLL_IMPORT -# endif - -# ifndef PNG_IMPEXP -# define PNG_IMPEXP -# endif -#endif - -/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat - * 'attributes' as a storage class - the attributes go at the start of the - * function definition, and attributes are always appended regardless of the - * compiler. This considerably simplifies these macros but may cause problems - * if any compilers both need function attributes and fail to handle them as - * a storage class (this is unlikely.) - */ -#ifndef PNG_FUNCTION -# define PNG_FUNCTION(type, name, args, attributes) attributes type name args -#endif - -#ifndef PNG_EXPORT_TYPE -# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type -#endif - - /* The ordinal value is only relevant when preprocessing png.h for symbol - * table entries, so we discard it here. See the .dfn files in the - * scripts directory. - */ -#ifndef PNG_EXPORTA - -# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ - PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \ - extern attributes) -#endif - -/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, - * so make something non-empty to satisfy the requirement: - */ -#define PNG_EMPTY /*empty list*/ - -#define PNG_EXPORT(ordinal, type, name, args)\ - PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) - -/* Use PNG_REMOVED to comment out a removed interface. */ -#ifndef PNG_REMOVED -# define PNG_REMOVED(ordinal, type, name, args, attributes) -#endif - -#ifndef PNG_CALLBACK -# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) -#endif - -/* Support for compiler specific function attributes. These are used - * so that where compiler support is available incorrect use of API - * functions in png.h will generate compiler warnings. - * - * Added at libpng-1.2.41. - */ - -#ifndef PNG_NO_PEDANTIC_WARNINGS -# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED -# define PNG_PEDANTIC_WARNINGS_SUPPORTED -# endif -#endif - -#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED - /* Support for compiler specific function attributes. These are used - * so that where compiler support is available incorrect use of API - * functions in png.h will generate compiler warnings. Added at libpng - * version 1.2.41. - */ -# if defined(__GNUC__) -# ifndef PNG_USE_RESULT -# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) -# endif -# ifndef PNG_NORETURN -# define PNG_NORETURN __attribute__((__noreturn__)) -# endif -# ifndef PNG_ALLOCATED -# define PNG_ALLOCATED __attribute__((__malloc__)) -# endif -# ifndef PNG_DEPRECATED -# define PNG_DEPRECATED __attribute__((__deprecated__)) -# endif -# ifndef PNG_PRIVATE -# if 0 /* Doesn't work so we use deprecated instead*/ -# define PNG_PRIVATE \ - __attribute__((warning("This function is not exported by libpng."))) -# else -# define PNG_PRIVATE \ - __attribute__((__deprecated__)) -# endif -# endif -# endif /* __GNUC__ */ - -# if defined(_MSC_VER) && (_MSC_VER >= 1300) -# ifndef PNG_USE_RESULT -# define PNG_USE_RESULT /* not supported */ -# endif -# ifndef PNG_NORETURN -# define PNG_NORETURN __declspec(noreturn) -# endif -# ifndef PNG_ALLOCATED -# if (_MSC_VER >= 1400) -# define PNG_ALLOCATED __declspec(restrict) -# endif -# endif -# ifndef PNG_DEPRECATED -# define PNG_DEPRECATED __declspec(deprecated) -# endif -# ifndef PNG_PRIVATE -# define PNG_PRIVATE __declspec(deprecated) -# endif -# endif /* _MSC_VER */ -#endif /* PNG_PEDANTIC_WARNINGS */ - -#ifndef PNG_DEPRECATED -# define PNG_DEPRECATED /* Use of this function is deprecated */ -#endif -#ifndef PNG_USE_RESULT -# define PNG_USE_RESULT /* The result of this function must be checked */ -#endif -#ifndef PNG_NORETURN -# define PNG_NORETURN /* This function does not return */ -#endif -#ifndef PNG_ALLOCATED -# define PNG_ALLOCATED /* The result of the function is new memory */ -#endif -#ifndef PNG_PRIVATE -# define PNG_PRIVATE /* This is a private libpng function */ -#endif -#ifndef PNG_FP_EXPORT /* A floating point API. */ -# ifdef PNG_FLOATING_POINT_SUPPORTED -# define PNG_FP_EXPORT(ordinal, type, name, args)\ - PNG_EXPORT(ordinal, type, name, args) -# else /* No floating point APIs */ -# define PNG_FP_EXPORT(ordinal, type, name, args) -# endif -#endif -#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ -# ifdef PNG_FIXED_POINT_SUPPORTED -# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ - PNG_EXPORT(ordinal, type, name, args) -# else /* No fixed point APIs */ -# define PNG_FIXED_EXPORT(ordinal, type, name, args) -# endif -#endif - -/* The following uses const char * instead of char * for error - * and warning message functions, so some compilers won't complain. - * If you do not want to use const, define PNG_NO_CONST here. - * - * This should not change how the APIs are called, so it can be done - * on a per-file basis in the application. - */ -#ifndef PNG_CONST -# ifndef PNG_NO_CONST -# define PNG_CONST const -# else -# define PNG_CONST -# endif -#endif - -/* Some typedefs to get us started. These should be safe on most of the - * common platforms. The typedefs should be at least as large as the - * numbers suggest (a png_uint_32 must be at least 32 bits long), but they - * don't have to be exactly that size. Some compilers dislike passing - * unsigned shorts as function parameters, so you may be better off using - * unsigned int for png_uint_16. - */ - -#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL) -typedef unsigned int png_uint_32; -typedef int png_int_32; -#else -typedef unsigned long png_uint_32; -typedef long png_int_32; -#endif -typedef unsigned short png_uint_16; -typedef short png_int_16; -typedef unsigned char png_byte; - -#ifdef PNG_NO_SIZE_T -typedef unsigned int png_size_t; -#else -typedef size_t png_size_t; -#endif -#define png_sizeof(x) (sizeof (x)) - -/* The following is needed for medium model support. It cannot be in the - * pngpriv.h header. Needs modification for other compilers besides - * MSC. Model independent support declares all arrays and pointers to be - * large using the far keyword. The zlib version used must also support - * model independent data. As of version zlib 1.0.4, the necessary changes - * have been made in zlib. The USE_FAR_KEYWORD define triggers other - * changes that are needed. (Tim Wegner) - */ - -/* Separate compiler dependencies (problem here is that zlib.h always - * defines FAR. (SJT) - */ -#ifdef __BORLANDC__ -# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) -# define LDATA 1 -# else -# define LDATA 0 -# endif - /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ -# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) -# define PNG_MAX_MALLOC_64K /* only used in build */ -# if (LDATA != 1) -# ifndef FAR -# define FAR __far -# endif -# define USE_FAR_KEYWORD -# endif /* LDATA != 1 */ - /* Possibly useful for moving data out of default segment. - * Uncomment it if you want. Could also define FARDATA as - * const if your compiler supports it. (SJT) -# define FARDATA FAR - */ -# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ -#endif /* __BORLANDC__ */ - - -/* Suggest testing for specific compiler first before testing for - * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, - * making reliance oncertain keywords suspect. (SJT) - */ - -/* MSC Medium model */ -#ifdef FAR -# ifdef M_I86MM -# define USE_FAR_KEYWORD -# define FARDATA FAR -# include -# endif -#endif - -/* SJT: default case */ -#ifndef FAR -# define FAR -#endif - -/* At this point FAR is always defined */ -#ifndef FARDATA -# define FARDATA -#endif - -/* Typedef for floating-point numbers that are converted - * to fixed-point with a multiple of 100,000, e.g., gamma - */ -typedef png_int_32 png_fixed_point; - -/* Add typedefs for pointers */ -typedef void FAR * png_voidp; -typedef PNG_CONST void FAR * png_const_voidp; -typedef png_byte FAR * png_bytep; -typedef PNG_CONST png_byte FAR * png_const_bytep; -typedef png_uint_32 FAR * png_uint_32p; -typedef PNG_CONST png_uint_32 FAR * png_const_uint_32p; -typedef png_int_32 FAR * png_int_32p; -typedef PNG_CONST png_int_32 FAR * png_const_int_32p; -typedef png_uint_16 FAR * png_uint_16p; -typedef PNG_CONST png_uint_16 FAR * png_const_uint_16p; -typedef png_int_16 FAR * png_int_16p; -typedef PNG_CONST png_int_16 FAR * png_const_int_16p; -typedef char FAR * png_charp; -typedef PNG_CONST char FAR * png_const_charp; -typedef png_fixed_point FAR * png_fixed_point_p; -typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p; -typedef png_size_t FAR * png_size_tp; -typedef PNG_CONST png_size_t FAR * png_const_size_tp; - -#ifdef PNG_STDIO_SUPPORTED -typedef FILE * png_FILE_p; -#endif - -#ifdef PNG_FLOATING_POINT_SUPPORTED -typedef double FAR * png_doublep; -typedef PNG_CONST double FAR * png_const_doublep; -#endif - -/* Pointers to pointers; i.e. arrays */ -typedef png_byte FAR * FAR * png_bytepp; -typedef png_uint_32 FAR * FAR * png_uint_32pp; -typedef png_int_32 FAR * FAR * png_int_32pp; -typedef png_uint_16 FAR * FAR * png_uint_16pp; -typedef png_int_16 FAR * FAR * png_int_16pp; -typedef PNG_CONST char FAR * FAR * png_const_charpp; -typedef char FAR * FAR * png_charpp; -typedef png_fixed_point FAR * FAR * png_fixed_point_pp; -#ifdef PNG_FLOATING_POINT_SUPPORTED -typedef double FAR * FAR * png_doublepp; -#endif - -/* Pointers to pointers to pointers; i.e., pointer to array */ -typedef char FAR * FAR * FAR * png_charppp; - -/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, - * and no smaller than png_uint_32. Casts from png_size_t or png_uint_32 - * to png_alloc_size_t are not necessary; in fact, it is recommended - * not to use them at all so that the compiler can complain when something - * turns out to be problematic. - * Casts in the other direction (from png_alloc_size_t to png_size_t or - * png_uint_32) should be explicitly applied; however, we do not expect - * to encounter practical situations that require such conversions. - */ -#if defined(__TURBOC__) && !defined(__FLAT__) - typedef unsigned long png_alloc_size_t; -#else -# if defined(_MSC_VER) && defined(MAXSEG_64K) - typedef unsigned long png_alloc_size_t; -# else - /* This is an attempt to detect an old Windows system where (int) is - * actually 16 bits, in that case png_malloc must have an argument with a - * bigger size to accomodate the requirements of the library. - */ -# if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \ - (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL) - typedef DWORD png_alloc_size_t; -# else - typedef png_size_t png_alloc_size_t; -# endif -# endif -#endif - -#endif /* PNGCONF_H */ diff --git a/include/pngdebug.h b/include/pngdebug.h deleted file mode 100644 index 96c1ea4..0000000 --- a/include/pngdebug.h +++ /dev/null @@ -1,157 +0,0 @@ - -/* pngdebug.h - Debugging macros for libpng, also used in pngtest.c - * - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * Last changed in libpng 1.5.0 [January 6, 2011] - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -/* Define PNG_DEBUG at compile time for debugging information. Higher - * numbers for PNG_DEBUG mean more debugging information. This has - * only been added since version 0.95 so it is not implemented throughout - * libpng yet, but more support will be added as needed. - * - * png_debug[1-2]?(level, message ,arg{0-2}) - * Expands to a statement (either a simple expression or a compound - * do..while(0) statement) that outputs a message with parameter - * substitution if PNG_DEBUG is defined to 2 or more. If PNG_DEBUG - * is undefined, 0 or 1 every png_debug expands to a simple expression - * (actually ((void)0)). - * - * level: level of detail of message, starting at 0. A level 'n' - * message is preceded by 'n' tab characters (not implemented - * on Microsoft compilers unless PNG_DEBUG_FILE is also - * defined, to allow debug DLL compilation with no standard IO). - * message: a printf(3) style text string. A trailing '\n' is added - * to the message. - * arg: 0 to 2 arguments for printf(3) style substitution in message. - */ -#ifndef PNGDEBUG_H -#define PNGDEBUG_H -/* These settings control the formatting of messages in png.c and pngerror.c */ -/* Moved to pngdebug.h at 1.5.0 */ -# ifndef PNG_LITERAL_SHARP -# define PNG_LITERAL_SHARP 0x23 -# endif -# ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET -# define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b -# endif -# ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET -# define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d -# endif -# ifndef PNG_STRING_NEWLINE -# define PNG_STRING_NEWLINE "\n" -# endif - -#ifdef PNG_DEBUG -# if (PNG_DEBUG > 0) -# if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) -# include -# if (PNG_DEBUG > 1) -# ifndef _DEBUG -# define _DEBUG -# endif -# ifndef png_debug -# define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE) -# endif -# ifndef png_debug1 -# define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1) -# endif -# ifndef png_debug2 -# define png_debug2(l,m,p1,p2) \ - _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2) -# endif -# endif -# else /* PNG_DEBUG_FILE || !_MSC_VER */ -# ifndef PNG_STDIO_SUPPORTED -# include /* not included yet */ -# endif -# ifndef PNG_DEBUG_FILE -# define PNG_DEBUG_FILE stderr -# endif /* PNG_DEBUG_FILE */ - -# if (PNG_DEBUG > 1) -/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on - * non-ISO compilers - */ -# ifdef __STDC__ -# ifndef png_debug -# define png_debug(l,m) \ - do { \ - int num_tabs=l; \ - fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ - } while (0) -# endif -# ifndef png_debug1 -# define png_debug1(l,m,p1) \ - do { \ - int num_tabs=l; \ - fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ - } while (0) -# endif -# ifndef png_debug2 -# define png_debug2(l,m,p1,p2) \ - do { \ - int num_tabs=l; \ - fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ - } while (0) -# endif -# else /* __STDC __ */ -# ifndef png_debug -# define png_debug(l,m) \ - do { \ - int num_tabs=l; \ - char format[256]; \ - snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ - m,PNG_STRING_NEWLINE); \ - fprintf(PNG_DEBUG_FILE,format); \ - } while (0) -# endif -# ifndef png_debug1 -# define png_debug1(l,m,p1) \ - do { \ - int num_tabs=l; \ - char format[256]; \ - snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ - m,PNG_STRING_NEWLINE); \ - fprintf(PNG_DEBUG_FILE,format,p1); \ - } while (0) -# endif -# ifndef png_debug2 -# define png_debug2(l,m,p1,p2) \ - do { \ - int num_tabs=l; \ - char format[256]; \ - snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ - m,PNG_STRING_NEWLINE); \ - fprintf(PNG_DEBUG_FILE,format,p1,p2); \ - } while (0) -# endif -# endif /* __STDC __ */ -# endif /* (PNG_DEBUG > 1) */ - -# endif /* _MSC_VER */ -# endif /* (PNG_DEBUG > 0) */ -#endif /* PNG_DEBUG */ -#ifndef png_debug -# define png_debug(l, m) ((void)0) -#endif -#ifndef png_debug1 -# define png_debug1(l, m, p1) ((void)0) -#endif -#ifndef png_debug2 -# define png_debug2(l, m, p1, p2) ((void)0) -#endif -#endif /* PNGDEBUG_H */ diff --git a/include/pnginfo.h b/include/pnginfo.h deleted file mode 100644 index bbfb105..0000000 --- a/include/pnginfo.h +++ /dev/null @@ -1,269 +0,0 @@ - -/* pnginfo.h - header file for PNG reference library - * - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * Last changed in libpng 1.5.0 [January 6, 2011] - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - - /* png_info is a structure that holds the information in a PNG file so - * that the application can find out the characteristics of the image. - * If you are reading the file, this structure will tell you what is - * in the PNG file. If you are writing the file, fill in the information - * you want to put into the PNG file, using png_set_*() functions, then - * call png_write_info(). - * - * The names chosen should be very close to the PNG specification, so - * consult that document for information about the meaning of each field. - * - * With libpng < 0.95, it was only possible to directly set and read the - * the values in the png_info_struct, which meant that the contents and - * order of the values had to remain fixed. With libpng 0.95 and later, - * however, there are now functions that abstract the contents of - * png_info_struct from the application, so this makes it easier to use - * libpng with dynamic libraries, and even makes it possible to use - * libraries that don't have all of the libpng ancillary chunk-handing - * functionality. In libpng-1.5.0 this was moved into a separate private - * file that is not visible to applications. - * - * The following members may have allocated storage attached that should be - * cleaned up before the structure is discarded: palette, trans, text, - * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, - * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these - * are automatically freed when the info structure is deallocated, if they were - * allocated internally by libpng. This behavior can be changed by means - * of the png_data_freer() function. - * - * More allocation details: all the chunk-reading functions that - * change these members go through the corresponding png_set_* - * functions. A function to clear these members is available: see - * png_free_data(). The png_set_* functions do not depend on being - * able to point info structure members to any of the storage they are - * passed (they make their own copies), EXCEPT that the png_set_text - * functions use the same storage passed to them in the text_ptr or - * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns - * functions do not make their own copies. - */ -#ifndef PNGINFO_H -#define PNGINFO_H - -struct png_info_def -{ - /* the following are necessary for every PNG file */ - png_uint_32 width; /* width of image in pixels (from IHDR) */ - png_uint_32 height; /* height of image in pixels (from IHDR) */ - png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ - png_size_t rowbytes; /* bytes needed to hold an untransformed row */ - png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ - png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ - png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ - png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ - png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ - /* The following three should have been named *_method not *_type */ - png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ - png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ - png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ - - /* The following is informational only on read, and not used on writes. */ - png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ - png_byte pixel_depth; /* number of bits per pixel */ - png_byte spare_byte; /* to align the data, and for future use */ - png_byte signature[8]; /* magic bytes read by libpng from start of file */ - - /* The rest of the data is optional. If you are reading, check the - * valid field to see if the information in these are valid. If you - * are writing, set the valid field to those chunks you want written, - * and initialize the appropriate fields below. - */ - -#if defined(PNG_gAMA_SUPPORTED) - /* The gAMA chunk describes the gamma characteristics of the system - * on which the image was created, normally in the range [1.0, 2.5]. - * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. - */ - png_fixed_point gamma; -#endif - -#ifdef PNG_sRGB_SUPPORTED - /* GR-P, 0.96a */ - /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ - png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ -#endif - -#ifdef PNG_TEXT_SUPPORTED - /* The tEXt, and zTXt chunks contain human-readable textual data in - * uncompressed, compressed, and optionally compressed forms, respectively. - * The data in "text" is an array of pointers to uncompressed, - * null-terminated C strings. Each chunk has a keyword that describes the - * textual data contained in that chunk. Keywords are not required to be - * unique, and the text string may be empty. Any number of text chunks may - * be in an image. - */ - int num_text; /* number of comments read or comments to write */ - int max_text; /* current size of text array */ - png_textp text; /* array of comments read or comments to write */ -#endif /* PNG_TEXT_SUPPORTED */ - -#ifdef PNG_tIME_SUPPORTED - /* The tIME chunk holds the last time the displayed image data was - * modified. See the png_time struct for the contents of this struct. - */ - png_time mod_time; -#endif - -#ifdef PNG_sBIT_SUPPORTED - /* The sBIT chunk specifies the number of significant high-order bits - * in the pixel data. Values are in the range [1, bit_depth], and are - * only specified for the channels in the pixel data. The contents of - * the low-order bits is not specified. Data is valid if - * (valid & PNG_INFO_sBIT) is non-zero. - */ - png_color_8 sig_bit; /* significant bits in color channels */ -#endif - -#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ -defined(PNG_READ_BACKGROUND_SUPPORTED) - /* The tRNS chunk supplies transparency data for paletted images and - * other image types that don't need a full alpha channel. There are - * "num_trans" transparency values for a paletted image, stored in the - * same order as the palette colors, starting from index 0. Values - * for the data are in the range [0, 255], ranging from fully transparent - * to fully opaque, respectively. For non-paletted images, there is a - * single color specified that should be treated as fully transparent. - * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. - */ - png_bytep trans_alpha; /* alpha values for paletted image */ - png_color_16 trans_color; /* transparent color for non-palette image */ -#endif - -#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - /* The bKGD chunk gives the suggested image background color if the - * display program does not have its own background color and the image - * is needs to composited onto a background before display. The colors - * in "background" are normally in the same color space/depth as the - * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. - */ - png_color_16 background; -#endif - -#ifdef PNG_oFFs_SUPPORTED - /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards - * and downwards from the top-left corner of the display, page, or other - * application-specific co-ordinate space. See the PNG_OFFSET_ defines - * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. - */ - png_int_32 x_offset; /* x offset on page */ - png_int_32 y_offset; /* y offset on page */ - png_byte offset_unit_type; /* offset units type */ -#endif - -#ifdef PNG_pHYs_SUPPORTED - /* The pHYs chunk gives the physical pixel density of the image for - * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ - * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. - */ - png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ - png_uint_32 y_pixels_per_unit; /* vertical pixel density */ - png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ -#endif - -#ifdef PNG_hIST_SUPPORTED - /* The hIST chunk contains the relative frequency or importance of the - * various palette entries, so that a viewer can intelligently select a - * reduced-color palette, if required. Data is an array of "num_palette" - * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) - * is non-zero. - */ - png_uint_16p hist; -#endif - -#ifdef PNG_cHRM_SUPPORTED - /* The cHRM chunk describes the CIE color characteristics of the monitor - * on which the PNG was created. This data allows the viewer to do gamut - * mapping of the input image to ensure that the viewer sees the same - * colors in the image as the creator. Values are in the range - * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. - */ - png_fixed_point x_white; - png_fixed_point y_white; - png_fixed_point x_red; - png_fixed_point y_red; - png_fixed_point x_green; - png_fixed_point y_green; - png_fixed_point x_blue; - png_fixed_point y_blue; -#endif - -#ifdef PNG_pCAL_SUPPORTED - /* The pCAL chunk describes a transformation between the stored pixel - * values and original physical data values used to create the image. - * The integer range [0, 2^bit_depth - 1] maps to the floating-point - * range given by [pcal_X0, pcal_X1], and are further transformed by a - * (possibly non-linear) transformation function given by "pcal_type" - * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ - * defines below, and the PNG-Group's PNG extensions document for a - * complete description of the transformations and how they should be - * implemented, and for a description of the ASCII parameter strings. - * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. - */ - png_charp pcal_purpose; /* pCAL chunk description string */ - png_int_32 pcal_X0; /* minimum value */ - png_int_32 pcal_X1; /* maximum value */ - png_charp pcal_units; /* Latin-1 string giving physical units */ - png_charpp pcal_params; /* ASCII strings containing parameter values */ - png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ - png_byte pcal_nparams; /* number of parameters given in pcal_params */ -#endif - -/* New members added in libpng-1.0.6 */ - png_uint_32 free_me; /* flags items libpng is responsible for freeing */ - -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ - defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) - /* Storage for unknown chunks that the library doesn't recognize. */ - png_unknown_chunkp unknown_chunks; - int unknown_chunks_num; -#endif - -#ifdef PNG_iCCP_SUPPORTED - /* iCCP chunk data. */ - png_charp iccp_name; /* profile name */ - png_bytep iccp_profile; /* International Color Consortium profile data */ - png_uint_32 iccp_proflen; /* ICC profile data length */ - png_byte iccp_compression; /* Always zero */ -#endif - -#ifdef PNG_sPLT_SUPPORTED - /* Data on sPLT chunks (there may be more than one). */ - png_sPLT_tp splt_palettes; - png_uint_32 splt_palettes_num; -#endif - -#ifdef PNG_sCAL_SUPPORTED - /* The sCAL chunk describes the actual physical dimensions of the - * subject matter of the graphic. The chunk contains a unit specification - * a byte value, and two ASCII strings representing floating-point - * values. The values are width and height corresponsing to one pixel - * in the image. Data values are valid if (valid & PNG_INFO_sCAL) is - * non-zero. - */ - png_byte scal_unit; /* unit of physical scale */ - png_charp scal_s_width; /* string containing height */ - png_charp scal_s_height; /* string containing width */ -#endif - -#ifdef PNG_INFO_IMAGE_SUPPORTED - /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) - non-zero */ - /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ - png_bytepp row_pointers; /* the image bits */ -#endif - -}; -#endif /* PNGINFO_H */ diff --git a/include/pnglibconf.h b/include/pnglibconf.h deleted file mode 100644 index 0a579f7..0000000 --- a/include/pnglibconf.h +++ /dev/null @@ -1,186 +0,0 @@ - -/* libpng STANDARD API DEFINITION */ - -/* pnglibconf.h - library build configuration */ - -/* Libpng 1.5.10 - March 29, 2012 */ - -/* Copyright (c) 1998-2012 Glenn Randers-Pehrson */ - -/* This code is released under the libpng license. */ -/* For conditions of distribution and use, see the disclaimer */ -/* and license in png.h */ - -/* pnglibconf.h */ -/* Derived from: scripts/pnglibconf.dfa */ -/* If you edit this file by hand you must obey the rules expressed in */ -/* pnglibconf.dfa with respect to the dependencies between the following */ -/* symbols. It is much better to generate a new file using */ -/* scripts/libpngconf.mak */ - -#ifndef PNGLCONF_H -#define PNGLCONF_H -/* settings */ -#define PNG_API_RULE 0 -#define PNG_CALLOC_SUPPORTED -#define PNG_COST_SHIFT 3 -#define PNG_DEFAULT_READ_MACROS 1 -#define PNG_GAMMA_THRESHOLD_FIXED 5000 -#define PNG_MAX_GAMMA_8 11 -#define PNG_QUANTIZE_BLUE_BITS 5 -#define PNG_QUANTIZE_GREEN_BITS 5 -#define PNG_QUANTIZE_RED_BITS 5 -#define PNG_sCAL_PRECISION 5 -#define PNG_WEIGHT_SHIFT 8 -#define PNG_ZBUF_SIZE 8192 -/* end of settings */ -/* options */ -#define PNG_16BIT_SUPPORTED -#define PNG_ALIGN_MEMORY_SUPPORTED -#define PNG_BENIGN_ERRORS_SUPPORTED -#define PNG_bKGD_SUPPORTED -#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED -#define PNG_CHECK_cHRM_SUPPORTED -#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED -#define PNG_cHRM_SUPPORTED -#define PNG_CONSOLE_IO_SUPPORTED -#define PNG_CONVERT_tIME_SUPPORTED -#define PNG_EASY_ACCESS_SUPPORTED -/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ -#define PNG_ERROR_TEXT_SUPPORTED -#define PNG_FIXED_POINT_SUPPORTED -#define PNG_FLOATING_ARITHMETIC_SUPPORTED -#define PNG_FLOATING_POINT_SUPPORTED -#define PNG_gAMA_SUPPORTED -#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED -#define PNG_hIST_SUPPORTED -#define PNG_iCCP_SUPPORTED -#define PNG_INCH_CONVERSIONS_SUPPORTED -#define PNG_INFO_IMAGE_SUPPORTED -#define PNG_IO_STATE_SUPPORTED -#define PNG_iTXt_SUPPORTED -#define PNG_MNG_FEATURES_SUPPORTED -#define PNG_oFFs_SUPPORTED -#define PNG_pCAL_SUPPORTED -#define PNG_pHYs_SUPPORTED -#define PNG_POINTER_INDEXING_SUPPORTED -#define PNG_PROGRESSIVE_READ_SUPPORTED -#define PNG_READ_16BIT_SUPPORTED -#define PNG_READ_ALPHA_MODE_SUPPORTED -#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED -#define PNG_READ_BACKGROUND_SUPPORTED -#define PNG_READ_BGR_SUPPORTED -#define PNG_READ_bKGD_SUPPORTED -#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED -#define PNG_READ_cHRM_SUPPORTED -#define PNG_READ_COMPOSITE_NODIV_SUPPORTED -#define PNG_READ_COMPRESSED_TEXT_SUPPORTED -#define PNG_READ_EXPAND_16_SUPPORTED -#define PNG_READ_EXPAND_SUPPORTED -#define PNG_READ_FILLER_SUPPORTED -#define PNG_READ_gAMA_SUPPORTED -#define PNG_READ_GAMMA_SUPPORTED -#define PNG_READ_GRAY_TO_RGB_SUPPORTED -#define PNG_READ_hIST_SUPPORTED -#define PNG_READ_iCCP_SUPPORTED -#define PNG_READ_INTERLACING_SUPPORTED -#define PNG_READ_INT_FUNCTIONS_SUPPORTED -#define PNG_READ_INVERT_ALPHA_SUPPORTED -#define PNG_READ_INVERT_SUPPORTED -#define PNG_READ_iTXt_SUPPORTED -#define PNG_READ_oFFs_SUPPORTED -#define PNG_READ_OPT_PLTE_SUPPORTED -#define PNG_READ_PACK_SUPPORTED -#define PNG_READ_PACKSWAP_SUPPORTED -#define PNG_READ_pCAL_SUPPORTED -#define PNG_READ_pHYs_SUPPORTED -#define PNG_READ_QUANTIZE_SUPPORTED -#define PNG_READ_RGB_TO_GRAY_SUPPORTED -#define PNG_READ_sBIT_SUPPORTED -#define PNG_READ_SCALE_16_TO_8_SUPPORTED -#define PNG_READ_sCAL_SUPPORTED -#define PNG_READ_SHIFT_SUPPORTED -#define PNG_READ_sPLT_SUPPORTED -#define PNG_READ_sRGB_SUPPORTED -#define PNG_READ_STRIP_16_TO_8_SUPPORTED -#define PNG_READ_STRIP_ALPHA_SUPPORTED -#define PNG_READ_SUPPORTED -#define PNG_READ_SWAP_ALPHA_SUPPORTED -#define PNG_READ_SWAP_SUPPORTED -#define PNG_READ_tEXt_SUPPORTED -#define PNG_READ_TEXT_SUPPORTED -#define PNG_READ_tIME_SUPPORTED -#define PNG_READ_TRANSFORMS_SUPPORTED -#define PNG_READ_tRNS_SUPPORTED -#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED -#define PNG_READ_USER_CHUNKS_SUPPORTED -#define PNG_READ_USER_TRANSFORM_SUPPORTED -#define PNG_READ_zTXt_SUPPORTED -#define PNG_SAVE_INT_32_SUPPORTED -#define PNG_sBIT_SUPPORTED -#define PNG_sCAL_SUPPORTED -#define PNG_SEQUENTIAL_READ_SUPPORTED -#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED -#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED -#define PNG_SETJMP_SUPPORTED -#define PNG_SET_USER_LIMITS_SUPPORTED -#define PNG_sPLT_SUPPORTED -#define PNG_sRGB_SUPPORTED -#define PNG_STDIO_SUPPORTED -#define PNG_tEXt_SUPPORTED -#define PNG_TEXT_SUPPORTED -#define PNG_TIME_RFC1123_SUPPORTED -#define PNG_tIME_SUPPORTED -#define PNG_tRNS_SUPPORTED -#define PNG_UNKNOWN_CHUNKS_SUPPORTED -#define PNG_USER_CHUNKS_SUPPORTED -#define PNG_USER_LIMITS_SUPPORTED -#define PNG_USER_MEM_SUPPORTED -#define PNG_USER_TRANSFORM_INFO_SUPPORTED -#define PNG_USER_TRANSFORM_PTR_SUPPORTED -#define PNG_WARNINGS_SUPPORTED -#define PNG_WRITE_16BIT_SUPPORTED -#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED -#define PNG_WRITE_BGR_SUPPORTED -#define PNG_WRITE_bKGD_SUPPORTED -#define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED -#define PNG_WRITE_cHRM_SUPPORTED -#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED -#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED -#define PNG_WRITE_FILLER_SUPPORTED -#define PNG_WRITE_FILTER_SUPPORTED -#define PNG_WRITE_FLUSH_SUPPORTED -#define PNG_WRITE_gAMA_SUPPORTED -#define PNG_WRITE_hIST_SUPPORTED -#define PNG_WRITE_iCCP_SUPPORTED -#define PNG_WRITE_INTERLACING_SUPPORTED -#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED -#define PNG_WRITE_INVERT_ALPHA_SUPPORTED -#define PNG_WRITE_INVERT_SUPPORTED -#define PNG_WRITE_iTXt_SUPPORTED -#define PNG_WRITE_oFFs_SUPPORTED -#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED -#define PNG_WRITE_PACK_SUPPORTED -#define PNG_WRITE_PACKSWAP_SUPPORTED -#define PNG_WRITE_pCAL_SUPPORTED -#define PNG_WRITE_pHYs_SUPPORTED -#define PNG_WRITE_sBIT_SUPPORTED -#define PNG_WRITE_sCAL_SUPPORTED -#define PNG_WRITE_SHIFT_SUPPORTED -#define PNG_WRITE_sPLT_SUPPORTED -#define PNG_WRITE_sRGB_SUPPORTED -#define PNG_WRITE_SUPPORTED -#define PNG_WRITE_SWAP_ALPHA_SUPPORTED -#define PNG_WRITE_SWAP_SUPPORTED -#define PNG_WRITE_tEXt_SUPPORTED -#define PNG_WRITE_TEXT_SUPPORTED -#define PNG_WRITE_tIME_SUPPORTED -#define PNG_WRITE_TRANSFORMS_SUPPORTED -#define PNG_WRITE_tRNS_SUPPORTED -#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED -#define PNG_WRITE_USER_TRANSFORM_SUPPORTED -#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED -#define PNG_WRITE_zTXt_SUPPORTED -#define PNG_zTXt_SUPPORTED -/* end of options */ -#endif /* PNGLCONF_H */ diff --git a/include/pngpriv.h b/include/pngpriv.h deleted file mode 100644 index c397d00..0000000 --- a/include/pngpriv.h +++ /dev/null @@ -1,1683 +0,0 @@ - -/* pngpriv.h - private declarations for use inside libpng - * - * For conditions of distribution and use, see copyright notice in png.h - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -* Copyright (C) 2013 Electronic Arts, Inc. All rights reserved. - * - * Last changed in libpng 1.5.10 [March 29, 2012] - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -/* The symbols declared in this file (including the functions declared - * as PNG_EXTERN) are PRIVATE. They are not part of the libpng public - * interface, and are not recommended for use by regular applications. - * Some of them may become public in the future; others may stay private, - * change in an incompatible way, or even disappear. - * Although the libpng users are not forbidden to include this header, - * they should be well aware of the issues that may arise from doing so. - */ - -#ifndef PNGPRIV_H -#define PNGPRIV_H - -/* Feature Test Macros. The following are defined here to ensure that correctly - * implemented libraries reveal the APIs libpng needs to build and hide those - * that are not needed and potentially damaging to the compilation. - * - * Feature Test Macros must be defined before any system header is included (see - * POSIX 1003.1 2.8.2 "POSIX Symbols." - * - * These macros only have an effect if the operating system supports either - * POSIX 1003.1 or C99, or both. On other operating systems (particularly - * Windows/Visual Studio) there is no effect; the OS specific tests below are - * still required (as of 2011-05-02.) - */ -#define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */ - -/* This is required for the definition of abort(), used as a last ditch - * error handler when all else fails. - */ -#include - -/* This is used to find 'offsetof', used below for alignment tests. */ -#include - -#define PNGLIB_BUILD /*libpng is being built, not used*/ - -#ifdef PNG_USER_CONFIG -# include "pngusr.h" - /* These should have been defined in pngusr.h */ -# ifndef PNG_USER_PRIVATEBUILD -# define PNG_USER_PRIVATEBUILD "Custom libpng build" -# endif -# ifndef PNG_USER_DLLFNAME_POSTFIX -# define PNG_USER_DLLFNAME_POSTFIX "Cb" -# endif -#endif - -/* Is this a build of a DLL where compilation of the object modules requires - * different preprocessor settings to those required for a simple library? If - * so PNG_BUILD_DLL must be set. - * - * If libpng is used inside a DLL but that DLL does not export the libpng APIs - * PNG_BUILD_DLL must not be set. To avoid the code below kicking in build a - * static library of libpng then link the DLL against that. - */ -#ifndef PNG_BUILD_DLL -# ifdef DLL_EXPORT - /* This is set by libtool when files are compiled for a DLL; libtool - * always compiles twice, even on systems where it isn't necessary. Set - * PNG_BUILD_DLL in case it is necessary: - */ -# define PNG_BUILD_DLL -# else -# if defined _WINDLL && !defined CS_UNDEFINED_STRING - /* This is set by the Microsoft Visual Studio IDE in projects that - * build a DLL. It can't easily be removed from those projects (it - * isn't visible in the Visual Studio UI) so it is a fairly reliable - * indication that PNG_IMPEXP needs to be set to the DLL export - * attributes. - */ -# define PNG_BUILD_DLL -# else -# ifdef __DLL__ - /* This is set by the Borland C system when compiling for a DLL - * (as above.) - */ -# define PNG_BUILD_DLL -# else - /* Add additional compiler cases here. */ -# endif -# endif -# endif -#endif /* Setting PNG_BUILD_DLL if required */ - -/* See pngconf.h for more details: the builder of the library may set this on - * the command line to the right thing for the specific compilation system or it - * may be automagically set above (at present we know of no system where it does - * need to be set on the command line.) - * - * PNG_IMPEXP must be set here when building the library to prevent pngconf.h - * setting it to the "import" setting for a DLL build. - */ -#ifndef PNG_IMPEXP -# ifdef PNG_BUILD_DLL -# define PNG_IMPEXP PNG_DLL_EXPORT -# else - /* Not building a DLL, or the DLL doesn't require specific export - * definitions. - */ -# define PNG_IMPEXP -# endif -#endif - -/* No warnings for private or deprecated functions in the build: */ -#ifndef PNG_DEPRECATED -# define PNG_DEPRECATED -#endif -#ifndef PNG_PRIVATE -# define PNG_PRIVATE -#endif - -#include "png.h" -#include "pnginfo.h" -#include "pngstruct.h" - -/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */ -#ifndef PNG_DLL_EXPORT -# define PNG_DLL_EXPORT -#endif - -/* SECURITY and SAFETY: - * - * By default libpng is built without any internal limits on image size, - * individual heap (png_malloc) allocations or the total amount of memory used. - * If PNG_SAFE_LIMITS_SUPPORTED is defined, however, the limits below are used - * (unless individually overridden). These limits are believed to be fairly - * safe, but builders of secure systems should verify the values against the - * real system capabilities. - */ - -#ifdef PNG_SAFE_LIMITS_SUPPORTED - /* 'safe' limits */ -# ifndef PNG_USER_WIDTH_MAX -# define PNG_USER_WIDTH_MAX 1000000 -# endif -# ifndef PNG_USER_HEIGHT_MAX -# define PNG_USER_HEIGHT_MAX 1000000 -# endif -# ifndef PNG_USER_CHUNK_CACHE_MAX -# define PNG_USER_CHUNK_CACHE_MAX 128 -# endif -# ifndef PNG_USER_CHUNK_MALLOC_MAX -# define PNG_USER_CHUNK_MALLOC_MAX 8000000 -# endif -#else - /* values for no limits */ -# ifndef PNG_USER_WIDTH_MAX -# define PNG_USER_WIDTH_MAX 0x7fffffff -# endif -# ifndef PNG_USER_HEIGHT_MAX -# define PNG_USER_HEIGHT_MAX 0x7fffffff -# endif -# ifndef PNG_USER_CHUNK_CACHE_MAX -# define PNG_USER_CHUNK_CACHE_MAX 0 -# endif -# ifndef PNG_USER_CHUNK_MALLOC_MAX -# define PNG_USER_CHUNK_MALLOC_MAX 0 -# endif -#endif - -/* This is used for 16 bit gamma tables - only the top level pointers are const, - * this could be changed: - */ -typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp; - -/* Added at libpng-1.2.9 */ -/* Moved to pngpriv.h at libpng-1.5.0 */ - -/* config.h is created by and PNG_CONFIGURE_LIBPNG is set by the "configure" - * script. We may need it here to get the correct configuration on things - * like limits. - */ -#ifdef PNG_CONFIGURE_LIBPNG -# ifdef HAVE_CONFIG_H -# include "config.h" -# endif -#endif - -/* Moved to pngpriv.h at libpng-1.5.0 */ -/* NOTE: some of these may have been used in external applications as - * these definitions were exposed in pngconf.h prior to 1.5. - */ - -/* If you are running on a machine where you cannot allocate more - * than 64K of memory at once, uncomment this. While libpng will not - * normally need that much memory in a chunk (unless you load up a very - * large file), zlib needs to know how big of a chunk it can use, and - * libpng thus makes sure to check any memory allocation to verify it - * will fit into memory. - * - * zlib provides 'MAXSEG_64K' which, if defined, indicates the - * same limit and pngconf.h (already included) sets the limit - * if certain operating systems are detected. - */ -#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) -# define PNG_MAX_MALLOC_64K -#endif - -#ifndef PNG_UNUSED -/* Unused formal parameter warnings are silenced using the following macro - * which is expected to have no bad effects on performance (optimizing - * compilers will probably remove it entirely). Note that if you replace - * it with something other than whitespace, you must include the terminating - * semicolon. - */ -# define PNG_UNUSED(param) (void)param; -#endif - -/* Just a little check that someone hasn't tried to define something - * contradictory. - */ -#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) -# undef PNG_ZBUF_SIZE -# define PNG_ZBUF_SIZE 65536L -#endif - -/* PNG_STATIC is used to mark internal file scope functions if they need to be - * accessed for implementation tests (see the code in tests/?*). - */ -#ifndef PNG_STATIC -# define PNG_STATIC static -#endif - -/* C99 restrict is used where possible, to do this 'restrict' is defined as - * empty if we can't be sure it is supported. configure builds have already - * done this work. - */ -#ifdef PNG_CONFIGURE_LIBPNG -# define PNG_RESTRICT restrict -#else - /* Modern compilers support restrict, but assume not for anything not - * recognized here: - */ -# if defined __GNUC__ || defined _MSC_VER || defined __WATCOMC__ -# define PNG_RESTRICT restrict -# else -# define PNG_RESTRICT -# endif -#endif - -/* If warnings or errors are turned off the code is disabled or redirected here. - * From 1.5.4 functions have been added to allow very limited formatting of - * error and warning messages - this code will also be disabled here. - */ -#ifdef PNG_WARNINGS_SUPPORTED -# define PNG_WARNING_PARAMETERS(p) png_warning_parameters p; -#else -# define png_warning(s1,s2) ((void)(s1)) -# define png_chunk_warning(s1,s2) ((void)(s1)) -# define png_warning_parameter(p,number,string) ((void)0) -# define png_warning_parameter_unsigned(p,number,format,value) ((void)0) -# define png_warning_parameter_signed(p,number,format,value) ((void)0) -# define png_formatted_warning(pp,p,message) ((void)(pp)) -# define PNG_WARNING_PARAMETERS(p) -#endif -#ifndef PNG_ERROR_TEXT_SUPPORTED -# define png_error(s1,s2) png_err(s1) -# define png_chunk_error(s1,s2) png_err(s1) -# define png_fixed_error(s1,s2) png_err(s1) -#endif - -/* C allows up-casts from (void*) to any pointer and (const void*) to any - * pointer to a const object. C++ regards this as a type error and requires an - * explicit, static, cast and provides the static_cast<> rune to ensure that - * const is not cast away. - */ -#ifdef __cplusplus -# define png_voidcast(type, value) static_cast(value) -#else -# define png_voidcast(type, value) (value) -#endif /* __cplusplus */ - -#ifndef PNG_EXTERN -/* The functions exported by PNG_EXTERN are internal functions, which - * aren't usually used outside the library (as far as I know), so it is - * debatable if they should be exported at all. In the future, when it - * is possible to have run-time registry of chunk-handling functions, - * some of these might be made available again. - * - * 1.5.7: turned the use of 'extern' back on, since it is localized to pngpriv.h - * it should be safe now (it is unclear why it was turned off.) - */ -# define PNG_EXTERN extern -#endif - -/* Some fixed point APIs are still required even if not exported because - * they get used by the corresponding floating point APIs. This magic - * deals with this: - */ -#ifdef PNG_FIXED_POINT_SUPPORTED -# define PNGFAPI PNGAPI -#else -# define PNGFAPI /* PRIVATE */ -#endif - -/* Other defines specific to compilers can go here. Try to keep - * them inside an appropriate ifdef/endif pair for portability. - */ -#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\ - defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) - /* png.c requires the following ANSI-C constants if the conversion of - * floating point to ASCII is implemented therein: - * - * DBL_DIG Maximum number of decimal digits (can be set to any constant) - * DBL_MIN Smallest normalized fp number (can be set to an arbitrary value) - * DBL_MAX Maximum floating point number (can be set to an arbitrary value) - */ -# include - -# if (defined(CS_UNDEFINED_STRING) && defined(macintosh)) || defined(applec) || \ - defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) - /* We need to check that hasn't already been included earlier - * as it seems it doesn't agree with , yet we should really use - * if possible. - */ -# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) -# if !defined(TARGET_OS_IPHONE) && !defined(TARGET_IPHONE_SIMULATOR) && !defined(TARGET_OS_IPAD) && !defined(TARGET_IPAD_SIMULATOR) -# include -# endif -# endif -# else -# include -# endif -# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) - /* Amiga SAS/C: We must include builtin FPU functions when compiling using - * MATH=68881 - */ -# include -# endif -#endif - -/* This provides the non-ANSI (far) memory allocation routines. */ -#if defined(__TURBOC__) && defined(__MSDOS__) -# include -# include -#endif - -#if (defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \ - defined(_WIN32) || defined(__WIN32__)) && !defined(CS_UNDEFINED_STRING) -# include /* defines _WINDOWS_ macro */ -#endif - -/* Moved here around 1.5.0beta36 from pngconf.h */ -/* Users may want to use these so they are not private. Any library - * functions that are passed far data must be model-independent. - */ - -/* Memory model/platform independent fns */ -#ifndef PNG_ABORT -# ifdef _WINDOWS_ -# define PNG_ABORT() ExitProcess(0) -# else -# define PNG_ABORT() abort() -# endif -#endif - -#ifdef USE_FAR_KEYWORD -/* Use this to make far-to-near assignments */ -# define CHECK 1 -# define NOCHECK 0 -# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) -# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) -# define png_strlen _fstrlen -# define png_memcmp _fmemcmp /* SJT: added */ -# define png_memcpy _fmemcpy -# define png_memset _fmemset -#else -//+EAWebKitChange - Compile fix for some platforms. -//1/16/13 -# if 0 /*#ifdef _WINDOWS_ */ /* Favor Windows over C runtime fns */ -//-EAWebKitChange -# define CVT_PTR(ptr) (ptr) -# define CVT_PTR_NOCHECK(ptr) (ptr) -# define png_strlen lstrlenA -# define png_memcmp memcmp -# define png_memcpy CopyMemory -# define png_memset memset -# else -# define CVT_PTR(ptr) (ptr) -# define CVT_PTR_NOCHECK(ptr) (ptr) -# define png_strlen strlen -# define png_memcmp memcmp /* SJT: added */ -# define png_memcpy memcpy -# define png_memset memset -# endif -#endif - -/* These macros may need to be architecture dependent. */ -#define PNG_ALIGN_NONE 0 /* do not use data alignment */ -#define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */ -#ifdef offsetof -# define PNG_ALIGN_OFFSET 2 /* use offsetof to determine alignment */ -#else -# define PNG_ALIGN_OFFSET -1 /* prevent the use of this */ -#endif -#define PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */ - -#ifndef PNG_ALIGN_TYPE - /* Default to using aligned access optimizations and requiring alignment to a - * multiple of the data type size. Override in a compiler specific fashion - * if necessary by inserting tests here: - */ -# define PNG_ALIGN_TYPE PNG_ALIGN_SIZE -#endif - -#if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE - /* This is used because in some compiler implementations non-aligned - * structure members are supported, so the offsetof approach below fails. - * Set PNG_ALIGN_TO_SIZE=0 for compiler combinations where unaligned access - * is good for performance. Do not do this unless you have tested the result - * and understand it. - */ -# define png_alignof(type) (sizeof (type)) -#else -# if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET -# define png_alignof(type) offsetof(struct{char c; type t;}, t) -# else -# if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS -# define png_alignof(type) (1) -# endif - /* Else leave png_alignof undefined to prevent use thereof */ -# endif -#endif - -/* This implicitly assumes alignment is always to a power of 2. */ -#ifdef png_alignof -# define png_isaligned(ptr, type)\ - ((((const char*)ptr-(const char*)0) & (png_alignof(type)-1)) == 0) -#else -# define png_isaligned(ptr, type) 0 -#endif - -/* End of memory model/platform independent support */ -/* End of 1.5.0beta36 move from pngconf.h */ - -/* CONSTANTS and UTILITY MACROS - * These are used internally by libpng and not exposed in the API - */ - -/* Various modes of operation. Note that after an init, mode is set to - * zero automatically when the structure is created. Three of these - * are defined in png.h because they need to be visible to applications - * that call png_set_unknown_chunk(). - */ -/* #define PNG_HAVE_IHDR 0x01 (defined in png.h) */ -/* #define PNG_HAVE_PLTE 0x02 (defined in png.h) */ -#define PNG_HAVE_IDAT 0x04 -/* #define PNG_AFTER_IDAT 0x08 (defined in png.h) */ -#define PNG_HAVE_IEND 0x10 -#define PNG_HAVE_gAMA 0x20 -#define PNG_HAVE_cHRM 0x40 -#define PNG_HAVE_sRGB 0x80 -#define PNG_HAVE_CHUNK_HEADER 0x100 -#define PNG_WROTE_tIME 0x200 -#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 -#define PNG_BACKGROUND_IS_GRAY 0x800 -#define PNG_HAVE_PNG_SIGNATURE 0x1000 -#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ -#define PNG_HAVE_iCCP 0x4000 - -/* Flags for the transformations the PNG library does on the image data */ -#define PNG_BGR 0x0001 -#define PNG_INTERLACE 0x0002 -#define PNG_PACK 0x0004 -#define PNG_SHIFT 0x0008 -#define PNG_SWAP_BYTES 0x0010 -#define PNG_INVERT_MONO 0x0020 -#define PNG_QUANTIZE 0x0040 -#define PNG_COMPOSE 0x0080 /* Was PNG_BACKGROUND */ -#define PNG_BACKGROUND_EXPAND 0x0100 -#define PNG_EXPAND_16 0x0200 /* Added to libpng 1.5.2 */ -#define PNG_16_TO_8 0x0400 /* Becomes 'chop' in 1.5.4 */ -#define PNG_RGBA 0x0800 -#define PNG_EXPAND 0x1000 -#define PNG_GAMMA 0x2000 -#define PNG_GRAY_TO_RGB 0x4000 -#define PNG_FILLER 0x8000 -#define PNG_PACKSWAP 0x10000 -#define PNG_SWAP_ALPHA 0x20000 -#define PNG_STRIP_ALPHA 0x40000 -#define PNG_INVERT_ALPHA 0x80000 -#define PNG_USER_TRANSFORM 0x100000 -#define PNG_RGB_TO_GRAY_ERR 0x200000 -#define PNG_RGB_TO_GRAY_WARN 0x400000 -#define PNG_RGB_TO_GRAY 0x600000 /* two bits, RGB_TO_GRAY_ERR|WARN */ -#define PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */ -#define PNG_ADD_ALPHA 0x1000000 /* Added to libpng-1.2.7 */ -#define PNG_EXPAND_tRNS 0x2000000 /* Added to libpng-1.2.9 */ -#define PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */ - /* 0x8000000 unused */ - /* 0x10000000 unused */ - /* 0x20000000 unused */ - /* 0x40000000 unused */ -/* Flags for png_create_struct */ -#define PNG_STRUCT_PNG 0x0001 -#define PNG_STRUCT_INFO 0x0002 - -/* Scaling factor for filter heuristic weighting calculations */ -#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) -#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) - -/* Flags for the png_ptr->flags rather than declaring a byte for each one */ -#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 -#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 -#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 -#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 -#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 -#define PNG_FLAG_ZLIB_FINISHED 0x0020 -#define PNG_FLAG_ROW_INIT 0x0040 -#define PNG_FLAG_FILLER_AFTER 0x0080 -#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 -#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 -#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 -#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 -#define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */ -#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */ -#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */ -#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000 -#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000 -#define PNG_FLAG_LIBRARY_MISMATCH 0x20000 -#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000 -#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000 -#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000 - /* 0x200000 unused */ - /* 0x400000 unused */ -#define PNG_FLAG_BENIGN_ERRORS_WARN 0x800000 /* Added to libpng-1.4.0 */ -#define PNG_FLAG_ZTXT_CUSTOM_STRATEGY 0x1000000 /* 5 lines added */ -#define PNG_FLAG_ZTXT_CUSTOM_LEVEL 0x2000000 /* to libpng-1.5.4 */ -#define PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL 0x4000000 -#define PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS 0x8000000 -#define PNG_FLAG_ZTXT_CUSTOM_METHOD 0x10000000 - /* 0x20000000 unused */ - /* 0x40000000 unused */ - -#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ - PNG_FLAG_CRC_ANCILLARY_NOWARN) - -#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ - PNG_FLAG_CRC_CRITICAL_IGNORE) - -#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ - PNG_FLAG_CRC_CRITICAL_MASK) - -/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib - * can handle at once. This type need be no larger than 16 bits (so maximum of - * 65535), this define allows us to discover how big it is, but limited by the - * maximuum for png_size_t. The value can be overriden in a library build - * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably - * lower value (e.g. 255 works). A lower value may help memory usage (slightly) - * and may even improve performance on some systems (and degrade it on others.) - */ -#ifndef ZLIB_IO_MAX -# define ZLIB_IO_MAX ((uInt)-1) -#endif - -/* Save typing and make code easier to understand */ - -#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ - abs((int)((c1).green) - (int)((c2).green)) + \ - abs((int)((c1).blue) - (int)((c2).blue))) - -/* Added to libpng-1.2.6 JB */ -#define PNG_ROWBYTES(pixel_bits, width) \ - ((pixel_bits) >= 8 ? \ - ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \ - (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) ) - -/* PNG_OUT_OF_RANGE returns true if value is outside the range - * ideal-delta..ideal+delta. Each argument is evaluated twice. - * "ideal" and "delta" should be constants, normally simple - * integers, "value" a variable. Added to libpng-1.2.6 JB - */ -#define PNG_OUT_OF_RANGE(value, ideal, delta) \ - ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) - -/* Conversions between fixed and floating point, only defined if - * required (to make sure the code doesn't accidentally use float - * when it is supposedly disabled.) - */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -/* The floating point conversion can't overflow, though it can and - * does lose accuracy relative to the original fixed point value. - * In practice this doesn't matter because png_fixed_point only - * stores numbers with very low precision. The png_ptr and s - * arguments are unused by default but are there in case error - * checking becomes a requirement. - */ -#define png_float(png_ptr, fixed, s) (.00001 * (fixed)) - -/* The fixed point conversion performs range checking and evaluates - * its argument multiple times, so must be used with care. The - * range checking uses the PNG specification values for a signed - * 32 bit fixed point value except that the values are deliberately - * rounded-to-zero to an integral value - 21474 (21474.83 is roughly - * (2^31-1) * 100000). 's' is a string that describes the value being - * converted. - * - * NOTE: this macro will raise a png_error if the range check fails, - * therefore it is normally only appropriate to use this on values - * that come from API calls or other sources where an out of range - * error indicates a programming error, not a data error! - * - * NOTE: by default this is off - the macro is not used - because the - * function call saves a lot of code. - */ -#ifdef PNG_FIXED_POINT_MACRO_SUPPORTED -#define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\ - ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0)) -#else -PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp, - png_const_charp text)); -#endif -#endif - -/* Constants for known chunk types. If you need to add a chunk, define the name - * here. For historical reasons these constants have the form png_; i.e. - * the prefix is lower case. Please use decimal values as the parameters to - * match the ISO PNG specification and to avoid relying on the C locale - * interpretation of character values. - * - * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values - * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string - * to be generated if required. - * - * PNG_32b correctly produces a value shifted by up to 24 bits, even on - * architectures where (int) is only 16 bits. - */ -#define PNG_32b(b,s) ((png_uint_32)(b) << (s)) -#define PNG_CHUNK(b1,b2,b3,b4) \ - (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0)) - -#define png_IHDR PNG_CHUNK( 73, 72, 68, 82) -#define png_IDAT PNG_CHUNK( 73, 68, 65, 84) -#define png_IEND PNG_CHUNK( 73, 69, 78, 68) -#define png_PLTE PNG_CHUNK( 80, 76, 84, 69) -#define png_bKGD PNG_CHUNK( 98, 75, 71, 68) -#define png_cHRM PNG_CHUNK( 99, 72, 82, 77) -#define png_gAMA PNG_CHUNK(103, 65, 77, 65) -#define png_hIST PNG_CHUNK(104, 73, 83, 84) -#define png_iCCP PNG_CHUNK(105, 67, 67, 80) -#define png_iTXt PNG_CHUNK(105, 84, 88, 116) -#define png_oFFs PNG_CHUNK(111, 70, 70, 115) -#define png_pCAL PNG_CHUNK(112, 67, 65, 76) -#define png_sCAL PNG_CHUNK(115, 67, 65, 76) -#define png_pHYs PNG_CHUNK(112, 72, 89, 115) -#define png_sBIT PNG_CHUNK(115, 66, 73, 84) -#define png_sPLT PNG_CHUNK(115, 80, 76, 84) -#define png_sRGB PNG_CHUNK(115, 82, 71, 66) -#define png_sTER PNG_CHUNK(115, 84, 69, 82) -#define png_tEXt PNG_CHUNK(116, 69, 88, 116) -#define png_tIME PNG_CHUNK(116, 73, 77, 69) -#define png_tRNS PNG_CHUNK(116, 82, 78, 83) -#define png_zTXt PNG_CHUNK(122, 84, 88, 116) - -/* The following will work on (signed char*) strings, whereas the get_uint_32 - * macro will fail on top-bit-set values because of the sign extension. - */ -#define PNG_CHUNK_FROM_STRING(s)\ - PNG_CHUNK(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3]) - -/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is - * signed and the argument is a (char[]) This macro will fail miserably on - * systems where (char) is more than 8 bits. - */ -#define PNG_STRING_FROM_CHUNK(s,c)\ - (void)(((char*)(s))[0]=(char)((c)>>24), ((char*)(s))[1]=(char)((c)>>16),\ - ((char*)(s))[2]=(char)((c)>>8), ((char*)(s))[3]=(char)((c))) - -/* Do the same but terminate with a null character. */ -#define PNG_CSTRING_FROM_CHUNK(s,c)\ - (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0) - -/* Test on flag values as defined in the spec (section 5.4): */ -#define PNG_CHUNK_ANCILLIARY(c) (1 & ((c) >> 29)) -#define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLIARY(c)) -#define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21)) -#define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13)) -#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5)) - -/* Gamma values (new at libpng-1.5.4): */ -#define PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */ -#define PNG_GAMMA_MAC_INVERSE 65909 -#define PNG_GAMMA_sRGB_INVERSE 45455 - - -/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/* These functions are used internally in the code. They generally - * shouldn't be used unless you are writing code to add or replace some - * functionality in libpng. More information about most functions can - * be found in the files where the functions are located. - */ - -/* Check the user version string for compatibility, returns false if the version - * numbers aren't compatible. - */ -PNG_EXTERN int png_user_version_check(png_structp png_ptr, - png_const_charp user_png_ver); - -/* Allocate memory for an internal libpng struct */ -PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct,PNGARG((int type)), - PNG_ALLOCATED); - -/* Free memory from internal libpng struct */ -PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); - -PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct_2, - PNGARG((int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)), - PNG_ALLOCATED); -PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, - png_free_ptr free_fn, png_voidp mem_ptr)); - -/* Free any memory that info_ptr points to and reset struct. */ -PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, - png_infop info_ptr)); - -/* Function to allocate memory for zlib. PNGAPI is disallowed. */ -PNG_EXTERN PNG_FUNCTION(voidpf,png_zalloc,PNGARG((voidpf png_ptr, uInt items, - uInt size)),PNG_ALLOCATED); - -/* Function to free memory for zlib. PNGAPI is disallowed. */ -PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); - -/* Next four functions are used internally as callbacks. PNGCBAPI is required - * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to - * PNGCBAPI at 1.5.0 - */ - -PNG_EXTERN void PNGCBAPI png_default_read_data PNGARG((png_structp png_ptr, - png_bytep data, png_size_t length)); - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -PNG_EXTERN void PNGCBAPI png_push_fill_buffer PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t length)); -#endif - -PNG_EXTERN void PNGCBAPI png_default_write_data PNGARG((png_structp png_ptr, - png_bytep data, png_size_t length)); - -#ifdef PNG_WRITE_FLUSH_SUPPORTED -# ifdef PNG_STDIO_SUPPORTED -PNG_EXTERN void PNGCBAPI png_default_flush PNGARG((png_structp png_ptr)); -# endif -#endif - -/* Reset the CRC variable */ -PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); - -/* Write the "data" buffer to whatever output you are using */ -PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, - png_const_bytep data, png_size_t length)); - -/* Read and check the PNG file signature */ -PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr)); - -/* Read the chunk header (length + type name) */ -PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr)); - -/* Read data from whatever input you are using into the "data" buffer */ -PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, - png_size_t length)); - -/* Read bytes into buf, and update png_ptr->crc */ -PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, - png_size_t length)); - -/* Decompress data in a chunk that uses compression */ -#if defined(PNG_READ_COMPRESSED_TEXT_SUPPORTED) -PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr, - int comp_type, png_size_t chunklength, png_size_t prefix_length, - png_size_t *data_length)); -#endif - -/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ -PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); - -/* Read the CRC from the file and compare it to the libpng calculated CRC */ -PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); - -/* Calculate the CRC over a section of data. Note that we are only - * passing a maximum of 64K on systems that have this as a memory limit, - * since this is the maximum buffer size we can specify. - */ -PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, - png_const_bytep ptr, png_size_t length)); - -#ifdef PNG_WRITE_FLUSH_SUPPORTED -PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); -#endif - -/* Write various chunks */ - -/* Write the IHDR chunk, and update the png_struct with the necessary - * information. - */ -PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, - png_uint_32 height, - int bit_depth, int color_type, int compression_method, int filter_method, - int interlace_method)); - -PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, - png_const_colorp palette, png_uint_32 num_pal)); - -PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, - png_size_t length)); - -PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); - -#ifdef PNG_WRITE_gAMA_SUPPORTED -# ifdef PNG_FLOATING_POINT_SUPPORTED -PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); -# endif -# ifdef PNG_FIXED_POINT_SUPPORTED -PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, - png_fixed_point file_gamma)); -# endif -#endif - -#ifdef PNG_WRITE_sBIT_SUPPORTED -PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, - png_const_color_8p sbit, int color_type)); -#endif - -#ifdef PNG_WRITE_cHRM_SUPPORTED -# ifdef PNG_FLOATING_POINT_SUPPORTED -PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, - double white_x, double white_y, - double red_x, double red_y, double green_x, double green_y, - double blue_x, double blue_y)); -# endif -PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, - png_fixed_point int_white_x, png_fixed_point int_white_y, - png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point - int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, - png_fixed_point int_blue_y)); -#endif - -#ifdef PNG_WRITE_sRGB_SUPPORTED -PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, - int intent)); -#endif - -#ifdef PNG_WRITE_iCCP_SUPPORTED -PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, - png_const_charp name, int compression_type, - png_const_charp profile, int proflen)); - /* Note to maintainer: profile should be png_bytep */ -#endif - -#ifdef PNG_WRITE_sPLT_SUPPORTED -PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, - png_const_sPLT_tp palette)); -#endif - -#ifdef PNG_WRITE_tRNS_SUPPORTED -PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, - png_const_bytep trans, png_const_color_16p values, int number, - int color_type)); -#endif - -#ifdef PNG_WRITE_bKGD_SUPPORTED -PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, - png_const_color_16p values, int color_type)); -#endif - -#ifdef PNG_WRITE_hIST_SUPPORTED -PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, - png_const_uint_16p hist, int num_hist)); -#endif - -/* Chunks that have keywords */ -#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ - defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) -PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, - png_const_charp key, png_charpp new_key)); -#endif - -#ifdef PNG_WRITE_tEXt_SUPPORTED -PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_const_charp key, - png_const_charp text, png_size_t text_len)); -#endif - -#ifdef PNG_WRITE_zTXt_SUPPORTED -PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_const_charp key, - png_const_charp text, png_size_t text_len, int compression)); -#endif - -#ifdef PNG_WRITE_iTXt_SUPPORTED -PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, - int compression, png_const_charp key, png_const_charp lang, - png_const_charp lang_key, png_const_charp text)); -#endif - -#ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */ -PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, - png_infop info_ptr, png_const_textp text_ptr, int num_text)); -#endif - -#ifdef PNG_WRITE_oFFs_SUPPORTED -PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, - png_int_32 x_offset, png_int_32 y_offset, int unit_type)); -#endif - -#ifdef PNG_WRITE_pCAL_SUPPORTED -PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, - png_int_32 X0, png_int_32 X1, int type, int nparams, - png_const_charp units, png_charpp params)); -#endif - -#ifdef PNG_WRITE_pHYs_SUPPORTED -PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, - png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, - int unit_type)); -#endif - -#ifdef PNG_WRITE_tIME_SUPPORTED -PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, - png_const_timep mod_time)); -#endif - -#ifdef PNG_WRITE_sCAL_SUPPORTED -PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, - int unit, png_const_charp width, png_const_charp height)); -#endif - -/* Called when finished processing a row of data */ -PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); - -/* Internal use only. Called before first row of data */ -PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); - -/* Combine a row of data, dealing with alpha, etc. if requested. 'row' is an - * array of png_ptr->width pixels. If the image is not interlaced or this - * is the final pass this just does a png_memcpy, otherwise the "display" flag - * is used to determine whether to copy pixels that are not in the current pass. - * - * Because 'png_do_read_interlace' (below) replicates pixels this allows this - * function to achieve the documented 'blocky' appearance during interlaced read - * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row' - * are not changed if they are not in the current pass, when display is 0. - * - * 'display' must be 0 or 1, otherwise the memcpy will be done regardless. - * - * The API always reads from the png_struct row buffer and always assumes that - * it is full width (png_do_read_interlace has already been called.) - * - * This function is only ever used to write to row buffers provided by the - * caller of the relevant libpng API and the row must have already been - * transformed by the read transformations. - * - * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed - * bitmasks for use within the code, otherwise runtime generated masks are used. - * The default is compile time masks. - */ -#ifndef PNG_USE_COMPILE_TIME_MASKS -# define PNG_USE_COMPILE_TIME_MASKS 1 -#endif -PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, - int display)); - -#ifdef PNG_READ_INTERLACING_SUPPORTED -/* Expand an interlaced row: the 'row_info' describes the pass data that has - * been read in and must correspond to the pixels in 'row', the pixels are - * expanded (moved apart) in 'row' to match the final layout, when doing this - * the pixels are *replicated* to the intervening space. This is essential for - * the correct operation of png_combine_row, above. - */ -PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, - png_bytep row, int pass, png_uint_32 transformations)); -#endif - -/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED -/* Grab pixels out of a row for an interlaced pass */ -PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, - png_bytep row, int pass)); -#endif - -/* Unfilter a row: check the filter value before calling this, there is no point - * calling it for PNG_FILTER_VALUE_NONE. - */ -PNG_EXTERN void png_read_filter_row PNGARG((png_structp pp, png_row_infop row_info, - png_bytep row, png_const_bytep prev_row, int filter)); - -PNG_EXTERN void png_read_filter_row_up_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); -PNG_EXTERN void png_read_filter_row_sub3_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); -PNG_EXTERN void png_read_filter_row_sub4_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); -PNG_EXTERN void png_read_filter_row_avg3_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); -PNG_EXTERN void png_read_filter_row_avg4_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); -PNG_EXTERN void png_read_filter_row_paeth3_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); -PNG_EXTERN void png_read_filter_row_paeth4_neon PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep prev_row)); - -/* Choose the best filter to use and filter the row data */ -PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, - png_row_infop row_info)); - -/* Finish a row while reading, dealing with interlacing passes, etc. */ -PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); - -/* Initialize the row buffers, etc. */ -PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED -/* Optional call to update the users info structure */ -PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, - png_infop info_ptr)); -#endif - -/* These are the functions that do the transformations */ -#ifdef PNG_READ_FILLER_SUPPORTED -PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, - png_bytep row, png_uint_32 filler, png_uint_32 flags)); -#endif - -#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED -PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED -PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED -PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED -PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ - defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -PNG_EXTERN void png_do_strip_channel PNGARG((png_row_infop row_info, - png_bytep row, int at_start)); -#endif - -#ifdef PNG_16BIT_SUPPORTED -#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) -PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, - png_bytep row)); -#endif -#endif - -#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ - defined(PNG_WRITE_PACKSWAP_SUPPORTED) -PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED -PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, - png_row_infop row_info, png_bytep row)); -#endif - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED -PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_PACK_SUPPORTED -PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_SHIFT_SUPPORTED -PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, - png_bytep row, png_const_color_8p sig_bits)); -#endif - -#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) -PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED -PNG_EXTERN void png_do_scale_16_to_8 PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED -PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED -PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info, - png_bytep row, png_const_bytep palette_lookup, - png_const_bytep quantize_lookup)); - -# ifdef PNG_CORRECT_PALETTE_SUPPORTED -PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, - png_colorp palette, int num_palette)); -# endif -#endif - -#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) -PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#ifdef PNG_WRITE_PACK_SUPPORTED -PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, - png_bytep row, png_uint_32 bit_depth)); -#endif - -#ifdef PNG_WRITE_SHIFT_SUPPORTED -PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, - png_bytep row, png_const_color_8p bit_depth)); -#endif - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) -PNG_EXTERN void png_do_compose PNGARG((png_row_infop row_info, - png_bytep row, png_structp png_ptr)); -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED -PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, - png_bytep row, png_structp png_ptr)); -#endif - -#ifdef PNG_READ_ALPHA_MODE_SUPPORTED -PNG_EXTERN void png_do_encode_alpha PNGARG((png_row_infop row_info, - png_bytep row, png_structp png_ptr)); -#endif - -#ifdef PNG_READ_EXPAND_SUPPORTED -PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, - png_bytep row, png_const_colorp palette, png_const_bytep trans, - int num_trans)); -PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, - png_bytep row, png_const_color_16p trans_color)); -#endif - -#ifdef PNG_READ_EXPAND_16_SUPPORTED -PNG_EXTERN void png_do_expand_16 PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -/* The following decodes the appropriate chunks, and does error correction, - * then calls the appropriate callback for the chunk if it is valid. - */ - -/* Decode the IHDR chunk */ -PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); - -#ifdef PNG_READ_bKGD_SUPPORTED -PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_cHRM_SUPPORTED -PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_gAMA_SUPPORTED -PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_hIST_SUPPORTED -PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_iCCP_SUPPORTED -PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif /* PNG_READ_iCCP_SUPPORTED */ - -#ifdef PNG_READ_iTXt_SUPPORTED -PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_oFFs_SUPPORTED -PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_pCAL_SUPPORTED -PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_pHYs_SUPPORTED -PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_sBIT_SUPPORTED -PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_sCAL_SUPPORTED -PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_sPLT_SUPPORTED -PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif /* PNG_READ_sPLT_SUPPORTED */ - -#ifdef PNG_READ_sRGB_SUPPORTED -PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_tEXt_SUPPORTED -PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_tIME_SUPPORTED -PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_tRNS_SUPPORTED -PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_READ_zTXt_SUPPORTED -PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -#endif - -PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, - png_uint_32 chunk_name)); - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -/* Exactly as png_handle_as_unknown() except that the argument is a 32-bit chunk - * name, not a string. - */ -PNG_EXTERN int png_chunk_unknown_handling PNGARG((png_structp png_ptr, - png_uint_32 chunk_name)); -#endif - -/* Handle the transformations for reading and writing */ -#ifdef PNG_READ_TRANSFORMS_SUPPORTED -PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr, - png_row_infop row_info)); -#endif -#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED -PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr, - png_row_infop row_info)); -#endif - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED -PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); -#endif - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, - png_uint_32 length)); -PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t buffer_length)); -PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t buffer_length)); -PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); -PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); -# ifdef PNG_READ_tEXt_SUPPORTED -PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, - png_infop info_ptr)); -# endif -# ifdef PNG_READ_zTXt_SUPPORTED -PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, - png_infop info_ptr)); -# endif -# ifdef PNG_READ_iTXt_SUPPORTED -PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, - png_infop info_ptr)); -# endif - -#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ - -#ifdef PNG_MNG_FEATURES_SUPPORTED -PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, - png_bytep row)); -PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -/* Added at libpng version 1.4.0 */ -#ifdef PNG_CHECK_cHRM_SUPPORTED -PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr, - png_fixed_point int_white_x, png_fixed_point int_white_y, - png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point - int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, - png_fixed_point int_blue_y)); -#endif - -#ifdef PNG_CHECK_cHRM_SUPPORTED -/* Added at libpng version 1.2.34 and 1.4.0 */ -/* Currently only used by png_check_cHRM_fixed */ -PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2, - unsigned long *hi_product, unsigned long *lo_product)); -#endif - -#ifdef PNG_cHRM_SUPPORTED -/* Added at libpng version 1.5.5 */ -typedef struct png_xy -{ - png_fixed_point redx, redy; - png_fixed_point greenx, greeny; - png_fixed_point bluex, bluey; - png_fixed_point whitex, whitey; -} png_xy; - -typedef struct png_XYZ -{ - png_fixed_point redX, redY, redZ; - png_fixed_point greenX, greenY, greenZ; - png_fixed_point blueX, blueY, blueZ; -} png_XYZ; - -/* The conversion APIs return 0 on success, non-zero on a parameter error. They - * allow conversion between the above representations of a color encoding. When - * converting from XYZ end points to chromaticities the absolute magnitude of - * the end points is lost, when converting back the sum of the Y values of the - * three end points will be 1.0 - */ -PNG_EXTERN int png_xy_from_XYZ PNGARG((png_xy *xy, png_XYZ XYZ)); -PNG_EXTERN int png_XYZ_from_xy PNGARG((png_XYZ *XYZ, png_xy xy)); -PNG_EXTERN int png_XYZ_from_xy_checked PNGARG((png_structp png_ptr, - png_XYZ *XYZ, png_xy xy)); -#endif - -/* Added at libpng version 1.4.0 */ -PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr, - png_uint_32 width, png_uint_32 height, int bit_depth, - int color_type, int interlace_type, int compression_type, - int filter_type)); - -/* Added at libpng version 1.5.10 */ -#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ - defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) -PNG_EXTERN void png_do_check_palette_indexes PNGARG((png_structp png_ptr, - png_row_infop row_info)); -#endif - -/* Free all memory used by the read (old method - NOT DLL EXPORTED) */ -PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr, - png_infop info_ptr, png_infop end_info_ptr)); - -/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ -PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr)); - -#ifdef USE_FAR_KEYWORD /* memory model conversion function */ -PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr, - int check)); -#endif /* USE_FAR_KEYWORD */ - -#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) -PNG_EXTERN PNG_FUNCTION(void, png_fixed_error, (png_structp png_ptr, - png_const_charp name),PNG_NORETURN); -#endif - -/* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite - * the end. Always leaves the buffer nul terminated. Never errors out (and - * there is no error code.) - */ -PNG_EXTERN size_t png_safecat(png_charp buffer, size_t bufsize, size_t pos, - png_const_charp string); - -/* Various internal functions to handle formatted warning messages, currently - * only implemented for warnings. - */ -#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED) -/* Utility to dump an unsigned value into a buffer, given a start pointer and - * and end pointer (which should point just *beyond* the end of the buffer!) - * Returns the pointer to the start of the formatted string. This utility only - * does unsigned values. - */ -PNG_EXTERN png_charp png_format_number(png_const_charp start, png_charp end, - int format, png_alloc_size_t number); - -/* Convenience macro that takes an array: */ -#define PNG_FORMAT_NUMBER(buffer,format,number) \ - png_format_number(buffer, buffer + (sizeof buffer), format, number) - -/* Suggested size for a number buffer (enough for 64 bits and a sign!) */ -#define PNG_NUMBER_BUFFER_SIZE 24 - -/* These are the integer formats currently supported, the name is formed from - * the standard printf(3) format string. - */ -#define PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */ -#define PNG_NUMBER_FORMAT_02u 2 -#define PNG_NUMBER_FORMAT_d 1 /* chose signed API! */ -#define PNG_NUMBER_FORMAT_02d 2 -#define PNG_NUMBER_FORMAT_x 3 -#define PNG_NUMBER_FORMAT_02x 4 -#define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */ -#endif - -#ifdef PNG_WARNINGS_SUPPORTED -/* New defines and members adding in libpng-1.5.4 */ -# define PNG_WARNING_PARAMETER_SIZE 32 -# define PNG_WARNING_PARAMETER_COUNT 8 - -/* An l-value of this type has to be passed to the APIs below to cache the - * values of the parameters to a formatted warning message. - */ -typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][ - PNG_WARNING_PARAMETER_SIZE]; - -PNG_EXTERN void png_warning_parameter(png_warning_parameters p, int number, - png_const_charp string); - /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters, - * including the trailing '\0'. - */ -PNG_EXTERN void png_warning_parameter_unsigned(png_warning_parameters p, - int number, int format, png_alloc_size_t value); - /* Use png_alloc_size_t because it is an unsigned type as big as any we - * need to output. Use the following for a signed value. - */ -PNG_EXTERN void png_warning_parameter_signed(png_warning_parameters p, - int number, int format, png_int_32 value); - -PNG_EXTERN void png_formatted_warning(png_structp png_ptr, - png_warning_parameters p, png_const_charp message); - /* 'message' follows the X/Open approach of using @1, @2 to insert - * parameters previously supplied using the above functions. Errors in - * specifying the paramters will simple result in garbage substitutions. - */ -#endif - -/* ASCII to FP interfaces, currently only implemented if sCAL - * support is required. - */ -#if defined(PNG_READ_sCAL_SUPPORTED) -/* MAX_DIGITS is actually the maximum number of characters in an sCAL - * width or height, derived from the precision (number of significant - * digits - a build time settable option) and assumpitions about the - * maximum ridiculous exponent. - */ -#define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/) - -#ifdef PNG_FLOATING_POINT_SUPPORTED -PNG_EXTERN void png_ascii_from_fp PNGARG((png_structp png_ptr, png_charp ascii, - png_size_t size, double fp, unsigned int precision)); -#endif /* FLOATING_POINT */ - -#ifdef PNG_FIXED_POINT_SUPPORTED -PNG_EXTERN void png_ascii_from_fixed PNGARG((png_structp png_ptr, - png_charp ascii, png_size_t size, png_fixed_point fp)); -#endif /* FIXED_POINT */ -#endif /* READ_sCAL */ - -#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) -/* An internal API to validate the format of a floating point number. - * The result is the index of the next character. If the number is - * not valid it will be the index of a character in the supposed number. - * - * The format of a number is defined in the PNG extensions specification - * and this API is strictly conformant to that spec, not anyone elses! - * - * The format as a regular expression is: - * - * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)? - * - * or: - * - * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)? - * - * The complexity is that either integer or fraction must be present and the - * fraction is permitted to have no digits only if the integer is present. - * - * NOTE: The dangling E problem. - * There is a PNG valid floating point number in the following: - * - * PNG floating point numb1.ers are not greedy. - * - * Working this out requires *TWO* character lookahead (because of the - * sign), the parser does not do this - it will fail at the 'r' - this - * doesn't matter for PNG sCAL chunk values, but it requires more care - * if the value were ever to be embedded in something more complex. Use - * ANSI-C strtod if you need the lookahead. - */ -/* State table for the parser. */ -#define PNG_FP_INTEGER 0 /* before or in integer */ -#define PNG_FP_FRACTION 1 /* before or in fraction */ -#define PNG_FP_EXPONENT 2 /* before or in exponent */ -#define PNG_FP_STATE 3 /* mask for the above */ -#define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */ -#define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */ -#define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */ -#define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */ -#define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */ - -/* These three values don't affect the parser. They are set but not used. - */ -#define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */ -#define PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */ -#define PNG_FP_NONZERO 256 /* A non-zero value */ -#define PNG_FP_STICKY 448 /* The above three flags */ - -/* This is available for the caller to store in 'state' if required. Do not - * call the parser after setting it (the parser sometimes clears it.) - */ -#define PNG_FP_INVALID 512 /* Available for callers as a distinct value */ - -/* Result codes for the parser (boolean - true meants ok, false means - * not ok yet.) - */ -#define PNG_FP_MAYBE 0 /* The number may be valid in the future */ -#define PNG_FP_OK 1 /* The number is valid */ - -/* Tests on the sticky non-zero and negative flags. To pass these checks - * the state must also indicate that the whole number is valid - this is - * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this - * is equivalent to PNG_FP_OK above.) - */ -#define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO) - /* NZ_MASK: the string is valid and a non-zero negative value */ -#define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO) - /* Z MASK: the string is valid and a non-zero value. */ - /* PNG_FP_SAW_DIGIT: the string is valid. */ -#define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT) -#define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK) -#define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK) - -/* The actual parser. This can be called repeatedly, it updates - * the index into the string and the state variable (which must - * be initialzed to 0). It returns a result code, as above. There - * is no point calling the parser any more if it fails to advance to - * the end of the string - it is stuck on an invalid character (or - * terminated by '\0'). - * - * Note that the pointer will consume an E or even an E+ then leave - * a 'maybe' state even though a preceding integer.fraction is valid. - * The PNG_FP_WAS_VALID flag indicates that a preceding substring was - * a valid number. It's possible to recover from this by calling - * the parser again (from the start, with state 0) but with a string - * that omits the last character (i.e. set the size to the index of - * the problem character.) This has not been tested within libpng. - */ -PNG_EXTERN int png_check_fp_number PNGARG((png_const_charp string, - png_size_t size, int *statep, png_size_tp whereami)); - -/* This is the same but it checks a complete string and returns true - * only if it just contains a floating point number. As of 1.5.4 this - * function also returns the state at the end of parsing the number if - * it was valid (otherwise it returns 0.) This can be used for testing - * for negative or zero values using the sticky flag. - */ -PNG_EXTERN int png_check_fp_string PNGARG((png_const_charp string, - png_size_t size)); -#endif /* pCAL || sCAL */ - -#if defined(PNG_READ_GAMMA_SUPPORTED) ||\ - defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED) -/* Added at libpng version 1.5.0 */ -/* This is a utility to provide a*times/div (rounded) and indicate - * if there is an overflow. The result is a boolean - false (0) - * for overflow, true (1) if no overflow, in which case *res - * holds the result. - */ -PNG_EXTERN int png_muldiv PNGARG((png_fixed_point_p res, png_fixed_point a, - png_int_32 multiplied_by, png_int_32 divided_by)); -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) -/* Same deal, but issue a warning on overflow and return 0. */ -PNG_EXTERN png_fixed_point png_muldiv_warn PNGARG((png_structp png_ptr, - png_fixed_point a, png_int_32 multiplied_by, png_int_32 divided_by)); -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED -/* Calculate a reciprocal - used for gamma values. This returns - * 0 if the argument is 0 in order to maintain an undefined value, - * there are no warnings. - */ -PNG_EXTERN png_fixed_point png_reciprocal PNGARG((png_fixed_point a)); - -/* The same but gives a reciprocal of the product of two fixed point - * values. Accuracy is suitable for gamma calculations but this is - * not exact - use png_muldiv for that. - */ -PNG_EXTERN png_fixed_point png_reciprocal2 PNGARG((png_fixed_point a, - png_fixed_point b)); -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED -/* Internal fixed point gamma correction. These APIs are called as - * required to convert single values - they don't need to be fast, - * they are not used when processing image pixel values. - * - * While the input is an 'unsigned' value it must actually be the - * correct bit value - 0..255 or 0..65535 as required. - */ -PNG_EXTERN png_uint_16 png_gamma_correct PNGARG((png_structp png_ptr, - unsigned int value, png_fixed_point gamma_value)); -PNG_EXTERN int png_gamma_significant PNGARG((png_fixed_point gamma_value)); -PNG_EXTERN png_uint_16 png_gamma_16bit_correct PNGARG((unsigned int value, - png_fixed_point gamma_value)); -PNG_EXTERN png_byte png_gamma_8bit_correct PNGARG((unsigned int value, - png_fixed_point gamma_value)); -PNG_EXTERN void png_destroy_gamma_table(png_structp png_ptr); -PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr, - int bit_depth)); -#endif - -/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ - -#include "pngdebug.h" - -#ifdef __cplusplus -} -#endif - -#endif /* PNGPRIV_H */ diff --git a/include/pngstruct.h b/include/pngstruct.h deleted file mode 100644 index e156ee5..0000000 --- a/include/pngstruct.h +++ /dev/null @@ -1,357 +0,0 @@ - -/* pngstruct.h - header file for PNG reference library - * - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * Last changed in libpng 1.5.9 [March 29, 2012] - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -/* The structure that holds the information to read and write PNG files. - * The only people who need to care about what is inside of this are the - * people who will be modifying the library for their own special needs. - * It should NOT be accessed directly by an application. - */ - -#ifndef PNGSTRUCT_H -#define PNGSTRUCT_H -/* zlib.h defines the structure z_stream, an instance of which is included - * in this structure and is required for decompressing the LZ compressed - * data in PNG files. - */ -#include - -struct png_struct_def -{ -#ifdef PNG_SETJMP_SUPPORTED - jmp_buf longjmp_buffer; /* used in png_error */ - png_longjmp_ptr longjmp_fn;/* setjmp non-local goto function. */ -#endif - png_error_ptr error_fn; /* function for printing errors and aborting */ -#ifdef PNG_WARNINGS_SUPPORTED - png_error_ptr warning_fn; /* function for printing warnings */ -#endif - png_voidp error_ptr; /* user supplied struct for error functions */ - png_rw_ptr write_data_fn; /* function for writing output data */ - png_rw_ptr read_data_fn; /* function for reading input data */ - png_voidp io_ptr; /* ptr to application struct for I/O functions */ - -#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED - png_user_transform_ptr read_user_transform_fn; /* user read transform */ -#endif - -#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED - png_user_transform_ptr write_user_transform_fn; /* user write transform */ -#endif - -/* These were added in libpng-1.0.2 */ -#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) - png_voidp user_transform_ptr; /* user supplied struct for user transform */ - png_byte user_transform_depth; /* bit depth of user transformed pixels */ - png_byte user_transform_channels; /* channels in user transformed pixels */ -#endif -#endif - - png_uint_32 mode; /* tells us where we are in the PNG file */ - png_uint_32 flags; /* flags indicating various things to libpng */ - png_uint_32 transformations; /* which transformations to perform */ - - z_stream zstream; /* pointer to decompression structure (below) */ - png_bytep zbuf; /* buffer for zlib */ - uInt zbuf_size; /* size of zbuf (typically 65536) */ -#ifdef PNG_WRITE_SUPPORTED - -/* Added in 1.5.4: state to keep track of whether the zstream has been - * initialized and if so whether it is for IDAT or some other chunk. - */ -#define PNG_ZLIB_UNINITIALIZED 0 -#define PNG_ZLIB_FOR_IDAT 1 -#define PNG_ZLIB_FOR_TEXT 2 /* anything other than IDAT */ -#define PNG_ZLIB_USE_MASK 3 /* bottom two bits */ -#define PNG_ZLIB_IN_USE 4 /* a flag value */ - - png_uint_32 zlib_state; /* State of zlib initialization */ -/* End of material added at libpng 1.5.4 */ - - int zlib_level; /* holds zlib compression level */ - int zlib_method; /* holds zlib compression method */ - int zlib_window_bits; /* holds zlib compression window bits */ - int zlib_mem_level; /* holds zlib compression memory level */ - int zlib_strategy; /* holds zlib compression strategy */ -#endif -/* Added at libpng 1.5.4 */ -#if defined(PNG_WRITE_COMPRESSED_TEXT_SUPPORTED) || \ - defined(PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED) - int zlib_text_level; /* holds zlib compression level */ - int zlib_text_method; /* holds zlib compression method */ - int zlib_text_window_bits; /* holds zlib compression window bits */ - int zlib_text_mem_level; /* holds zlib compression memory level */ - int zlib_text_strategy; /* holds zlib compression strategy */ -#endif -/* End of material added at libpng 1.5.4 */ - - png_uint_32 width; /* width of image in pixels */ - png_uint_32 height; /* height of image in pixels */ - png_uint_32 num_rows; /* number of rows in current pass */ - png_uint_32 usr_width; /* width of row at start of write */ - png_size_t rowbytes; /* size of row in bytes */ - png_uint_32 iwidth; /* width of current interlaced row in pixels */ - png_uint_32 row_number; /* current row in interlace pass */ - png_uint_32 chunk_name; /* PNG_CHUNK() id of current chunk */ - png_bytep prev_row; /* buffer to save previous (unfiltered) row. - * This is a pointer into big_prev_row - */ - png_bytep row_buf; /* buffer to save current (unfiltered) row. - * This is a pointer into big_row_buf - */ - png_bytep sub_row; /* buffer to save "sub" row when filtering */ - png_bytep up_row; /* buffer to save "up" row when filtering */ - png_bytep avg_row; /* buffer to save "avg" row when filtering */ - png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ - png_size_t info_rowbytes; /* Added in 1.5.4: cache of updated row bytes */ - - png_uint_32 idat_size; /* current IDAT size for read */ - png_uint_32 crc; /* current chunk CRC value */ - png_colorp palette; /* palette from the input file */ - png_uint_16 num_palette; /* number of color entries in palette */ - -/* Added at libpng-1.5.10 */ -#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED - int num_palette_max; /* maximum palette index found in IDAT */ -#endif - - png_uint_16 num_trans; /* number of transparency values */ - png_byte compression; /* file compression type (always 0) */ - png_byte filter; /* file filter type (always 0) */ - png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ - png_byte pass; /* current interlace pass (0 - 6) */ - png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ - png_byte color_type; /* color type of file */ - png_byte bit_depth; /* bit depth of file */ - png_byte usr_bit_depth; /* bit depth of users row: write only */ - png_byte pixel_depth; /* number of bits per pixel */ - png_byte channels; /* number of channels in file */ - png_byte usr_channels; /* channels at start of write: write only */ - png_byte sig_bytes; /* magic bytes read/written from start of file */ - png_byte maximum_pixel_depth; - /* pixel depth used for the row buffers */ - png_byte transformed_pixel_depth; - /* pixel depth after read/write transforms */ - png_byte io_chunk_string[5]; - /* string name of chunk */ - -#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) - png_uint_16 filler; /* filler bytes for pixel expansion */ -#endif - -#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) - png_byte background_gamma_type; - png_fixed_point background_gamma; - png_color_16 background; /* background color in screen gamma space */ -#ifdef PNG_READ_GAMMA_SUPPORTED - png_color_16 background_1; /* background normalized to gamma 1.0 */ -#endif -#endif /* PNG_bKGD_SUPPORTED */ - -#ifdef PNG_WRITE_FLUSH_SUPPORTED - png_flush_ptr output_flush_fn; /* Function for flushing output */ - png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ - png_uint_32 flush_rows; /* number of rows written since last flush */ -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED - int gamma_shift; /* number of "insignificant" bits in 16-bit gamma */ - png_fixed_point gamma; /* file gamma value */ - png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */ - - png_bytep gamma_table; /* gamma table for 8-bit depth files */ - png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ -#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ - defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) - png_bytep gamma_from_1; /* converts from 1.0 to screen */ - png_bytep gamma_to_1; /* converts from file to 1.0 */ - png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ - png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ -#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) - png_color_8 sig_bit; /* significant bits in each available channel */ -#endif - -#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) - png_color_8 shift; /* shift for significant bit tranformation */ -#endif - -#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ - || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - png_bytep trans_alpha; /* alpha values for paletted files */ - png_color_16 trans_color; /* transparent color for non-paletted files */ -#endif - - png_read_status_ptr read_row_fn; /* called after each row is decoded */ - png_write_status_ptr write_row_fn; /* called after each row is encoded */ -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED - png_progressive_info_ptr info_fn; /* called after header data fully read */ - png_progressive_row_ptr row_fn; /* called after a prog. row is decoded */ - png_progressive_end_ptr end_fn; /* called after image is complete */ - png_bytep save_buffer_ptr; /* current location in save_buffer */ - png_bytep save_buffer; /* buffer for previously read data */ - png_bytep current_buffer_ptr; /* current location in current_buffer */ - png_bytep current_buffer; /* buffer for recently used data */ - png_uint_32 push_length; /* size of current input chunk */ - png_uint_32 skip_length; /* bytes to skip in input data */ - png_size_t save_buffer_size; /* amount of data now in save_buffer */ - png_size_t save_buffer_max; /* total size of save_buffer */ - png_size_t buffer_size; /* total amount of available input data */ - png_size_t current_buffer_size; /* amount of data now in current_buffer */ - int process_mode; /* what push library is currently doing */ - int cur_palette; /* current push library palette index */ - -#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ - -#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) -/* For the Borland special 64K segment handler */ - png_bytepp offset_table_ptr; - png_bytep offset_table; - png_uint_16 offset_table_number; - png_uint_16 offset_table_count; - png_uint_16 offset_table_count_free; -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED - png_bytep palette_lookup; /* lookup table for quantizing */ - png_bytep quantize_index; /* index translation for palette files */ -#endif - -#if defined(PNG_READ_QUANTIZE_SUPPORTED) || defined(PNG_hIST_SUPPORTED) - png_uint_16p hist; /* histogram */ -#endif - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - png_byte heuristic_method; /* heuristic for row filter selection */ - png_byte num_prev_filters; /* number of weights for previous rows */ - png_bytep prev_filters; /* filter type(s) of previous row(s) */ - png_uint_16p filter_weights; /* weight(s) for previous line(s) */ - png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ - png_uint_16p filter_costs; /* relative filter calculation cost */ - png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ -#endif - -#ifdef PNG_TIME_RFC1123_SUPPORTED - char time_buffer[29]; /* String to hold RFC 1123 time text */ -#endif - -/* New members added in libpng-1.0.6 */ - - png_uint_32 free_me; /* flags items libpng is responsible for freeing */ - -#ifdef PNG_USER_CHUNKS_SUPPORTED - png_voidp user_chunk_ptr; - png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ -#endif - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - int num_chunk_list; - png_bytep chunk_list; -#endif - -#ifdef PNG_READ_sRGB_SUPPORTED - /* Added in 1.5.5 to record an sRGB chunk in the png. */ - png_byte is_sRGB; -#endif - -/* New members added in libpng-1.0.3 */ -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - png_byte rgb_to_gray_status; - /* Added in libpng 1.5.5 to record setting of coefficients: */ - png_byte rgb_to_gray_coefficients_set; - /* These were changed from png_byte in libpng-1.0.6 */ - png_uint_16 rgb_to_gray_red_coeff; - png_uint_16 rgb_to_gray_green_coeff; - /* deleted in 1.5.5: rgb_to_gray_blue_coeff; */ -#endif - -/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ -#if defined(PNG_MNG_FEATURES_SUPPORTED) -/* Changed from png_byte to png_uint_32 at version 1.2.0 */ - png_uint_32 mng_features_permitted; -#endif - -/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ -#ifdef PNG_MNG_FEATURES_SUPPORTED - png_byte filter_type; -#endif - -/* New members added in libpng-1.2.0 */ - -/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ -#ifdef PNG_USER_MEM_SUPPORTED - png_voidp mem_ptr; /* user supplied struct for mem functions */ - png_malloc_ptr malloc_fn; /* function for allocating memory */ - png_free_ptr free_fn; /* function for freeing memory */ -#endif - -/* New member added in libpng-1.0.13 and 1.2.0 */ - png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ - -#ifdef PNG_READ_QUANTIZE_SUPPORTED -/* The following three members were added at version 1.0.14 and 1.2.4 */ - png_bytep quantize_sort; /* working sort array */ - png_bytep index_to_palette; /* where the original index currently is - in the palette */ - png_bytep palette_to_index; /* which original index points to this - palette color */ -#endif - -/* New members added in libpng-1.0.16 and 1.2.6 */ - png_byte compression_type; - -#ifdef PNG_USER_LIMITS_SUPPORTED - png_uint_32 user_width_max; - png_uint_32 user_height_max; - - /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown - * chunks that can be stored (0 means unlimited). - */ - png_uint_32 user_chunk_cache_max; - - /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk - * can occupy when decompressed. 0 means unlimited. - */ - png_alloc_size_t user_chunk_malloc_max; -#endif - -/* New member added in libpng-1.0.25 and 1.2.17 */ -#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED - /* Storage for unknown chunk that the library doesn't recognize. */ - png_unknown_chunk unknown_chunk; -#endif - -/* New member added in libpng-1.2.26 */ - png_size_t old_big_row_buf_size; - -/* New member added in libpng-1.2.30 */ - png_charp chunkdata; /* buffer for reading chunk data */ - -#ifdef PNG_IO_STATE_SUPPORTED -/* New member added in libpng-1.4.0 */ - png_uint_32 io_state; -#endif - -/* New member added in libpng-1.5.6 */ - png_bytep big_prev_row; - - void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info, - png_bytep row, png_const_bytep prev_row); -}; -#endif /* PNGSTRUCT_H */ diff --git a/include/slist.h b/include/slist.h deleted file mode 100644 index 5755ca1..0000000 --- a/include/slist.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifndef _LIBNFS_SLIST_H_ -#define _LIBNFS_SLIST_H_ - -#define LIBNFS_LIST_ADD(list, item) \ - do { \ - (item)->next = (*list); \ - (*list) = (item); \ - } while (0); - -#define LIBNFS_LIST_ADD_END(list, item) \ - if ((*list) == NULL) { \ - LIBNFS_LIST_ADD((list), (item)); \ - } else { \ - void *head = (*list); \ - while ((*list)->next) \ - (*list) = (*list)->next; \ - (*list)->next = (item); \ - (item)->next = NULL; \ - (*list) = head; \ - } - -#define LIBNFS_LIST_REMOVE(list, item) \ - if ((*list) == (item)) { \ - (*list) = (item)->next; \ - } else { \ - void *head = (*list); \ - while ((*list)->next && (*list)->next != (item)) \ - (*list) = (*list)->next; \ - if ((*list)->next != NULL) { \ - (*list)->next = (*list)->next->next; \ - } \ - (*list) = head; \ - } - -#endif /* !_LIBNFS_SLIST_H_ */ diff --git a/include/sxmlc.h b/include/sxmlc.h deleted file mode 100755 index ef8d593..0000000 --- a/include/sxmlc.h +++ /dev/null @@ -1,1084 +0,0 @@ -/** - Copyright (c) 2010, Matthieu Labas - All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY - OF SUCH DAMAGE. - - The views and conclusions contained in the software and documentation are those of the - authors and should not be interpreted as representing official policies, either expressed - or implied, of the FreeBSD Project. -*/ -#ifndef _SXML_H_ -#define _SXML_H_ - -/** - * \def SXMLC_VERSION - * \brief Current SXMLC version, as a `const char[]`. - */ -#define SXMLC_VERSION "4.3.1" - -#ifdef __cplusplus -extern "C" { -#endif - -#include - -/** - * \brief Define this to compile unicode support. - */ -#ifdef SXMLC_UNICODE - typedef wchar_t SXML_CHAR; - #define C2SX(c) L ## c - #define CEOF WEOF - #define sx_strcmp wcscmp - #define sx_strncmp wcsncmp - #define sx_strlen wcslen - #define sx_strdup wcsdup - #define sx_strchr wcschr - #define sx_strrchr wcsrchr - #define sx_strcpy wcscpy - #define sx_strncpy wcsncpy - #define sx_strcat wcscat - #define sx_printf wprintf - #define sx_fprintf fwprintf - #define sx_sprintf swprintf - #define sx_fgetc fgetwc - #define sx_fputc fputwc - #define sx_puts putws - #define sx_fputs fputws - #define sx_isspace iswspace - #if defined(WIN32) || defined(WIN64) - #define sx_fopen _wfopen - #else - #define sx_fopen fopen - #endif - #define sx_fclose fclose - #define sx_feof feof -#else - typedef char SXML_CHAR; - #define C2SX(c) c - #define CEOF EOF - #define sx_strcmp strcmp - #define sx_strncmp strncmp - #define sx_strlen strlen - #define sx_strdup __sx_strdup - #define sx_strchr strchr - #define sx_strrchr strrchr - #define sx_strcpy strcpy - #define sx_strncpy strncpy - #define sx_strcat strcat - #define sx_printf printf - #define sx_fprintf fprintf - #define sx_sprintf sprintf - #define sx_fgetc fgetc - #define sx_fputc fputc - #define sx_puts puts - #define sx_fputs fputs - #define sx_isspace(ch) isspace((int)ch) - #define sx_fopen fopen - #define sx_fclose fclose - #define sx_feof feof -#endif - -#ifdef DBG_MEM - void* __malloc(size_t sz); - void* __calloc(size_t count, size_t sz); - void* __realloc(void* mem, size_t sz); - void __free(void* mem); - char* __sx_strdup(const char* s); -#else - #define __malloc malloc - #define __calloc calloc - #define __realloc realloc - #define __free free - #define __sx_strdup strdup -#endif - -/** - * \def MEM_INCR_RLA - * \brief The number of bytes to add to currently allocated buffer for line reading. Default to 256 characters (=512 - * bytes with unicode support). - */ -#ifndef MEM_INCR_RLA -#define MEM_INCR_RLA (256*sizeof(SXML_CHAR)) /* Initial buffer size and increment for memory reallocations */ -#endif - -#ifndef false -#define false 0 -#endif - -#ifndef true -#define true 1 -#endif - -#define NULC ((SXML_CHAR)C2SX('\0')) -#define isquote(c) (((c) == C2SX('"')) || ((c) == C2SX('\''))) - -/** - * \typedef DataSourceBuffer - * \brief Buffer data source used by 'read_line_alloc' when required. 'buf' should be 0-terminated. - */ -typedef struct _DataSourceBuffer { - const SXML_CHAR* buf; - int buf_len; - int cur_pos; -} DataSourceBuffer; - -typedef FILE* DataSourceFile; - -/** - * \typedef DataSourceType - * \brief Describes the type of data source used for parsing. - */ -typedef enum _DataSourceType { - DATA_SOURCE_FILE = 0, - DATA_SOURCE_BUFFER, - DATA_SOURCE_MAX -} DataSourceType; - -/** - * \brief Node types for `XMLNode`. - * - * Types marked *[N/A]* are *not* valid types for an `XMLNode` but are used - * internally by the parser. - */ -typedef enum _TagType { - TAG_ERROR = -1, - TAG_NONE = 0, - TAG_PARTIAL, /**< Node containing a legal `>` that stopped file reading. *[N/A]* */ - TAG_FATHER, /**< `` - Next nodes will be children of this one. */ - TAG_SELF, /**< `` - Standalone node. */ - TAG_INSTR, /**< `` - Processing instructions, or prolog node. */ - TAG_COMMENT, /**< `` */ - TAG_CDATA, /**< `` - CDATA node */ - TAG_DOCTYPE, /**< `` - DOCTYPE node */ - TAG_END, /**< `` - End of father node. *[N/A]* */ - TAG_TEXT, /**< Special node used as a text container. */ - /**< and `node->tag` is `NULL`. */ - - TAG_USER = 100 /*!< User-defined tag start */ -} TagType; - -/* TODO: Performance improvement with some fixed-sized strings ??? (e.g. XMLAttribute.name[64], XMLNode.tag[64]). - * Also better for platforms where allocations can be forbidden (e.g. embedded, space, ...). */ - -/** - * \typedef XMLAttribute - * \brief An XML attribute in the form `name="value"`. - * - * An attribute can be *deactivated*, in which case it will not be taken into account in functions - * `XMLNode_print*()`, `XMLNode_get_attribute_count()`. - */ -typedef struct _XMLAttribute { - SXML_CHAR* name; /**< The attribute name. */ - SXML_CHAR* value; /**< The attribute value. */ - int active; /**< `true` if the attribute is active. */ -} XMLAttribute; - -/* Constant to know whether a struct has been initialized (XMLNode or XMLDoc) - * TODO: Find a better way. */ -#define XML_INIT_DONE 0x19770522 /* Happy Birthday ;) */ - -/** - * \typedef XMLNode - * \brief An XML node. - * - * For tag types `TAG_INSTR`, `TAG_COMMENT`, `TAG_CDATA` and `TAG_DOCTYPE`, the text is - * stored in `node->tag`, with `node->text` being `NULL`. - * - * A node can be *deactivated*, in which case it will not be taken into account in functions - * `XMLNode_print*()`, `XMLNode_get_children_count()`, `XMLNode_get_child()`, `XMLNode_insert_child()`, ... - * - * If `text_as_nodes` is zeroed during parsing, the `node->text` is the concatenation of - * all texts found under the node: `textother text` will show `node->tag == "a"` - * and `node->text == "textother text"`. - * If `text_as_nodes` is non-zeroed, the same node will have 3 children: child [0] type is - * `TAG_TEXT` (with text `"text"`), child [1] type is `TAG_SELF` and child [2] type is - * `TAG_TEXT` (with text `"other text"`). - * - * *N.B. that when reading a pretty-printed XML, the extra line breaks and spaces will be stored - * in `node->text`*. - */ -typedef struct _XMLNode { - SXML_CHAR* tag; /**< Tag name, or text for tag types `TAG_INSTR`, `TAG_COMMENT`, `TAG_CDATA` and `TAG_DOCTYPE`. */ - SXML_CHAR* text; /**< Text inside the node, or `NULL` if empty. */ - XMLAttribute* attributes; /**< Array of attributes. */ - int n_attributes; /**< Number of attributes *in `attributes` array* (might not be the number of *active* attributes). */ - - struct _XMLNode* father; /**< Pointer to father node. `NULL` if root. */ - struct _XMLNode** children; /**< Array of children nodes. */ - int n_children; /**< Number of nodes *in `children` array* (might not be the number of *active* children). */ - - TagType tag_type; /**< Node type. */ - int active; /**< 'true' to tell that node is active and should be displayed by 'XMLDoc_print_*()'. */ - - void* user; /**< Pointer for user data associated to the node. */ - - /* Keep 'init_value' as the last member */ - int init_value; /**< Initialized to 'XML_INIT_DONE' to indicate that node has been initialized properly. */ -} XMLNode; - -#ifndef SXMLC_MAX_PATH -#define SXMLC_MAX_PATH 256 -#endif -/** - * \typedef XMLDoc. - * \brief An XML document, basically an array of `XMLNode`. - * - * An sxmlc XML document can have several root nodes. It actually usually have a prolog `` - * as the first node, then maybe a few comment nodes, then the first root node, which is the last node in - * correctly-formed XML, but there can also be some other nodes after it. - * - * N.B. that when compiled with `SXMLC_UNICODE` there are additional fields for BOM (Byte Order Mark) handling. - */ -typedef struct _XMLDoc { - SXML_CHAR filename[SXMLC_MAX_PATH]; -#ifdef SXMLC_UNICODE - BOM_TYPE bom_type; /**< BOM type (UTF-8, UTF-16*). */ - unsigned char bom[5]; /**< First characters read that might be a BOM when unicode is used. */ - int sz_bom; /**< Number of bytes in BOM. */ -#endif - XMLNode** nodes; /* Nodes of the document, including prolog, comments and root nodes */ - int n_nodes; /* Number of nodes in 'nodes' */ - int i_root; /* Index of first root node in 'nodes', -1 if document is empty */ - - /* Keep 'init_value' as the last member */ - int init_value; /* Initialized to 'XML_INIT_DONE' to indicate that document has been initialized properly */ -} XMLDoc; - -/** - * \brief Register an XML tag, giving its 'start' and 'end' string, which should include '<' and '>'. - * - * \param tag_type is user-given and has to be less than or equal to `TAG_USER`. It will be - * returned as the `tag_type` member of the `XMLNode` struct. - * *Note that no test is performed to check for an already-existing `tag_type`*. - * \param start The start string used to detect such tag (e.g. `""`). Should end with `>`. - * \return tag index in user tags table when successful, or -1 if the `tag_type` is invalid or - * the new tag could not be registered (e.g. when `start` does not start with `<` or - * `end` does not end with `>`). - */ -int XML_register_user_tag(TagType tag_type, SXML_CHAR* start, SXML_CHAR* end); - -/** - * \brief Remove a registered user tag. - * \param i_tag The user-tag number, as returned by `XML_register_user_tag()`. - * \return the new number of registered user tags or -1 if `i_tag` is invalid. - */ -int XML_unregister_user_tag(int i_tag); - -/** - * \brief Get the number of user-defined tags - * \return the number of registered tags. - */ -int XML_get_nb_registered_user_tags(void); - -/** - * \brief Search for a user tag based on it type. - * \param tag_type The tag type, as given in `XML_register_user_tag()`. - * \return the index of first occurrence of 'tag_type' in registered user tags, or '-1' if not found. - */ -int XML_get_registered_user_tag(TagType tag_type); - -/** - * \brief The different reasons why parsing would fail. - */ -typedef enum _ParseError { - PARSE_ERR_NONE = 0, /**< Success. */ - PARSE_ERR_MEMORY = -1, /**< Not enough memory for an `?alloc()` call. */ - PARSE_ERR_UNEXPECTED_TAG_END = -2, /**< When a tag end does not match the tag start (e.g. ``). */ - PARSE_ERR_SYNTAX = -3, /**< General syntax error. */ - PARSE_ERR_EOF = -4, /**< Unexpected EOF. */ - PARSE_ERR_TEXT_OUTSIDE_NODE = -5, /**< During DOM loading. */ - PARSE_ERR_UNEXPECTED_NODE_END = -6 /**< During DOM loading. */ -} ParseError; - -/** - * \brief Events that can happen when loading an XML document. - * - * These will be passed to the `all_event` callback of the SAX parser. - */ -typedef enum _XMLEvent { - XML_EVENT_START_DOC, /**< Document parsing started. */ - XML_EVENT_START_NODE, /**< New node detected (all attributes are read). */ - XML_EVENT_END_NODE, /**< Last node ended. */ - XML_EVENT_TEXT, /**< Text detected in current node. */ - XML_EVENT_ERROR, /**< Parsing error. */ - XML_EVENT_END_DOC /**< Document parsing finished. */ -} XMLEvent; - -/** - * \typedef SAX_Data - * \brief Structure given as an argument for SAX callbacks to retrieve information about parsing status. - */ -typedef struct _SAX_Data { - const SXML_CHAR* name; /**< Document name (file name or buffer name). */ - int line_num; /**< Current line number being processed. */ - void* user; /**< User-given data. */ -} SAX_Data; - -/** - * \typedef SAX_Callbacks - * \brief User callbacks used for SAX parsing. - * - * Return values of these callbacks should be 0 to stop parsing. Some callbacks can be set to `NULL` - * to disable handling of some events (e.g. everything `NULL` except `all_event()`). - * - * All parameters are pointers to structures that will no longer be available after callback returns so - * it is recommended that the callback uses the information and stores it in its own data structure. - * - * *WARNING! SAX PARSING DOES NOT CHECK FOR XML INTEGRITY!* e.g. a tag end without a matching tag start - * will not be detected by the parser and should be detected by the callbacks instead. - */ -typedef struct _SAX_Callbacks { - /** - * \fn start_doc - * \brief Callback called when parsing starts, *before* parsing the first node. - */ - int (*start_doc)(SAX_Data* sd); - - /** - * \fn start_node - * \brief Callback called when a new node starts (e.g. `` or ``). - * - * Attributes are read and available from `node->attributes`. - * N.B. "self-contained" ndoes (e.g. ``) will trigger an immediate call to the `end_node()` callback - * after the `start_node()` callback. - */ - int (*start_node)(const XMLNode* node, SAX_Data* sd); - - /** - * \fn end_node - * \brief Callback called when a node ends (e.g. `` or ``). - */ - int (*end_node)(const XMLNode* node, SAX_Data* sd); - - /** - * \fn new_text - * \brief Callback called when text has been found in the last node (e.g. `text<...`). - */ - int (*new_text)(SXML_CHAR* text, SAX_Data* sd); - - /** - * \fn end_doc - * \brief Callback called when parsing is finished. - * No other callbacks will be called after it. - */ - int (*end_doc)(SAX_Data* sd); - - /** - * \fn on_error - * \brief Callback called when an error occurs during parsing. - * \param error_num is the error number - * \param line_number is the line number in the stream being read (file or buffer). - */ - int (*on_error)(ParseError error_num, int line_number, SAX_Data* sd); - - /** - * \fn all_event - * \brief Callback called when text has been found in the last node. - * - * \param event is the type of event for which the callback was called: - - `XML_EVENT_START_DOC`: - - `node` is NULL. - - 'text` is the file name if a file is being parsed, `NULL` if a buffer is being parsed. - - `n` is 0. - - `XML_EVENT_START_NODE`: - - `node` is the node starting, with tag and all attributes initialized. - - `text` is NULL. - - `n` is the number of lines parsed. - - `XML_EVENT_END_NODE`: - - `node` is the node ending, with tag, attributes and text initialized. - - `text` is NULL. - - `n` is the number of lines parsed. - - `XML_EVENT_TEXT`: - - `node` is NULL. - - `text` is the text to be added to last node started and not finished. - - `n` is the number of lines parsed. - - `XML_EVENT_ERROR`: - - Everything is NULL. - - `n` is one of the `PARSE_ERR_*`. - - `XML_EVENT_END_DOC`: - - `node` is `NULL`. - - `text` is the file name if a file is being parsed, NULL if a buffer is being parsed. - - `n` is the number of lines parsed. - */ - int (*all_event)(XMLEvent event, const XMLNode* node, SXML_CHAR* text, const int n, SAX_Data* sd); -} SAX_Callbacks; - -/** - * \brief Helper function to initialize all `sax` members to `NULL`. - * \param sax The callbacks structure to initialize. - * \return `false` is `sax` is NULL. - */ -int SAX_Callbacks_init(SAX_Callbacks* sax); - -/** - * Set of SAX callbacks used by `XMLDoc_parse_file_DOM()`. - * These are made available to be able to load an XML document using DOM implementation - * with user-defined code at some point (e.g. counting nodes, running search, ...). - * In this case, the `XMLDoc_parse_file_SAX()` has to be called instead of the `XMLDoc_parse_file_DOM()`, - * providing either these callbacks directly, or a functions calling these callbacks. - * To do that, you should initialize the `doc` member of the `DOM_through_SAX` struct and call the - * `XMLDoc_parse_file_SAX()` giving this struct as a the `user` data pointer. - */ -typedef struct _DOM_through_SAX { - XMLDoc* doc; /**< Document to fill up. */ - XMLNode* current; /**< For internal use (current father node). */ - ParseError error; /**< For internal use (parse status). */ - int line_error; /**< For internal use (line number when error occurred). */ - int text_as_nodes; /**< For internal use (store text inside nodes as sequential TAG_TEXT nodes). */ -} DOM_through_SAX; - -int DOMXMLDoc_doc_start(SAX_Data* dom); -int DOMXMLDoc_node_start(const XMLNode* node, SAX_Data* dom); -int DOMXMLDoc_node_text(SXML_CHAR* text, SAX_Data* dom); -int DOMXMLDoc_node_end(const XMLNode* node, SAX_Data* dom); -int DOMXMLDoc_parse_error(ParseError error_num, int line_number, SAX_Data* sd); -int DOMXMLDoc_doc_end(SAX_Data* dom); - -/** - * \brief Initialize `sax` with the "official" DOM callbacks. - */ -int SAX_Callbacks_init_DOM(SAX_Callbacks* sax); - -/* --- XMLNode methods --- */ - -/** - * \brief Parse an attribute to an `XMLAttribute` struct. - * \param str contains the string to parse, supposed like `attrName[ ]=[ ]["]attr Value["]`. - * \param to is the position in `str` to stop at, or `-1` to parse until the end of `str`. - * \param xmlattr filled with `xmlattr->name` to `attrName` and `xmlattr->value` to `attr Value`. - * \return 0 if not enough memory or bad parameters (`str` or `xmlattr` is `NULL`), - 2 if last quote is missing in the attribute value, 1 if `xmlattr` was filled correctly. - */ -int XML_parse_attribute_to(const SXML_CHAR* str, int to, XMLAttribute* xmlattr); - -/** - * \fn XML_parse_attribute - * \brief Short for `XML_parse_attribute_to()` with `to=-1`. - */ -#define XML_parse_attribute(str, xmlattr) XML_parse_attribute_to(str, -1, xmlattr) - -/** - * \brief Reads a string that is supposed to be an xml tag like `` or ``. - * \param str The string to parse. - * \param xmlnode the `XMLNode` structure which tag name and attributes will be filled. - * \returns 0 if an error occurred (malformed `str` or memory). `TAG_*` when string is recognized. - */ -TagType XML_parse_1string(const SXML_CHAR* str, XMLNode* xmlnode); - -/** - * \brief Allocate and initialize XML nodes. - * \param n is the number of contiguous elements to allocate (to create and array). - * \return `NULL` if not enough memory, or the pointer to the elements otherwise. - */ -XMLNode* XMLNode_allocN(int n); - -/** - * \fn XMLNode_alloc - * \brief Shortcut to allocate one node only. - */ -#define XMLNode_alloc() XMLNode_allocN(1) - -/** - * \brief Allocate and initialize a new `XMLNode` of the given type, tag name and text. - * \param tag_type The node tag type. - * \param tag The node tag. - * \param text The node text. - * \return `NULL` if not enough memory, or the pointer to the node otherwise. - */ - -XMLNode* XMLNode_new(const TagType tag_type, const char* tag, const char* text); - -/** - * \fn XMLNode_new_node_comment - * \brief Utility to create a comment: `` - */ -#define XMLNode_new_node_comment(comment) XMLNode_new(TAG_COMMENT, (comment), NULL) -/** - * \fn XMLNode_new_comment - */ -#define XMLNode_new_comment XMLNode_new_node_comment - -/** - * \fn XMLNode_new_node_text - * \brief Utility to create a simple node with text: `text` - */ -#define XMLNode_new_node_text(tag, text) XMLNode_new(TAG_TEXT, (tag), (text)) -/** - * \fn XMLNode_new_text - */ -#define XMLNode_new_text XMLNode_new_node_text - -/** - * \brief Initialize an already-allocated XMLNode. - */ -int XMLNode_init(XMLNode* node); - -/** - * \brief Tells whether a node is valid. - */ -#define XMLNode_is_valid(node) ((node) != NULL && (node)->init_value == XML_INIT_DONE) - -/** - * \brief Free a node and all its children. - */ -int XMLNode_free(XMLNode* node); - -/** - * \brief Copy a node to another one, optionally including its children. - * \param dst The node receiving the copy. N.B. thtat the node is freed first! - * \param src The node to duplicate. If `NULL`, `dst` is freed and initialized. - * \param copy_children `true` to include `src` children (recursive copy). - * \return `false` in case of memory error or if `dst` is `NULL` or `src` uninitialized. - */ -int XMLNode_copy(XMLNode* dst, const XMLNode* src, int copy_children); - -/** - * \brief Duplicate a node, potentially with its children. - * \param node The node to duplicate. - * \param copy_children `true` to include `src` children (recursive copy). - * \return `NULL` if not enough memory, or a pointer to the new node otherwise. - */ -XMLNode* XMLNode_dup(const XMLNode* node, int copy_children); - -/** - * \brief Set the active/inactive state of `node`. - * - * Set `active` to `true` to activate `node` and all its children, and enable its use - * in other functions (e.g. `XMLDoc_print()`, ...). - */ -int XMLNode_set_active(XMLNode* node, int active); - -/** - * \brief Set node tag. - * \param node The node to set. - * \param tag The tag to set in `node`. A *copy* of `tag` will be assigned to `node->tag`, using `strdup()`. - * \return `false` for memory error, `true` otherwise. - */ -int XMLNode_set_tag(XMLNode* node, const SXML_CHAR* tag); - -/** - * \brief Set the node type to one of `TagType` or any user-registered tag. - * \return 'false' when the node or the 'tag_type' is invalid. - */ -int XMLNode_set_type(XMLNode* node, const TagType tag_type); - -/** - * \brief Add an attribute to a node or update an existing one. - * \param node The node to which add/update an attribute. - * \param attr_name The attribute name. A *copy* will be assigned through `strdup()`. - * \param attr_value The attribute value. A *copy* will be assigned through `strdup()`. - * \return the new number of attributes, or -1 for memory problem. - */ -int XMLNode_set_attribute(XMLNode* node, const SXML_CHAR* attr_name, const SXML_CHAR* attr_value); - -/** - * \brief Retrieve an attribute value, based on its name, returning a default value if the attribute - * does not exist. - * \param node The node. - * \param attr_name The attribute name to search. - * \param attr_value A pointer receiving a *copy* of the attribute value (from `strdup()`). - * \param default_attr_value If `attr_name` does not exist in `node`, a *copy* (from `strdup()`) - * of this string will be stored in `attr_value`. - * \return `false` when the `node` is invalid, `attr_name` is NULL or empty, or `attr_value` is NULL. - */ -int XMLNode_get_attribute_with_default(XMLNode* node, const SXML_CHAR* attr_name, const SXML_CHAR** attr_value, const SXML_CHAR* default_attr_value); - -/** - * \fn XMLNode_get_attribute - * \brief Helper macro that retrieve an attribute value, or an empty string if the attribute does not exist. - */ -#define XMLNode_get_attribute(node, attr_name, attr_value) XMLNode_get_attribute_with_default(node, attr_name, attr_value, C2SX("")) - -/** - * \return the number of active attributes of 'node', or '-1' if 'node' is invalid. - */ -int XMLNode_get_attribute_count(const XMLNode* node); - -/** - * \brief Search for the active attribute `attr_name` in `node`, starting from index `isearch` - * and returns its index, or -1 if not found or error. - */ -int XMLNode_search_attribute(const XMLNode* node, const SXML_CHAR* attr_name, int isearch); - -/** - * \brief Remove attribute index `i_attr`. - * \return the new number of attributes or -1 on invalid arguments. - */ -int XMLNode_remove_attribute(XMLNode* node, int i_attr); - -/** - * \brief Remove all attributes from `node`. - */ -int XMLNode_remove_all_attributes(XMLNode* node); - -/** - * Set node text to a copy of `text` (from `strdup()`), or remove text if set to `NULL`. - * \return `true` when successful, `false` on error. - */ -int XMLNode_set_text(XMLNode* node, const SXML_CHAR* text); - -/** - * \fn XMLNode_remove_text - * \brief Helper macro to remove text from `node`. - */ -#define XMLNode_remove_text(node) XMLNode_set_text(node, NULL); - -/** - * \brief Add a child to a node. - * \return `false` for memory problem, `true` otherwise. - */ -int XMLNode_add_child(XMLNode* node, XMLNode* child); - -/** - * \brief Insert a node at a given position. - * \param node The node to which inserting the child node. - * \param child The node to insert. - * \param index The insert position: if `index <= 0`: will be the first child (0). - * If `index >= child->father->n_children`: will be the last child. - * \return 'false' if 'node' is not initialized, 'true' otherwise. - */ -int XMLNode_insert_child(XMLNode* node, XMLNode* child, int index); - -/** - * \fn XMLNode_insert_before - * \brief Insert a node before the given node (i.e. at its index). - */ -#define XMLNode_insert_before(node, child) XMLNode_insert_child(node, child, XMLNode_get_index(node)) -/** - * \fn XMLNode_insert_after - * \brief Insert a node after the given node. - */ -#define XMLNode_insert_after(node, child) XMLNode_insert_child(node, child, XMLNode_get_index(node)+1) - -/** - * \brief Move a child node among its siblings. - * \param node The node which children should be moved. - * \param from Position of the node to move. - * \param to Position to move to. Moved to first position if `to <= 0` or last position - * if `to >= node->n_children`. - * \return `false` if `node` is not initialized or `from` is invalid. `true` otherwise. - */ -int XMLNode_move_child(XMLNode* node, int from, int to); - -/** - * \brief Get the number of *active* children of a node. - * \param node The node. - * \return the number of active children nodes of `node`, or -1 if `node` is invalid. - * N.B. that it can be different from `node->n_children` if some nodes are deactivated! - */ -int XMLNode_get_children_count(const XMLNode* node); - -/** - * \brief Get the node position among its *active* siblings. - * \param node The node. - * \return `node` position among its siblings, -1 if `node` is invalid or -2 if `node` could - * not be found in its father's children (in which case I'd appreciate a bug report with - * the XML and steps that led to that situation!). - */ -int XMLNode_get_index(const XMLNode* node); - -/** - * \brief Get an *active* node. - * \param node The node. - * \param i_child The active node index to retrieve. - * \return the `i_child`th *active* node. - */ -XMLNode* XMLNode_get_child(const XMLNode* node, int i_child); - -/** - * \brief Remove the `i_child`th *active* child of the node. - * \param node The node. - * \param i_child The active node index to retrieve. - * \param free_child if `true`, free the child node itself (and its children, recursively). - * This parameter is usually `true` but should be `false` when child nodes are pointers - * to local or global variables instead of user-allocated memory. - * \return the new number of children or -1 on invalid arguments. - */ -int XMLNode_remove_child(XMLNode* node, int i_child, int free_child); - -/** - * \brief Remove (and frees) all children from the node. - * \param node The node. - * \return `true`. - */ -int XMLNode_remove_children(XMLNode* node); - -/** - * \param node1 The first node to test. - * \param node2 The second node to test. - * \return `true` if `node1` is the same as `node2` (i.e. same tag, same active attributes) - * but *not necessarily* the same children. - */ -int XMLNode_equal(const XMLNode* node1, const XMLNode* node2); - -/** - * \brief Get the next sibling node. - * \param node The node which sibling to retrieve. - * \return the next sibling of the node, or `NULL` if `node` is invalid or the last child - * or if its father could not be determined (i.e. `node` is a root node). - */ -XMLNode* XMLNode_next_sibling(const XMLNode* node); - -/** - * \brief Get the "next" node: first child (if any) of next sibling otherwise. - * \param node The node. - * \return the next node in XML order, or `NULL` if `node` is invalid or the last node. - */ -XMLNode* XMLNode_next(const XMLNode* node); - - - -/* --- XMLDoc methods --- */ - - -/** - * \brief Initializes an already-allocated XML document. - * \param doc The document to initialize. - * \return `false` if `doc` is NULL. - */ -int XMLDoc_init(XMLDoc* doc); - -/** - * \brief Free an XML document, including all of its nodes, recursively. - * \param doc The document to initialize. - * \return `false` if `doc` was not initialized. - */ -int XMLDoc_free(XMLDoc* doc); - -/** - * \brief Set the new document root node. - * \param doc The document to initialize. - * \param i_root The element index to set as root. - * \return `false` if `doc` is not initialized or `i_root` is invalid, `true` otherwise. - */ -int XMLDoc_set_root(XMLDoc* doc, int i_root); - -/** - * \brief Add a node to the document. - * - * If the node type is `TAG_FATHER`, it also sets the document root node if previously undefined. - * \param doc The document. - * \param node The node to add. - * \return the node index, or -1 for uninitialized `doc` or `node`, or memory error. - */ -int XMLDoc_add_node(XMLDoc* doc, XMLNode* node); - -/** - * \brief Remove a node from the document root nodes. Inactive nodes can be removed like this. - * \param doc The XML document. - * \param i_node The node index to remove - * \param free_node if `true`, free the node itself. This parameter is usually `true` - * but should be 'false' when the node is a pointer to local or global variable instead of - * user-allocated memory. - * \return `true` if node was removed or `false` if `doc` or `i_node` is invalid. - */ -int XMLDoc_remove_node(XMLDoc* doc, int i_node, int free_node); - -#define XMLDoc_remove_root_node XMLDoc_remove_node - -/** - * \brief Shortcut macro to retrieve root node from a document. Equivalent to `doc->nodes[doc->i_root]`. - */ -#define XMLDoc_root(doc) ((doc)->nodes[(doc)->i_root]) - -/** - * \brief Shortcut macro to add a node to 'doc' root node. Equivalent to `XMLDoc_add_child_root(XMLDoc* doc, XMLNode* child)`. - */ -#define XMLDoc_add_child_root(doc, child) XMLNode_add_child((doc)->nodes[(doc)->i_root], (child)) - -/** - * \brief Default quote to use to print attribute value (defaults to a double. quote `"`). - * - * User can redefine it with its own character by adding a `-DXML_DEFAULT_QUOTE` compiler option. - */ -#ifndef XML_DEFAULT_QUOTE -#define XML_DEFAULT_QUOTE C2SX('"') -#endif - -/** - * \brief Print the node and its children to a file (that can be `stdout`). - * - * \param node The node to print. - * \param f The file to print to (can be `stdout`). - * \param tag_sep The string to use to separate nodes from each other (usually `"\n"`). - * \param child_sep The additional string to put for each child level (usually `"\t"`). - * \param attr_sep The additional string to put to separate attributes (usually `" "`). - * \param keep_text_spaces indicates that text should not be printed if it is composed of - * spaces, tabs or new lines only (e.g. when XML document spans on several lines due to - * pretty-printing). - * \param sz_line The maximum number of characters that can be put on a single line. The - * node remainder will be output to extra lines. - * \param nb_char_tab How many characters should be counted for a tab when counting characters - * in the line. It usually is 8 or 4, but at least 1. - * \return `false` on invalid arguments (`NULL` `node` or `f`), `true` otherwise. - */ -int XMLNode_print_attr_sep(const XMLNode* node, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, const SXML_CHAR* attr_sep, int keep_text_spaces, int sz_line, int nb_char_tab); - -/** - * \brief For backward compatibility (`attr_sep` is a space). - */ -#define XMLNode_print(node, f, tag_sep, child_sep, keep_text_spaces, sz_line, nb_char_tab) XMLNode_print_attr_sep(node, f, tag_sep, child_sep, C2SX(" "), keep_text_spaces, sz_line, nb_char_tab) - -/** - * \brief Print the node "header": ``, spanning it on several lines if needed. - * \return `false` on invalid arguments (`NULL` `node` or `f`), `true` otherwise. - */ -int XMLNode_print_header(const XMLNode* node, FILE* f, int sz_line, int nb_char_tab); - -/** - * \brief Prints the XML document using `XMLNode_print_attr_sep()` on all document nodes. - */ -int XMLDoc_print_attr_sep(const XMLDoc* doc, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, const SXML_CHAR* attr_sep, int keep_text_spaces, int sz_line, int nb_char_tab); - -/* For backward compatibility */ -#define XMLDoc_print(doc, f, tag_sep, child_sep, keep_text_spaces, sz_line, nb_char_tab) XMLDoc_print_attr_sep(doc, f, tag_sep, child_sep, C2SX(" "), keep_text_spaces, sz_line, nb_char_tab) - -/** - * \brief Parse a file into an initialized XML document (DOM mode). - * \param filename The file to parse. - * \param doc The document to parse into. - * \param text_as_nodes should be non-zero to put text into separate TAG_TEXT nodes. - * \return `false` in case of error (memory or unavailable filename, malformed document), `true` otherwise. - */ -int XMLDoc_parse_file_DOM_text_as_nodes(const SXML_CHAR* filename, XMLDoc* doc, int text_as_nodes); - -/** - * \brief For backward compatibility (`text_as_nodes` is 0) - */ -#define XMLDoc_parse_file_DOM(filename, doc) XMLDoc_parse_file_DOM_text_as_nodes(filename, doc, 0) - -/** - * \brief Parse a memory buffer into an initialized document (DOM mode). - * \param buffer The memory buffer to parse. - * \param name The buffer name (to identify several buffers if run concurrently). - * \param doc The document to parse into. - * \param text_as_nodes should be non-zero to put text into separate TAG_TEXT nodes. - * \return `false` in case of error (memory or unavailable filename, malformed document), `true` otherwise. - */ -int XMLDoc_parse_buffer_DOM_text_as_nodes(const SXML_CHAR* buffer, const SXML_CHAR* name, XMLDoc* doc, int text_as_nodes); - -/** - * \brief For backward compatibility (`text_as_nodes` is 0) - */ -#define XMLDoc_parse_buffer_DOM(buffer, name, doc) XMLDoc_parse_buffer_DOM_text_as_nodes(buffer, name, doc, 0) - -/** - * \brief Parse an XML file, calling SAX callbacks. - * \param filename The file to parse. - * \param sax The SAX callbacks that will be called by the parser on each XML event. - * \param user A user-given pointer that will be given back to all callbacks. - * \return `false` in case of error (memory or unavailable filename, malformed document) or when requested - * by a SAX callback. `true` otherwise. - */ -int XMLDoc_parse_file_SAX(const SXML_CHAR* filename, const SAX_Callbacks* sax, void* user); - -/** - * \brief Parse an XML buffer, calling SAX callbacks. - * \param buffer The memory buffer to parse. - * \param buffer_len The buffer lenght, in *characters* (i.e. can be 2 bytes in unicode). - * \param name An optional buffer name. - * \param sax The SAX callbacks that will be called by the parser on each XML event. - * \param user A user-given pointer that will be given back to all callbacks. - * \return `false` in case of error (memory or unavailable filename, malformed document) or when requested - * by a SAX callback. `true` otherwise. - */ -int XMLDoc_parse_buffer_SAX_len(const SXML_CHAR* buffer, int buffer_len, const SXML_CHAR* name, const SAX_Callbacks* sax, void* user); - -/** - * \brief For backward compatibility (buffer length is `strlen(buffer)`). - */ -#define XMLDoc_parse_buffer_SAX(buffer, name, sax, user) XMLDoc_parse_buffer_SAX_len(buffer, sx_strlen(buffer), name, sax, user) - -/** - * \brief Parse an XML file using the DOM implementation. - */ -#define XMLDoc_parse_file XMLDoc_parse_file_DOM - - - -/* --- Utility functions --- */ - -/** - * \brief Get next byte from data source. - * \return as `fgetc()` would for `FILE*`. - */ -int _bgetc(DataSourceBuffer* ds); - -/** - * \brief know if the end has been reached in a data source. - * \return as `feof()` would for `FILE*`. - */ -int _beob(DataSourceBuffer* ds); - -/** - * \brief Read a "line" from data source, eventually (re-)allocating a given buffer. A "line" is defined - * as a portion starting with character `from` (usually `<`) ending at character `to` (usually `>`). - * - * Characters read will be stored in `line` starting at `i0` (this allows multiple calls to - * `read_line_alloc()` on the same `line` buffer without overwriting it at each call). - * Searches for character `from` until character `to`. If `from` is 0, starts from - * current position in the data source. If `to` is 0, it is replaced by `\n`. - * - * \param in The data source (either `FILE*` if `in_type` is `DATA_SOURCE_FILE` or `SXML_CHAR*` - * if `in_type` is `DATA_SOURCE_BUFFER`). - * \param in_type specifies the type of data source to be read. - * \param line can be `NULL`, in which case it will be allocated to `*sz_line` bytes. After the function - * returns, `*sz_line` is the actual buffer size. This allows multiple calls to this function using - * the same buffer (without re-allocating/freeing). - * \param sz_line is the size of the buffer `line` if previously allocated (in `SXML_CHAR`, not byte!). - * If `NULL` or 0, an internal value of `MEM_INCR_RLA` is used. - * \param i0 The position where read characters are stored in `line`. - * \param from The character indicating a start of line. - * \param to The character indicating an end of line. - * \param keep_fromto if 0, removes characters `from` and `to` from the line (stripping). - * \param interest is a special character of interest, usually `\n` so we can count line numbers in the - * data source (valid only if `interest_count` is not `NULL`). - * \param interest_count if not `NULL`, will receive the count of `interest` characters while searching. - * \returns the number of characters in the line or 0 if an error occurred. - */ -int read_line_alloc(void* in, DataSourceType in_type, SXML_CHAR** line, int* sz_line, int i0, SXML_CHAR from, SXML_CHAR to, int keep_fromto, SXML_CHAR interest, int* interest_count); - -/** - * \brief Concatenates the string pointed at by `src1` with `src2` into `*src1` and return it. - * \return `*src1`, or `NULL` if out of memory. - */ -SXML_CHAR* strcat_alloc(SXML_CHAR** src1, const SXML_CHAR* src2); - -/** - * \brief Strip whitespaces at the beginning and end of a string, modifying it. - * \param str The string to strip. - * \param repl_sq if not null, squeezes spaces to an single character `repl_sq`. - * \returns the stripped string, which can be `str` directly if there are no whitespaces - * at the beginning. - * N.B. that if `str` was allocated, it should be freed later, *not* the returned - * reference. - */ -SXML_CHAR* strip_spaces(SXML_CHAR* str, SXML_CHAR repl_sq); - -/** - * \brief Remove `\` characters from `str`, modifying it. - * \return `str` unescaped. - */ -SXML_CHAR* str_unescape(SXML_CHAR* str); - -/** - * \brief Split a string into a left and right part around a given separator. - * - * The beginning and end indices of left part are stored in `l0` and `l1` while the - * right part's are stored in `r0` and `r1`. The separator position is stored at `i_sep` - * (whenever these are not `NULL`). - * Whenever the right member is empty (e.g. `"attrib"` or `"attrib="`), `*r0` is set to - * `strlen(str)` and `*r1` to `*r0-1` (crossed). - * - * \param str The string to split. - * \param sep The separator (e.g. `=`). - * \param l0 will contain the index of the left part first character in `str`. - * \param l1 will contain the index of left part last character in `str`. - * \param i_sep will contain the index of the separator in `str`, or -1 if not found. - * \param r0 will contain the index of the left part first character in `str`. - * \param r1 will contain the index of left part last character in `str`. - * \param ignore_spaces Is `true`, computed indexes will not take into account potential - * spaces around the separator as well as before left part and after right part, so - * `"name=val"` will be equivalent to `"name = val"`. - * \param ignore_quotes If `true`, quotes (`"` or `'`) will not be taken into account when parsing left - * and right members, so `"name = 'val'"` will be equivalent to `"name = val"`. - * - * \return `false` when `str` is malformed, `true` when splitting was successful. - */ -int split_left_right(SXML_CHAR* str, SXML_CHAR sep, int* l0, int* l1, int* i_sep, int* r0, int* r1, int ignore_spaces, int ignore_quotes); - -#ifdef SXMLC_UNICODE -/** - * \brief Describe the types of BOM detected while reading an XML buffer. - */ -typedef enum _BOM_TYPE { - BOM_NONE = 0x00, - BOM_UTF_8 = 0xefbbbf, - BOM_UTF_16BE = 0xfeff, - BOM_UTF_16LE = 0xfffe, - BOM_UTF_32BE = 0x0000feff, - BOM_UTF_32LE = 0xfffe0000 -} BOM_TYPE; -/** - Detect a potential BOM at the current file position and read it into 'bom' (if not NULL, - 'bom' should be at least 5 bytes). It also moves the 'f' beyond the BOM so it's possible to - skip it by calling 'freadBOM(f, NULL, NULL)'. If no BOM is found, it leaves 'f' file pointer - is reset to its original location. - If not null, 'sz_bom' is filled with how many bytes are stored in 'bom'. - Return the BOM type or BOM_NONE if none found (empty 'bom' in this case). - */ -BOM_TYPE freadBOM(FILE* f, unsigned char* bom, int* sz_bom); -#endif - -/** - * \brief Replace occurrences of special HTML characters escape sequences (e.g. `"&"`) - * by its character equivalent (e.g. `"&"`). - * - * If `html == str`, replacement is made in `str` itself, overwriting it. - * If `str` is `NULL`, replacement is made into `html`, overwriting it. - * - * \param html The string containing the HTML escapes (e.g. `"hôtel"`). - * \param str The string to receive the unescaped string (e.g. `"hôtel"`). - * - * \returns The unescaped string (`str`, or `html` if `str` was `NULL`). - */ -SXML_CHAR* html2str(SXML_CHAR* html, SXML_CHAR* str); - -/** - * \brief Replace occurrences of special characters (e.g. `&`) into their XML escaped - * equivalent (e.g. `"&"`). - * - * `html` is supposed allocated to the correct size (e.g. using `__malloc(strlen_html(str)+30)`) - * and *different* from `str` (unlike `html2str()`), as the string will expand. - * If it is `NULL`, `str` will be analyzed and a string will be allocated to the exact size and - * returned. In that case, it is the responsibility of the caller to `free()` the result! - * \return `html`, or `NULL` if `str` or `html` are `NULL`, or when `html` is `str`. - */ -SXML_CHAR* str2html(SXML_CHAR* str, SXML_CHAR* html); - -/** - * \brief Compute the length of a string as if all its special character were replaced by their HTML - * escapes. - * \return 0 if `str` is NULL. - */ -int strlen_html(SXML_CHAR* str); - -/** - * \brief Print a string to a file, transforming special characters into their HTML equivalent. - - * This is more efficient than a call to `fprintf(f, str2html(str))` as it does not need memory - * allocation; rather, it converts characters on-the-fly while writing. - * If `f` is NULL, does not print `str` but rather counts the number of characters that - * would be printed. - * - * \returns the number of output characters. - */ -int fprintHTML(FILE* f, SXML_CHAR* str); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/sxmlsearch.h b/include/sxmlsearch.h deleted file mode 100755 index 4a8214b..0000000 --- a/include/sxmlsearch.h +++ /dev/null @@ -1,274 +0,0 @@ -/** - Copyright (c) 2010, Matthieu Labas - All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY - OF SUCH DAMAGE. - - The views and conclusions contained in the software and documentation are those of the - authors and should not be interpreted as representing official policies, either expressed - or implied, of the FreeBSD Project. -*/ -#ifndef _SXMLCSEARCH_H_ -#define _SXMLCSEARCH_H_ - -#ifdef __cplusplus -extern "C" { -#endif - -#include "sxmlc.h" - -/** - * \brief XML search parameters. Can be initialized from an XPath string. - */ -typedef struct _XMLSearch { - - SXML_CHAR* tag; /**< Search for nodes which tag match this `tag` field. */ - /**< If NULL or an empty string, all nodes will be matching. */ - - XMLAttribute* attributes; /**< Search for nodes which attributes match all the ones described. */ - /**< If NULL, all nodes will be matching. */ - /**< The `attribute->name` should not be NULL. If corresponding `attribute->value` */ - /**< is NULL or an empty-string, search will return the first node with an attribute */ - /**< `attribute->name`, no matter what its value is. */ - /**< If `attribute->value` is not NULL, a matching node should have an attribute */ - /**< `attribute->name` with the corresponding value `attribute->value`. */ - /**< When `attribute->value` is not NULL, the `attribute->active` should be `true` */ - /**< to specify that values should be equal, or `false` to specify that values should */ - /**< be different. */ - int n_attributes; /**< The size of `attributes`array. */ - - SXML_CHAR* text; /**< Search for nodes which text match this `text` field. */ - /**< If NULL or an empty string, all nodes will be matching (i.e. not used). */ - - struct _XMLSearch* next; /**< Next search to perform on children of a node matching current struct. */ - /**< Used to search for nodes children of specific nodes (used in XPath queries). */ - struct _XMLSearch* prev; - - XMLNode* stop_at; /**< Internal use only. Must be initialized to 'INVALID_XMLNODE_POINTER' prior to first search. */ - - /* Keep 'init_value' as the last member */ - int init_value; /**< Initialized to 'XML_INIT_DONE' to indicate that document has been initialized properly */ -} XMLSearch; - -/** - * \brief The prototype used by the regular expression handler. - * The default regex function can be overriden by user code through `XMLSearch_set_regexpr_compare()`. - * \param str The string to match on `pattern`. - * \param pattern The pattern to match `str` to. - * \return `true` if `str` matches `pattern`. - */ -typedef int (*REGEXPR_COMPARE)(SXML_CHAR* str, SXML_CHAR* pattern); - -/** - * \brief Set a new comparison function to evaluate whether a string matches a given pattern. - * - * The default one is `regstrcmp()` which handles limited regular expressions (`'?'` and `'*'` - * wildcards). - * - * \return The previous function used for matching. - */ -REGEXPR_COMPARE XMLSearch_set_regexpr_compare(REGEXPR_COMPARE fct); - -/** - * \brief Initialize an empty search. No memory freeing is performed. - * \param search The search parameters. - * \return `false` when `search` is NULL. - */ -int XMLSearch_init(XMLSearch* search); - -/** - * \brief Free all search members except for the `search->next` member that should be freed - * by its creator, unless `free_next` is `true`. - * - * It is recommended that `free_next` is positioned to `true` only when the creator did not - * handle the whole memory allocation chain, e.g. when using `XMLSearch_init_from_XPath()` - * that allocates all search structs. - * - * \param search The search parameters. - * \param free_next `false` in order *not* to free the `search->next` structures. - * - * \return `false` when `search` is NULL. - */ -int XMLSearch_free(XMLSearch* search, int free_next); - -/** - * \brief Set the search based on tag. - * \param search The search parameters. - * \param tag should be NULL or empty to search for any node (e.g. search based on attributes - * only). In this case, the previous tag is freed. - * \return `true` upon successful completion, `false` for memory error. - */ -int XMLSearch_search_set_tag(XMLSearch* search, const SXML_CHAR* tag); - -/** - * \brief Add an attribute search criteria. - * \param search The search parameters. - * \param attr_name is the attribute name to search. Mandatory. - * \param attr_value should be NULL to test for attribute presence only - * (no test on value). An empty string means the attribute should exist - * with an empty value. - * \param value_equal should be specified to test for attribute value equality (`true`) or - * difference (`false`). - * \return the index of the new attribute, or -1 for memory error. - */ -int XMLSearch_search_add_attribute(XMLSearch* search, const SXML_CHAR* attr_name, const SXML_CHAR* attr_value, int value_equal); - -/** - * \brief Retrieve attribute search parameters on attribute `attr_name`. - * \param search The search parameters. - * \param attr_name The attribute name to look for. - * \return The attribute search index or -1 if not found. - */ -int XMLSearch_search_get_attribute_index(const XMLSearch* search, const SXML_CHAR* attr_name); - -/** - * \brief Remove the attribute search parameters by index. - * \param search The search parameters. - * \param i_attr The search attribute index. - * \return the number of search attributes parameters left. - */ -int XMLSearch_search_remove_attribute(XMLSearch* search, int i_attr); - -/** - * \brief Set the search based on text content. - * \param search The search parameters. - * \param text should be NULL or empty to search for any node (e.g. search based on attributes - * only). In this case, the previous text is freed. - * - * \return `true` upon successful completion, `false` for memory error. - */ -int XMLSearch_search_set_text(XMLSearch* search, const SXML_CHAR* text); - -/** - * \brief Set an additional search on children nodes of a previously matching node. - * - * Search struct are chained to finally return the node matching the last search struct, - * which father node matches the previous search struct, and so on. - * This allows describing more complex search queries like XPath - * `"//FatherTag[@attrib=val]/ChildTag/"`. - * - * In this case, a first search struct would have `search->tag = "FatherTag"` and - * `search->attributes[0] = { "attrib", "val" }` and a second search struct with - * `search->tag = "ChildTag"`. - * If `children_search` is NULL, next search is removed. Freeing previous search is to be - * performed by its owner. - * In any case, if `search` next search is not NULL, it is freed. - * - * \param search The search parameters. - * \param children_search The search parameters to be applied to children of nodes - * matching `search`. - * - * \return `true` when association has been made, `false` when an error occurred. - */ -int XMLSearch_search_set_children_search(XMLSearch* search, XMLSearch* children_search); - -/** - * \brief Compute an XPath-equivalent string of the search criteria. - * - * \param search The search parameters. NULL will return an empty string. - * \param xpath is a pointer to a string that will be allocated by the function and should - * be freed after use. - * \param quote is the quote character to be used (e.g. `"` or `'`). If `'\0'`, - * `XML_DEFAULT_QUOTE` will be used. - * - * \return `false` for a memory problem, `true` otherwise. - */ -SXML_CHAR* XMLSearch_get_XPath_string(const XMLSearch* search, SXML_CHAR** xpath, SXML_CHAR quote); - -/** - * \brief Initialize a search struct from an XPath-like query. "XPath-like" means that - * it does not fully comply to XPath standard. - * - * \param xpath should be like `"tag[.=text, @attrib="value", @attrib!='value']/tag..."`. - * *Warning*: the XPath query on node text like `father[child="text"]` should be - * re-written `father/child[.="text"]` instead (which should be XPath-compliant as well). - * \param search The search parameters. - * - * - * \return `true` when `search` was correctly initialized, `false` in case of memory - * problem or malformed `xpath`. - */ -int XMLSearch_init_from_XPath(const SXML_CHAR* xpath, XMLSearch* search); - -/** - * \brief Check whether a node matches a search criteria. - * - * If `search->prev` is not NULL (i.e. has a father search), `node->father` is also - * tested, recursively (i.e. grand-father and so on). - * - * \param node The node to test. `tag_type` should be `TAG_FATHER` or `TAG_SELF` only. - * \param search The search parameters. - * - * \return `false` when `node` does not match or for invalid arguments, `true` - * if `node` is a match. - */ -int XMLSearch_node_matches(const XMLNode* node, const XMLSearch* search); - -/** - * \brief Search next matching node, according to search parameters. - * - * Search starts from node `from` by scanning all its children, and going up to siblings, - * uncles and so on. - * - * Searching for the next matching node is performed by running the search again on the last - * matching node. So `search` has to be initialized by `XMLSearch_init()` prior to the first - * call, to memorize the initial `from` node and know where to stop search. - * `from` ITSELF IS NOT CHECKED! Direct call to `XMLSearch_node_matches(from, search)` should - * be made if necessary. - * - * If the document has several root nodes, a complete search in the document should be performed - * by manually calling `XMLSearch_next()` on each root node in a for loop. - * Note that `search` should be the initial search struct (i.e. `search->prev` should be NULL). This - * cannot be checked corrected by the function itself as it is partly recursive. - * - * \param from The node to start searching from. - * \param search The search parameters. - * - * \return the next matching node according to `search` criteria, or NULL when no more nodes match - * or when an error occurred. - */ -XMLNode* XMLSearch_next(const XMLNode* from, XMLSearch* search); - -/** - * \brief Get node XPath-like equivalent: `tag[.="text", @attribute="value", ...]`, potentially - * including father nodes XPathes. - * - * The computed XPath is stored in a dynamically-allocated string. - * - * \return the XPath, or NULL if `node` is invalid or on memory error. - */ -SXML_CHAR* XMLNode_get_XPath(XMLNode* node, SXML_CHAR** xpath, int incl_parents); - -/** - * Checks whether a string corresponds to a pattern. - * \param str The string to check. - * \param pattern can use wildcads such as `*` (any potentially empty string) or - * `?` (any character) and use `\` as an escape character. - * \returns `true` when `str` matches `pattern`, `false` otherwise. - */ -int regstrcmp(SXML_CHAR* str, SXML_CHAR* pattern); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/trees.h b/include/trees.h deleted file mode 100644 index ce8f620..0000000 --- a/include/trees.h +++ /dev/null @@ -1,128 +0,0 @@ -/* header created automatically with -DGEN_TREES_H */ - -local const ct_data static_ltree[L_CODES+2] = { -{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, -{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, -{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, -{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, -{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, -{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, -{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, -{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, -{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, -{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, -{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, -{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, -{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, -{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, -{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, -{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, -{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, -{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, -{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, -{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, -{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, -{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, -{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, -{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, -{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, -{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, -{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, -{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, -{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, -{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, -{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, -{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, -{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, -{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, -{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, -{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, -{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, -{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, -{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, -{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, -{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, -{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, -{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, -{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, -{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, -{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, -{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, -{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, -{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, -{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, -{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, -{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, -{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, -{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, -{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, -{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, -{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, -{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} -}; - -local const ct_data static_dtree[D_CODES] = { -{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, -{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, -{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, -{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, -{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, -{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} -}; - -const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { - 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, - 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, -10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, -11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, -18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 -}; - -const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { - 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, -13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, -17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, -19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 -}; - -local const int base_length[LENGTH_CODES] = { -0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, -64, 80, 96, 112, 128, 160, 192, 224, 0 -}; - -local const int base_dist[D_CODES] = { - 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, - 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, - 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 -}; - diff --git a/include/zconf.h b/include/zconf.h deleted file mode 100644 index 137d360..0000000 --- a/include/zconf.h +++ /dev/null @@ -1,439 +0,0 @@ -/* zconf.h -- configuration of the zlib compression library - * Copyright (C) 1995-2010 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#ifndef ZCONF_H -#define ZCONF_H - -#ifdef __cplusplus -extern "C" { -#endif -/* - * 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 */ - -/* all linked symbols */ -# define _dist_code z__dist_code -# define _length_code z__length_code -# define _tr_align z__tr_align -# 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 -# define compress z_compress -# define compress2 z_compress2 -# define compressBound z_compressBound -# 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 deflatePrime z_deflatePrime -# define deflateReset z_deflateReset -# 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 -# 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 gzgets z_gzgets -# define gzoffset z_gzoffset -# define gzoffset64 z_gzoffset64 -# define gzopen z_gzopen -# define gzopen64 z_gzopen64 -# define gzprintf z_gzprintf -# 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 -# 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 inflateSync z_inflateSync -# define inflateSyncPoint z_inflateSyncPoint -# define inflateUndermine z_inflateUndermine -# define inflate_copyright z_inflate_copyright -# define inflate_fast z_inflate_fast -# define inflate_table z_inflate_table -# define uncompress z_uncompress -# define zError z_zError -# define zcalloc z_zcalloc -# define zcfree z_zcfree -# 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 -# define gzFile z_gzFile -# 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 - -/* Some Mac compilers merge all .h files incorrectly: */ -#if defined(CS_UNDEFINED_STRING)||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 - -/* 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 - /* 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 - -#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ -# define Z_HAVE_UNISTD_H -#endif - -#if defined(CS_UNDEFINED_STRING) || defined (CS_UNDEFINED_STRING) || defined(CS_UNDEFINED_STRING) || defined(__psp2__) // CTR is Nintendo 3DS. GHS is the Green Hills compiler. PSP2 is the Vita. - typedef long off_t; -#else - #ifdef STDC - #include /* for off_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 -_LARGEFILE64_SOURCE - -1 == 1 -# undef _LARGEFILE64_SOURCE -#endif - -#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) -# include /* for SEEK_* and off_t */ -# ifdef VMS -# include /* for off_t */ -# endif -# ifndef z_off_t -# define z_off_t off_t -# endif -#endif - -#ifndef SEEK_SET -# 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(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 -# define z_off64_t off64_t -#else -# define z_off64_t z_off_t -#endif - -#if defined(__OS400__) -# define NO_vsnprintf -#endif - -#if defined(__MVS__) -# define NO_vsnprintf -#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 - -#ifdef __cplusplus -} -#endif - -#endif /* ZCONF_H */ diff --git a/include/zlib.h b/include/zlib.h deleted file mode 100644 index f50a85a..0000000 --- a/include/zlib.h +++ /dev/null @@ -1,1613 +0,0 @@ -/* zlib.h -- interface of the 'zlib' general purpose compression library - version 1.2.5, April 19th, 2010 - - Copyright (C) 1995-2010 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://www.ietf.org/rfc/rfc1950.txt - (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). -*/ - -#ifndef ZLIB_H -#define ZLIB_H - -#include "zconf.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define ZLIB_VERSION "1.2.5.f-ea" -#define ZLIB_VERNUM 0x125f -#define ZLIB_VER_MAJOR 1 -#define ZLIB_VER_MINOR 2 -#define ZLIB_VER_REVISION 5 -#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 { - Bytef *next_in; /* next input byte */ - uInt avail_in; /* number of bytes available at next_in */ - uLong total_in; /* total nb 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 nb of bytes output so far */ - - 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). If deflate does not return - Z_STREAM_END, then 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 the uncompressed data. (The size - of the uncompressed data may have been saved by the compressor for this - purpose.) The next operation on this stream must be inflateEnd to deallocate - the decompression state. The use of Z_FINISH is never required, but can be - used to inform inflate that a faster approach may be used for the single - inflate() call. - - 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 only effect of the flush parameter in this implementation - is on the return value of inflate(), as noted below, or when it returns early - because Z_BLOCK or Z_TREES is used. - - If a preset dictionary is needed after this call (see inflateSetDictionary - below), inflate sets strm->adler to the adler32 checksum of the dictionary - chosen by the compressor and returns Z_NEED_DICT; otherwise it sets - strm->adler to the adler32 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. - - 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. This function must be called - immediately after deflateInit, deflateInit2 or deflateReset, before any call - of deflate. 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 the compression method is bsort). 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(). -*/ - -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, 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 - immediately after inflateInit2() or inflateReset() and before any call of - inflate() to set the dictionary. 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 inflateSync OF((z_streamp strm)); -/* - Skips invalid compressed data until a full flush point (see above the - description of deflate with Z_FULL_FLUSH) can be found, or until all - available input is skipped. No output is provided. - - inflateSync returns Z_OK if a 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 paramaters 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 *, 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 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. This - function 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) - */ - - - /* 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. -*/ - - - /* 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 voidp gzFile; /* 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.) Also "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. - - 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. - - 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. - - 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 was not in gzip format, gzread copies the given number of - bytes into the buffer. - - After reaching the end of a gzip stream in the input, gzread will continue - to read, looking for another gzip stream, or failing that, reading the rest - of the input file directly without decompression. The entire input file - will be read if gzread is called until it returns less than the requested - len. - - 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 OF((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. -*/ - -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. This state can change from - false to true while reading the input file if the end of a gzip stream is - reached, but is followed by data that is not another gzip stream. - - 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(). -*/ - -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, 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. -*/ - - - /* 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. -*/ - -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 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, sizeof(z_stream)) -#define inflateInit(strm) \ - inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) -#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ - deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ - (strategy), ZLIB_VERSION, sizeof(z_stream)) -#define inflateInit2(strm, windowBits) \ - inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) -#define inflateBackInit(strm, windowBits, window) \ - inflateBackInit_((strm), (windowBits), (window), \ - ZLIB_VERSION, sizeof(z_stream)) - -/* 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 - */ -#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 - 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) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0 -# define gzopen gzopen64 -# define gzseek gzseek64 -# define gztell gztell64 -# define gzoffset gzoffset64 -# define adler32_combine adler32_combine64 -# define crc32_combine crc32_combine64 -# ifdef _LARGEFILE64_SOURCE - 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 - -/* 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 uLongf * ZEXPORT get_crc_table OF((void)); -ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); - -#ifdef __cplusplus -} -#endif - -#endif /* ZLIB_H */ diff --git a/include/zutil.h b/include/zutil.h deleted file mode 100644 index e4abd4b..0000000 --- a/include/zutil.h +++ /dev/null @@ -1,270 +0,0 @@ -/* zutil.h -- internal interface and configuration of the compression library - * Copyright (C) 1995-2010 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* @(#) $Id$ */ - -#ifndef ZUTIL_H -#define ZUTIL_H - -#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) -# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) -#else -# define ZLIB_INTERNAL -#endif - -#include "zlib.h" - -#ifdef STDC -# if !(defined(_WIN32_WCE) && defined(_MSC_VER)) -# include -# endif -# include -# include -#endif - -#ifndef local -# define local static -#endif -/* compile with -Dlocal if your debugger can't find static symbols */ - -typedef unsigned char uch; -typedef uch FAR uchf; -typedef unsigned short ush; -typedef ush FAR ushf; -typedef unsigned long ulg; - -extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ -/* (size given to avoid silly warnings with Visual C++) */ - -#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] - -#define ERR_RETURN(strm,err) \ - return (strm->msg = (char*)ERR_MSG(err), (err)) -/* To be used only when the state is known to be valid */ - - /* common constants */ - -#ifndef DEF_WBITS -# define DEF_WBITS MAX_WBITS -#endif -/* default windowBits for decompression. MAX_WBITS is for compression only */ - -#if MAX_MEM_LEVEL >= 8 -# define DEF_MEM_LEVEL 8 -#else -# define DEF_MEM_LEVEL MAX_MEM_LEVEL -#endif -/* default memLevel */ - -#define STORED_BLOCK 0 -#define STATIC_TREES 1 -#define DYN_TREES 2 -/* The three kinds of block type */ - -#define MIN_MATCH 3 -#define MAX_MATCH 258 -/* The minimum and maximum match lengths */ - -#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ - - /* target dependencies */ - -#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) -# define OS_CODE 0x00 -# if defined(__TURBOC__) || defined(__BORLANDC__) -# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) - /* Allow compilation with ANSI keywords only enabled */ - void _Cdecl farfree( void *block ); - void *_Cdecl farmalloc( unsigned long nbytes ); -# else -# include -# endif -# else /* MSC or DJGPP */ -# include -# endif -#endif - -#ifdef AMIGA -# define OS_CODE 0x01 -#endif - -#if defined(VAXC) || defined(VMS) -# define OS_CODE 0x02 -# define F_OPEN(name, mode) \ - fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") -#endif - -#if defined(ATARI) || defined(atarist) -# define OS_CODE 0x05 -#endif - -#ifdef OS2 -# define OS_CODE 0x06 -# ifdef M_I86 -# include -# endif -#endif - -#if defined(MACOS) || defined(TARGET_OS_MAC) -# define OS_CODE 0x07 -# ifndef fdopen -# define fdopen(fd,mode) NULL /* No fdopen() */ -# endif -#endif - -#ifdef TOPS20 -# define OS_CODE 0x0a -#endif - -#ifdef WIN32 -# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ -# define OS_CODE 0x0b -# endif -#endif - -#ifdef __50SERIES /* Prime/PRIMOS */ -# define OS_CODE 0x0f -#endif - -#if defined(_BEOS_) || defined(RISCOS) -# define fdopen(fd,mode) NULL /* No fdopen() */ -#endif - -#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX -# if defined(_WIN32_WCE) -# define fdopen(fd,mode) NULL /* No fdopen() */ -# ifndef _PTRDIFF_T_DEFINED - typedef int ptrdiff_t; -# define _PTRDIFF_T_DEFINED -# endif -# else -# define fdopen(fd,type) _fdopen(fd,type) -# endif -#endif - -#if defined(__BORLANDC__) - #pragma warn -8004 - #pragma warn -8008 - #pragma warn -8066 -#endif - -/* provide prototypes for these when building zlib without LFS */ -#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); -#endif - - /* common defaults */ - -#ifndef OS_CODE -# define OS_CODE 0x03 /* assume Unix */ -#endif - -#ifndef F_OPEN -# define F_OPEN(name, mode) fopen((name), (mode)) -#endif - - /* functions */ - -#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) -# ifndef HAVE_VSNPRINTF -# define HAVE_VSNPRINTF -# endif -#endif -#if defined(__CYGWIN__) -# ifndef HAVE_VSNPRINTF -# define HAVE_VSNPRINTF -# endif -#endif -#ifndef HAVE_VSNPRINTF -# ifdef MSDOS - /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), - but for now we just assume it doesn't. */ -# define NO_vsnprintf -# endif -# ifdef __TURBOC__ -# define NO_vsnprintf -# endif -# ifdef WIN32 - /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ -# if !defined(vsnprintf) && !defined(NO_vsnprintf) -# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) -# define vsnprintf _vsnprintf -# endif -# endif -# endif -# ifdef __SASC -# define NO_vsnprintf -# endif -#endif -#ifdef VMS -# define NO_vsnprintf -#endif - -#if defined(pyr) -# define NO_MEMCPY -#endif -#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) - /* Use our own functions for small and medium model with MSC <= 5.0. - * You may have to use the same strategy for Borland C (untested). - * The __SC__ check is for Symantec. - */ -# define NO_MEMCPY -#endif -#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) -# define HAVE_MEMCPY -#endif -#ifdef HAVE_MEMCPY -# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ -# define zmemcpy _fmemcpy -# define zmemcmp _fmemcmp -# define zmemzero(dest, len) _fmemset(dest, 0, len) -# else -# define zmemcpy memcpy -# define zmemcmp memcmp -# define zmemzero(dest, len) memset(dest, 0, len) -# endif -#else - void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); - int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); - void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); -#endif - -/* Diagnostic functions */ -#ifdef DEBUG -# include - extern int ZLIB_INTERNAL z_verbose; - extern void ZLIB_INTERNAL z_error OF((char *m)); -# define Assert(cond,msg) {if(!(cond)) z_error(msg);} -# define Trace(x) {if (z_verbose>=0) fprintf x ;} -# define Tracev(x) {if (z_verbose>0) fprintf x ;} -# define Tracevv(x) {if (z_verbose>1) fprintf x ;} -# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} -# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} -#else -# define Assert(cond,msg) -# define Trace(x) -# define Tracev(x) -# define Tracevv(x) -# define Tracec(c,x) -# define Tracecv(c,x) -#endif - - -voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, - unsigned size)); -void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); - -#define ZALLOC(strm, items, size) \ - (*((strm)->zalloc))((strm)->opaque, (items), (size)) -#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) -#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} - -#endif /* ZUTIL_H */ diff --git a/source/libdebugnet/debugnet.c b/source/libdebugnet/debugnet.c deleted file mode 100644 index 837a0c0..0000000 --- a/source/libdebugnet/debugnet.c +++ /dev/null @@ -1,237 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#include -#include -#include -#include -#include -#include - -#include "debugnet.h" - -#define MSG_NOSIGNAL 0x20000 - - -int debugnet_external_conf = 0; -debugNetConfiguration *dconfig = NULL; - -/*static int debugnet_initialized=0; -int SocketFD = -1; -int logLevel=INFO;*/ - -/** - * UDP printf for debugnet library - * - * @par Example: - * @code - * debugNetUDPPrintf("This is a test\n"); - * @endcode - */ -void debugNetUDPPrintf(const char* fmt, ...) -{ - char buffer[0x800]; - va_list arg; - va_start(arg, fmt); - vsnprintf(buffer, sizeof(buffer), fmt, arg); - va_end(arg); - - // if not initialized, fallback to stdio - if(!dconfig) - printf("%s\n", buffer); - else - sceNetSend(dconfig->SocketFD, buffer, strlen(buffer), MSG_NOSIGNAL); -} - -/** - * Log Level printf for debugnet library - * - * @par Example: - * @code - * debugNetPrintf(INFO,"This is a test\n"); - * @endcode - * - * @param level - NONE,INFO,ERROR or DEBUG - */ -void debugNetPrintf(int level, char* format, ...) -{ - char msgbuf[0x800]; - va_list args; - if(dconfig!=NULL) - { - if (level>dconfig->logLevel) - return; - } - - va_start(args, format); - vsnprintf(msgbuf,2048, format, args); - msgbuf[2047] = 0; - va_end(args); - switch(level) - { - case DEBUGNET_INFO: - debugNetUDPPrintf("[ORBIS][INFO]: %s",msgbuf); - break; - case DEBUGNET_ERROR: - debugNetUDPPrintf("[ORBIS][ERROR]: %s",msgbuf); - break; - case DEBUGNET_DEBUG: - debugNetUDPPrintf("[ORBIS][DEBUG]: %s",msgbuf); - break; - case DEBUGNET_NONE: - break; - default: - debugNetUDPPrintf("%s",msgbuf); - } -} - -/** - * Set log level for debugnet library - * - * @par Example: - * @code - * debugNetSetLogLevel(DEBUG); - * @endcode - * @param level - DEBUG,ERROR,INFO or NONE - */ -void debugNetSetLogLevel(int level) -{ - if(dconfig) - { - dconfig->logLevel=level; - } -} - -/** - * Init debugnet library - * - * @par Example: - * @code - * #define LOGLEVEL 3 - * int ret; - * ret = debugNetInit("172.26.0.2", 18194, DEBUG); - * @endcode - * - * @param serverIP - your pc/mac server ip - * @param port - udp port server - * @param level - DEBUG,ERROR,INFO or NONE - */ -int debugNetInit(char *serverIp, int port, int level) -{ - // struct SceNetSockaddrIn stSockAddr; SceNet data types not yet in libps3 - struct sockaddr_in stSockAddr; - if(debugNetCreateConf()) - { - return dconfig->debugnet_initialized; - } - - debugNetSetLogLevel(level); - - //network initialization code is not needed on PS4 is started at boot - - /* Create datagram udp socket*/ - dconfig->SocketFD = sceNetSocket("debugnet_socket",AF_INET , SOCK_DGRAM, IPPROTO_UDP); - - memset(&stSockAddr, 0, sizeof stSockAddr); - - /*Populate SceNetSockaddrIn structure values*/ - - stSockAddr.sin_family = AF_INET; - stSockAddr.sin_port = sceNetHtons(port); - sceNetInetPton(AF_INET, serverIp, &stSockAddr.sin_addr); - - /*Connect socket to server*/ - sceNetConnect(dconfig->SocketFD, (struct sockaddr *)&stSockAddr, sizeof stSockAddr); - - /*Show log on pc/mac side*/ - debugNetPrintf(DEBUGNET_INFO,"debugnet initialized\n"); - debugNetPrintf(DEBUGNET_INFO,"Copyright (C) 2010,2016 Antonio Jose Ramos Marquez aka bigboss @psxdev\n"); - debugNetPrintf(DEBUGNET_INFO,"ready to have a lot of fun...\n"); - - /*library debugnet initialized*/ - dconfig->debugnet_initialized = 1; - - return dconfig->debugnet_initialized; -} - -debugNetConfiguration *debugNetGetConf() -{ - if(dconfig) - { - return dconfig; - } - return NULL; -} - -int debugNetSetConf(debugNetConfiguration *conf) -{ - if(conf) - { - dconfig=conf; - debugnet_external_conf=1; - return dconfig->debugnet_initialized; - } - return 0; -} - -int debugNetInitWithConf(debugNetConfiguration *conf) -{ - int ret; - ret=debugNetSetConf(conf); - if(ret) - { - debugNetPrintf(DEBUGNET_INFO,"debugnet already initialized using configuration from ps4link\n"); - debugNetPrintf(DEBUGNET_INFO,"debugnet_initialized=%d SocketFD=%d logLevel=%d\n",dconfig->debugnet_initialized,dconfig->SocketFD,dconfig->logLevel); - debugNetPrintf(DEBUGNET_INFO,"ready to have a lot of fun...\n"); - return dconfig->debugnet_initialized; - } - else - { - return 0; - } - -} - -int debugNetCreateConf() -{ - if(!dconfig) - { - dconfig=malloc(sizeof(debugNetConfiguration)); - dconfig->debugnet_initialized=0; - dconfig->SocketFD = -1; - dconfig->logLevel=DEBUGNET_INFO; - return 0; - } - - if(dconfig->debugnet_initialized) - { - return 1; - } - return 0; -} - -/** - * Finish debugnet library - * - * @par Example: - * @code - * debugNetFinish(); - * @endcode - */ -void debugNetFinish() -{ - if(!debugnet_external_conf) - { - if (dconfig->debugnet_initialized) { - dconfig->debugnet_initialized = 0; - dconfig->SocketFD=-1; - } - } -} diff --git a/source/libkernelutil/Syscall.s b/source/libkernelutil/Syscall.s deleted file mode 100644 index d34186f..0000000 --- a/source/libkernelutil/Syscall.s +++ /dev/null @@ -1,17 +0,0 @@ -.text - -.global mysyscall -mysyscall: - movq $0, %rax - movq %rcx, %r10 - syscall - jb err - retq -err: - pushq %rax - callq __error - popq %rcx - movl %ecx, 0(%rax) - movq $0xFFFFFFFFFFFFFFFF, %rax - movq $0xFFFFFFFFFFFFFFFF, %rdx - retq diff --git a/source/libkernelutil/module.c b/source/libkernelutil/module.c deleted file mode 100644 index ac66cde..0000000 --- a/source/libkernelutil/module.c +++ /dev/null @@ -1,127 +0,0 @@ -#include -#include -#include -#include -int mysyscall(int num, ...); - -int sceKernelGetModuleInfo(SceKernelModule handle, SceKernelModuleInfo* info) { - int ret; - - if (!info) { - ret = 0x8002000E; - goto err; - } - - memset(info, 0, sizeof(*info)); - { - info->size = sizeof(*info); - } - - ret = mysyscall(593, handle, info); /* TODO: make proper error code */ - -err: - return ret; -} - -int sceKernelGetModuleInfoByName(const char* name, SceKernelModuleInfo* info) { - SceKernelModuleInfo tmpInfo; - SceKernelModule handles[256]; - size_t numModules; - size_t i; - int ret; - - if (!name) { - ret = 0x8002000E; - goto err; - } - if (!info) { - ret = 0x8002000E; - goto err; - } - - memset(handles, 0, sizeof(handles)); - - ret = sceKernelGetModuleList(handles, ARRAY_SIZE(handles), &numModules); - if (ret) { - goto err; - } - - for (i = 0; i < numModules; ++i) { - ret = sceKernelGetModuleInfo(handles[i], &tmpInfo); - if (ret) { - goto err; - } - - if (strcmp(tmpInfo.name, name) == 0) { - memcpy(info, &tmpInfo, sizeof(tmpInfo)); - ret = 0; - goto err; - } - } - - ret = 0x80020002; - -err: - return ret; -} - -int sceKernelGetModuleInfoEx(SceKernelModule handle, SceKernelModuleInfoEx* info) { - int ret; - - if (!info) { - ret = 0x8002000E; - goto err; - } - - memset(info, 0, sizeof(*info)); - { - info->size = sizeof(*info); - } - - ret = mysyscall(608, handle, info); /* TODO: make proper error code */ - -err: - return ret; -} - -int sceKernelGetModuleInfoExByName(const char* name, SceKernelModuleInfoEx* info) { - SceKernelModuleInfoEx tmpInfo; - SceKernelModule handles[256]; - size_t numModules; - size_t i; - int ret; - - if (!name) { - ret = 0x8002000E; - goto err; - } - if (!info) { - ret = 0x8002000E; - goto err; - } - - memset(handles, 0, sizeof(handles)); - - ret = sceKernelGetModuleList(handles, ARRAY_SIZE(handles), &numModules); - if (ret) { - goto err; - } - - for (i = 0; i < numModules; ++i) { - ret = sceKernelGetModuleInfoEx(handles[i], &tmpInfo); - if (ret) { - goto err; - } - - if (strcmp(tmpInfo.name, name) == 0) { - memcpy(info, &tmpInfo, sizeof(tmpInfo)); - ret = 0; - goto err; - } - } - - ret = 0x80020002; - -err: - return ret; -} diff --git a/source/libmod/modplayer.c b/source/libmod/modplayer.c deleted file mode 100644 index 711649e..0000000 --- a/source/libmod/modplayer.c +++ /dev/null @@ -1,1094 +0,0 @@ -// modplayer.c: Module Player Implementation in C for Sony PlayStation 4 -// -// based on "PSP ModPlayer v1.0" by adresd -// -// Much of the information in this file (particularly the code used to do -// the effects) came from Brett Paterson's MOD Player Tutorial. -// Also contains some code by Mark Feldman, which is not subject to a license -// of any kind. -// -// This is not the most efficient bit of code in the world and there are a lot -// of optimisations that could be done, but it is released as a working -// modplayer for PSP which can be used and expanded upon by others. -// I would ask that anyone who expands or improves it considers releasing -// an updated version of the source, as a courtesy. -// -// This code is released with no implied warranty or assurance that it works -// it is not subject to any GPL or suchlike license, so use and enjoy. -// -// -- adresd -//////////////////////////////////////////////////////////////////////////// - -//#include -//#include -#include -#include -#include -//#include -//#include -#include -#include -//#include -#include -#include -#include - -#include "modplayer.h" -#include "modplayeri.h" -#include "modtables.h" - -typedef unsigned char u8; -#define FALSE 0 -#define TRUE !FALSE -#define min(a,b) (((a)<(b))?(a):(b)) -#define max(a,b) (((a)>(b))?(a):(b)) - -/* Define printf, just to make typing easier */ -//#define printf debugNetUDPPrintf - -// As a sample is being mixed into the buffer it's position pointer is updated. -// The position pointer is a 32-bit integer that is used to store a fixed-point -// number. The following constant specifies how many of the bits should be used -// for the fractional part. -#define FRAC_BITS 10 - -#define NUMCHANNELS 2 - -// This #define is used to convert an Amiga period number to a frequency. -// The freqency returned is the frequency that the sample should be played at. -// 3579545.25f / 428 = 8363.423 Hz for Middle C (PAL) -#define Period2Freq(period) (3579545.25f / (period)) - -////////////////////////////////////////////////////////////////////// -// Function Prototypes -////////////////////////////////////////////////////////////////////// -static void SetMasterVolume(int volume); -static int ReadModWord(unsigned char *data, int index); -static void DoTremalo(int track); -static void DoVibrato(int track); -static void DoPorta(int track); -static void SlideVolume(int track, int amount); -static int VolumeTable[65][256]; -static void UpdateEffects(); -static void UpdateRow(); -static int MixChunk(int numsamples, short *buffer); - - -//static void ModPlayCallback(short *_buf, unsigned long length); -static void ModPlayCallback(OrbisAudioSample *_buf2, unsigned int length,void *userdata); - -static int MixSubChunk(short *buffer, int numsamples); - -////////////////////////////////////////////////////////////////////// -// Global local variables -////////////////////////////////////////////////////////////////////// - -// The following variables contain the music data, ie they don't change value until you load a new file -static char m_szName[200]; -static int m_nSongLength; - -static int m_nOrders_num; -static int *m_nOrders; -static int m_Patterns_num; -static Pattern *m_Patterns; -static int m_Samples_num; -static Sample *m_Samples; - -// The following variables are maintained and updated by the tracker during playback -static int m_nSpeed; // Speed of mod being played -static int m_nOrder; // Current order being played -static int m_nRow; // Current row being played -static int m_nTick; // Current tick number (there are "m_nSpeed" -// ticks between each row) -static int BPM_RATE; // Adjusted master BPM for refresh rate -static int m_nBPM; // Beats-per-minute...controls length of -// each tick -static int m_nSamplesLeft; // Number of samples left to mix for the -// current tick -static int m_nNumTracks; // Number of tracks in this mod - -static int m_TrackDat_num; -static TrackData *m_TrackDat; // Stores info for each track being played -static RowData *m_CurrentRow; // Pointer to the current row being played -static int m_bPlaying; // Set to true when a mod is being played -static u8 *data; -int size = 0; -////////////////////////////////////////////////////////////////////// -// These are the public functions -////////////////////////////////////////////////////////////////////// - -void MODsetStubs(codecStubs * stubs) -{ - stubs->init = Mod_Init; - stubs->load = Mod_Load; - stubs->play = Mod_Play; - stubs->pause = Mod_Pause; - stubs->stop = Mod_Stop; - stubs->end = Mod_End; - stubs->time = Mod_GetTimeString; - stubs->tick = NULL; - stubs->eos = Mod_EndOfStream; - memcpy(stubs->extension, "mod\0" "\0\0\0\0", 2 * 4); -} - -int Mod_EndOfStream() -{ - return 0; -} - -void Mod_GetTimeString(char *dest) -{ - *dest = '\0'; - //HH:MM:SS - sprintf(dest, "%02d:%02d:%02d", m_nOrder, m_nRow, m_nTick); -} - -void Mod_DebugPrint() -{ - int count; - // int x, y; - printf("\nName : %s\n", m_szName); - printf("Num Tracks : %d\n", m_nNumTracks); - printf("Num Samples: %d\n\n", m_Samples_num); - - // x = pspDebugScreenGetX(); - //y = pspDebugScreenGetY(); - for (count = 1; count < m_Samples_num; count++) { - if (count == (m_Samples_num / 2)) { - // x += 30; - // y -= count; - printf("\n"); - } -// pspDebugScreenSetXY(x, y + count); - printf(" %02d - %s", count, m_Samples[count].szName); - } - printf("finishing Mod_DebugPrint \n"); -} - -void Mod_Init(int channel) -{ - modplayint_channel = channel; - m_bPlaying = FALSE; - //pspAudioSetChannelCallback(modplayint_channel, ModPlayCallback,0); - //pl_snd_set_callback(modplayint_channel, ModPlayCallback,0); - orbisAudioSetCallback(modplayint_channel, ModPlayCallback,0); - - //Mod_Load("",data); -} - -void Mod_FreeTune() -{ - int i; - int row; - - // Tear down all the mallocs done - //free the file itself - if (data) - free(data); - // Free patterns - for (i = 0; i < m_Patterns_num; i++) { - for (row = 0; row < 64; row++) - free(m_Patterns[i].row[row].note); - free(m_Patterns[i].row); - } - // Free orders - free(m_nOrders); - - // Free samples - for (i = 1; i < m_Samples_num; i++) - free(m_Samples[i].data); - free(m_Samples); - - // Free tracks - free(m_TrackDat); -} - -void Mod_End() -{ - Mod_Stop(); - //pspAudioSetChannelCallback(modplayint_channel, 0,0); - //pl_snd_set_callback(modplayint_channel, 0,0); - orbisAudioSetCallback(modplayint_channel, 0,0); - - Mod_FreeTune(); -} - -//static void ModPlayCallback(void *_buf2, unsigned int length, void *pdata) -static void ModPlayCallback(OrbisAudioSample *_buf2, unsigned int length,void *pdata) -{ - //debugNetPrintf(3,"Inside ModPlayCallback %d\n",length); - short *_buf = (short *)_buf2; - if (m_bPlaying == TRUE) { // Playing , so mix up a buffer - // debugNetPrintf(3,"Inside ModPlayCallback m_bPlaying is %d\n",m_bPlaying); - - MixChunk(length, _buf); - } - else // Not Playing , so clear buffer - { - //debugNetPrintf(3,"Inside ModPlayCallback not playing m_bPlaying is %d\n",m_bPlaying); - - int count; - for (count = 0; count < length * 2; count++) - *(_buf + count) = 0; - - } -} - - -////////////////////////////////////////////////////////////////////// -// Functions - Local and not public -////////////////////////////////////////////////////////////////////// - -// This is the initialiser and module loader -// This is a general call, which loads the module from the -// given address into the modplayer -// -// It basically loads into an internal format, so once this function -// has returned the buffer at 'data' will not be needed again. -int Mod_Load(char *filename) -{ - int i, numpatterns, row, note; - int index = 0; - int numsamples; - char modname[21]; - int fd; - if ((fd = orbisNfsOpen(filename, O_RDONLY, 0)) > 0) { - // opened file, so get size now - size = orbisNfsLseek(fd, 0, SEEK_END); - orbisNfsLseek(fd, 0, SEEK_SET); - data = (unsigned char *) malloc(size + 8); - memset(data, 0, size + 8); - if (data != 0) { // Read file in - orbisNfsRead(fd, data, size); - } else { - printf("Error allocing\n"); - orbisNfsClose(fd); - return 0; - } - // Close file - orbisNfsClose(fd); - } else { //if we couldn't open the file - return 0; - } - - //BPM_RATE = 130; - BPM_RATE = 125; //PAL - // Set default settings - numsamples = 32; - m_nNumTracks = 4; - // Check for diff types of mod - if ((data[1080] == 'M') && (data[1081] == '.') && (data[1082] == 'K') && (data[1083] == '.')); - else if ((data[1080] == 'F') && (data[1081] == 'L') && (data[1082] == 'T') && (data[1083] == '4')); - else if ((data[1080] == 'F') && (data[1081] == 'L') && (data[1082] == 'T') && (data[1083] == '8')) - m_nNumTracks = 8; - else if ((data[1080] == '6') && (data[1081] == 'C') && (data[1082] == 'H') && (data[1083] == 'N')) - m_nNumTracks = 6; - else if ((data[1080] == '8') && (data[1081] == 'C') && (data[1082] == 'H') && (data[1083] == 'N')) - m_nNumTracks = 8; - else - numsamples = 16; - - // Setup the trackdata structure - m_TrackDat_num = m_nNumTracks; - m_TrackDat = (TrackData *) malloc(m_TrackDat_num * sizeof(TrackData)); - - // Get the name - memcpy(modname, &data[index], 20); - modname[20] = 0; - strcpy(m_szName, modname); - index += 20; - - // Read in all the instrument headers - mod files have 31, sample #0 is ignored - m_Samples_num = numsamples; - m_Samples = (Sample *) malloc(m_Samples_num * sizeof(Sample)); - for (i = 1; i < numsamples; i++) { - // Read the sample name - char samplename[23]; - memcpy(samplename, &data[index], 22); - samplename[22] = 0; - strcpy(m_Samples[i].szName, samplename); - index += 22; - - // Read remaining info about sample - m_Samples[i].nLength = ReadModWord(data, index); - index += 2; - m_Samples[i].nFineTune = (int) (unsigned char) *(data + index); - index++; - if (m_Samples[i].nFineTune > 7) - m_Samples[i].nFineTune -= 16; - m_Samples[i].nVolume = (int) (unsigned char) *(data + index); - index++; - m_Samples[i].nLoopStart = ReadModWord(data, index); - index += 2; - m_Samples[i].nLoopLength = ReadModWord(data, index); - index += 2; - m_Samples[i].nLoopEnd = m_Samples[i].nLoopStart + m_Samples[i].nLoopLength; - - // Fix loop end in case it goes too far - if (m_Samples[i].nLoopEnd > m_Samples[i].nLength) - m_Samples[i].nLoopEnd = m_Samples[i].nLength; - } - - // Read in song data - m_nSongLength = (int) (unsigned char) *(data + index); - index++; - index++; // Skip over this byte, it's no longer used - - numpatterns = 0; - m_nOrders_num = 128; - m_nOrders = (int *) malloc(m_nOrders_num * sizeof(int)); - for (i = 0; i < 128; i++) { - m_nOrders[i] = (int) (unsigned char) *(data + index); - index++; - if (m_nOrders[i] > numpatterns) - numpatterns = m_nOrders[i]; - } - numpatterns++; - index += 4; // skip over the identifier - - // Load in the pattern data - m_Patterns_num = numpatterns; - m_Patterns = (Pattern *) malloc(m_Patterns_num * sizeof(Pattern)); - for (i = 0; i < numpatterns; i++) { - // Set the number of rows for this pattern, for mods it's always 64 - m_Patterns[i].numrows = 64; - m_Patterns[i].row = (RowData *) malloc(m_Patterns[i].numrows * sizeof(RowData)); - - // Loop through each row - for (row = 0; row < 64; row++) { - // Set the number of notes for this pattern - m_Patterns[i].row[row].numnotes = m_nNumTracks; - m_Patterns[i].row[row].note = (NoteData *) malloc(m_Patterns[i].row[row].numnotes * sizeof(NoteData)); - - // Loop through each note - for (note = 0; note < m_nNumTracks; note++) { - int b0, b1, b2, b3, period; - // Get the 4 bytes for this note - b0 = (int) (unsigned char) *(data + index); - b1 = (int) (unsigned char) *(data + index + 1); - b2 = (int) (unsigned char) *(data + index + 2); - b3 = (int) (unsigned char) *(data + index + 3); - index += 4; - - // Parse them - period = ((b0 & 0x0F) << 8) | b1; - if (period) - //m_Patterns[i].row[row].note[note].period_index = (int)((log(856) - log(period)) / log(1.007246412224) + 8);// ?? - m_Patterns[i].row[row].note[note].period_index = Period_Log_Lookup[period]; - else - m_Patterns[i].row[row].note[note].period_index = -1; - - m_Patterns[i].row[row].note[note].sample_num = (b0 & 0xF0) | (b2 >> 4); - m_Patterns[i].row[row].note[note].effect = b2 & 0x0F; - m_Patterns[i].row[row].note[note].effect_parms = b3; - } - } - } - - // Load in the sample data - for (i = 1; i < numsamples; i++) { - int length; - m_Samples[i].data_length = m_Samples[i].nLength; - m_Samples[i].data = (char *) malloc(m_Samples[i].data_length + 1); - - if (m_Samples[i].nLength) { - memcpy(&m_Samples[i].data[0], &data[index], m_Samples[i].nLength); - } - index += m_Samples[i].nLength; - - // Duplicate the last byte, we'll need an extra one in order to safely anti-alias - length = m_Samples[i].nLength; - if (length > 0) { - m_Samples[i].data[length] = m_Samples[i].data[length - 1]; - - if (m_Samples[i].nLoopLength > 2) - m_Samples[i].data[m_Samples[i].nLoopEnd] = m_Samples[i].data[m_Samples[i].nLoopStart]; - } - } - // Set volume to full ready to play - SetMasterVolume(64); - m_bPlaying = FALSE; - return 1; -} - -// This function initialises for playing, and starts -int Mod_Play() -{ - debugNetPrintf(3,"In play %d\n",m_bPlaying); - int track; - // See if I'm already playing - if (m_bPlaying) - return FALSE; - - - // Reset all track data - for (track = 0; track < m_nNumTracks; track++) { - m_TrackDat[track].sample = 0; - m_TrackDat[track].pos = 0; - m_TrackDat[track].period_index = 0; - m_TrackDat[track].period = 0; - m_TrackDat[track].volume = 0; - m_TrackDat[track].mixvol = 0; - m_TrackDat[track].porta = 0; - m_TrackDat[track].portasp = 0; - m_TrackDat[track].vibspe = 0; - m_TrackDat[track].vibdep = 0; - m_TrackDat[track].tremspe = 0; - m_TrackDat[track].tremdep = 0; - m_TrackDat[track].panval = 0; - m_TrackDat[track].freq = 0; - m_TrackDat[track].sinepos = 0; - m_TrackDat[track].sineneg = 0; - } - - // Get ready to play - m_nSpeed = 6; - m_nBPM = BPM_RATE; - m_nSamplesLeft = 0; - m_nOrder = 0; - m_nRow = 0; - m_CurrentRow = &m_Patterns[m_nOrders[m_nOrder]].row[m_nRow]; - m_nTick = 0; - - Mod_DebugPrint(); - { - m_bPlaying = TRUE; - debugNetPrintf(3,"In play m_bPlaying %d\n",m_bPlaying); - - return TRUE; - } - debugNetPrintf(3,"Inside Mod_Play something went wrong m_bPlaying is %d\n",m_bPlaying); - - // Oops...something went wrong. - return FALSE; -} - -void Mod_Pause() -{ - m_bPlaying = !m_bPlaying; -} - -int Mod_Stop() -{ - // Close it - m_bPlaying = FALSE; - return TRUE; -} - -// This function mixes an entire chunk of sound which is then -// to be sent to the sound driver, in this case the IOP module. -static int MixChunk(int numsamples, short *buffer) -{ - // Calculate the number of samples per beat - // 48000 / (125 * 2 / 5) = 48000/ 50 = 960 - int samples_per_beat = PLAYBACK_FREQ / (m_nBPM * 2 / 5); - - int thiscount; - // Keep looping until we've filled the buffer - int tickdata = 0; - int samples_to_mix = numsamples; - - while (samples_to_mix) { - // Only move on to the next tick if we finished mixing the last - if (!m_nSamplesLeft) { - // If we're on tick 0 then update the row - if (m_nTick == 0) { - // Get this row - m_CurrentRow = &m_Patterns[m_nOrders[m_nOrder]].row[m_nRow]; - - // Set up for next row (effect might change these values later) - m_nRow++; - if (m_nRow >= 64) { - m_nRow = 0; - m_nOrder++; - if (m_nOrder >= m_nSongLength) - m_nOrder = 0; - } - // Now update this row - UpdateRow(); - } - // Otherwise, all we gotta do is update the effects - else { - UpdateEffects(); - } - - // Move on to next tick - m_nTick++; - if (m_nTick >= m_nSpeed) - m_nTick = 0; - - // Set the number of samples to mix in this chunk - m_nSamplesLeft = samples_per_beat; - } - // Ok, so we know that we gotta mix 'm_nSamplesLeft' samples into - // this buffer, see how much room we actually got - thiscount = m_nSamplesLeft; - if (thiscount > samples_to_mix) - thiscount = samples_to_mix; - - // Make a note that we've added this amount - m_nSamplesLeft -= thiscount; - samples_to_mix -= thiscount; - //debugNetPrintf(3,"Inside MixChunk tickdata is %d\n",tickdata); - - // Now mix it! - MixSubChunk(&buffer[tickdata * 2], thiscount); - tickdata += thiscount; - } - return TRUE; -} - -// This function is called whenever a new row is encountered. -// It loops through each track, check's it's appropriate NoteData structure -// and updates the track accordingly. -static void UpdateRow() -{ - int neworder = m_nOrder; - int newrow = m_nRow; - int track; - - // Loop through each track - for (track = 0; track < m_nNumTracks; track++) { - // Get note data - NoteData *note = &m_CurrentRow->note[track]; - - // Make a copy of each value in the NoteData structure so they'll - // be easier to work with (less typing) - int sample = note->sample_num; - int period = note->period_index; - int effect = note->effect; - int eparm = note->effect_parms; - int eparmx = eparm >> 4; // effect parameter x - int eparmy = eparm & 0xF; // effect parameter y - - // Are we changing the sample being played? - if (sample > 0) { - m_TrackDat[track].sample = sample; - m_TrackDat[track].volume = m_Samples[sample].nVolume; - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - if ((effect != 3) && (effect != 5)) - m_TrackDat[track].pos = 0; - } - // Are we changing the frequency being played? - if (period >= 0) { - // Remember the note - m_TrackDat[track].period_index = note->period_index; - - // If not a porta effect, then set the channels frequency to the - // looked up amiga value + or - any finetune - if ((effect != 3) && (effect != 5)) { - int notenum = m_TrackDat[track].period_index + m_Samples[m_TrackDat[track].sample].nFineTune; - if (notenum < 0) - notenum = 0; - if (notenum > NUMNOTES - 1) - notenum = NUMNOTES - 1; - m_TrackDat[track].period = PeriodTable[notenum]; - } - // If there is no sample number or effect then we reset the position - if ((sample == 0) && (effect == 0)) - m_TrackDat[track].pos = 0; - - // Now reset a few things - m_TrackDat[track].vibspe = 0; - m_TrackDat[track].vibdep = 0; - m_TrackDat[track].tremspe = 0; - m_TrackDat[track].tremdep = 0; - m_TrackDat[track].sinepos = 0; - m_TrackDat[track].sineneg = 0; - } - // Process any effects - need to include 1, 2, 3, 4 and A - switch (note->effect) { - // Arpeggio - case 0x00: - break; // tick effect - - // Porta Up - case 0x01: - break; // tick effect - - // Porta Down - case 0x02: - break; // tick effect - - // Porta to Note (3) and Porta + Vol Slide (5) - case 0x03: - case 0x05: - m_TrackDat[track].porta = PeriodTable[m_TrackDat[track].period_index + m_Samples[sample].nFineTune]; - if (eparm > 0 && effect == 0x3) - m_TrackDat[track].portasp = eparm; - break; - - // Vibrato - case 0x04: - if (eparmx > 0) - m_TrackDat[track].vibspe = eparmx; - if (eparmy > 0) - m_TrackDat[track].vibdep = eparmy; - break; - - // Vibrato + Vol Slide - case 0x06: - break; // tick effect - - // Tremolo - case 0x07: - if (eparmx > 0) - m_TrackDat[track].tremspe = eparmx; - if (eparmy > 0) - m_TrackDat[track].tremdep = eparmy; - break; - - // Pan - not supported in the mixing yet - case 0x08: - if (eparm == 0xa4) - m_TrackDat[track].panval = 7; - else - m_TrackDat[track].panval = (eparm >> 3) - 1; - if (m_TrackDat[track].panval < 0) - m_TrackDat[track].panval = 0; - break; - - // Sample offset - case 0x09: - m_TrackDat[track].pos = note->effect_parms << (FRAC_BITS + 8); - break; - - // Volume Slide - case 0x0A: - break; // tick effect - - // Jump To Pattern - case 0x0B: - neworder = note->effect_parms; - if (neworder >= m_nSongLength) - neworder = 0; - newrow = 0; - - // Set Volume - case 0x0C: - m_TrackDat[track].volume = note->effect_parms; - SlideVolume(track, 0); - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - break; - - // Break from current pattern - case 0x0D: - newrow = eparmx * 10 + eparmy; - if (newrow > 63) - newrow = 0; - neworder = m_nOrder + 1; - if (neworder >= m_nSongLength) - neworder = 0; - break; - - // Extended effects - case 0x0E: - switch (eparmx) { - // Set filter - case 0x00: - break; // not supported - - // Fine porta up - case 0x01: - m_TrackDat[track].period -= eparmy; - break; - - // Fine porta down - case 0x02: - m_TrackDat[track].period += eparmy; - break; - - // Glissando - case 0x03: - break; // not supported - - - // Set vibrato waveform - case 0x04: - break; // not supported - - // Set finetune - case 0x05: - m_Samples[sample].nFineTune = eparmy; - if (m_Samples[sample].nFineTune > 7) - m_Samples[sample].nFineTune -= 16; - break; - - // Pattern loop - case 0x6: - break; // not supported - - // Set tremolo waveform - case 0x07: - break; // not supported - - // Pos panning - not supported in the mixing yet - case 0x08: - m_TrackDat[track].panval = eparmy; - break; - - // Retrig Note - case 0x09: - break; // tick effect - - // Fine volside up - case 0x0A: - SlideVolume(track, eparmy); - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - break; - - // Fine volside down - case 0xB: - SlideVolume(track, -eparmy); - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - break; - - // Cut note - case 0x0C: - break; // tick effect - - // Delay note - case 0x0D: - break; // not supported - - // Pattern delay - case 0x0E: - break; // not supported - - // Invert loop - case 0x0F: - break; // not supported - } - break; - - // Set Speed - case 0x0F: - if (eparm < 0x20) - m_nSpeed = note->effect_parms; - else - m_nBPM = note->effect_parms; - break; - - default: - break; - } - - // If we have something playing then set the frequency - if (m_TrackDat[track].period > 0) - m_TrackDat[track].freq = Period2Freq(m_TrackDat[track].period); - } - - // Update our row and orders - m_nRow = newrow; - m_nOrder = neworder; -} - -static int MixSubChunk(short *buffer, int numsamples) -{ - int i, track; - // Setup left and right channels - short *left; - short *right; - left = buffer; - right = buffer+1; - // Set up a mixing buffer and clear it - for (i = 0; i < numsamples * 2; i++) - buffer[i]= 0; - - // Loop through each channel and process note data - for (track = 0; track < m_nNumTracks; track++) { - // Make sure I'm actually playing something - if (m_TrackDat[track].sample <= 0) - continue; - - // Make sure this sample actually contains sound data - if (!m_Samples[m_TrackDat[track].sample].data_length) - continue; - { - // Set up for the mix loop - short *mixed = ((track & 3) == 0) - || ((track & 3) == 3) ? left : right; - unsigned char *sample = (unsigned char *) &m_Samples[m_TrackDat[track].sample].data[0]; - int nLength = m_Samples[m_TrackDat[track].sample].nLength << FRAC_BITS; - int nLoopLength = m_Samples[m_TrackDat[track].sample].nLoopLength << FRAC_BITS; - int nLoopEnd = m_Samples[m_TrackDat[track].sample].nLoopEnd << FRAC_BITS; - int finetune = m_Samples[m_TrackDat[track].sample].nFineTune; - int notenum = m_TrackDat[track].period_index + finetune; - float freq = m_TrackDat[track].freq; - int pos = m_TrackDat[track].pos; - int deltapos = (int) (freq * (1 << FRAC_BITS) / PLAYBACK_FREQ); - int *VolumeTablePtr = VolumeTable[m_TrackDat[track].mixvol]; - int mixpos = 0; - int samples_to_mix = numsamples; - notenum = notenum < 0 ? 0 : notenum >= NUMNOTES ? NUMNOTES - 1 : notenum; - - while (samples_to_mix) { - int thiscount; - - // If I'm a looping sample then I need to check if it's time to - // loop back. I also need to figure out how many samples I can mix - // before I need to loop again - if (nLoopEnd > (2 << FRAC_BITS)) { - if (pos >= nLoopEnd) - pos -= nLoopLength; - thiscount = min(samples_to_mix, (nLoopEnd - pos - 1) / deltapos + 1); - // above returns the smaller parameter - - samples_to_mix -= thiscount; - } - // If I'm not a looping sample then mix until I'm done playing - // the entire sample - else { - // If we've already reached the end of the sample then forget it - if (pos >= nLength) - thiscount = 0; - else - thiscount = min(numsamples, (nLength - pos - 1) / deltapos + 1); - samples_to_mix = 0; - } - - // Inner Loop start - for (i = 0; i < thiscount; i++) { - // Mix this sample in and update our position -#ifdef OVERSAMPLE - // This smooths the sound a bit by oversampling, but - // uses up more cpu (only a bit) - int sample1 = VolumeTablePtr[sample[pos >> FRAC_BITS]]; - int sample2 = VolumeTablePtr[sample[(pos >> FRAC_BITS) + 1]]; - int frac1 = pos & ((1 << FRAC_BITS) - 1); - int frac2 = (1 << FRAC_BITS) - frac1; - mixed[mixpos] += ((sample1 * frac2) + (sample2 * frac1)) >> FRAC_BITS; - mixpos += 2; -#else - // This is normal plain mixing - mixed[mixpos] += VolumeTablePtr[sample[pos >> FRAC_BITS]]; - mixpos += 2; -#endif - pos += deltapos; - } - // Inner Loop end - } - // Save current position - m_TrackDat[track].pos = pos; - } - } - - return TRUE; -} - -static void UpdateEffects() -{ - int track; - // Loop through each channel - for (track = 0; track < m_nNumTracks; track++) { - // Get note data - NoteData *note = &m_CurrentRow->note[track]; - - // Parse it - int effect = note->effect; // grab the effect number - int eparm = note->effect_parms; // grab the effect parameter - int eparmx = eparm >> 4; // grab the effect parameter x - int eparmy = eparm & 0xF; // grab the effect parameter y - - // Process it - switch (effect) { - // Arpeggio - case 0x00: - if (eparm > 0) { - int notenum, period; - switch (m_nTick % 3) { - case 0: - period = m_TrackDat[track].period; - break; - case 1: - notenum = - m_TrackDat[track].period_index + 8 * eparmx + m_Samples[m_TrackDat[track].sample].nFineTune; - period = PeriodTable[notenum]; - break; - case 2: - notenum = - m_TrackDat[track].period_index + 8 * eparmy + m_Samples[m_TrackDat[track].sample].nFineTune; - period = PeriodTable[notenum]; - break; - default: - period = 0; - break; - } - m_TrackDat[track].freq = Period2Freq(period); - } - break; - - - // Porta up - case 0x01: - m_TrackDat[track].period -= eparm; // subtract freq - if (m_TrackDat[track].period < 54) - m_TrackDat[track].period = 54; // stop at C-5 - m_TrackDat[track].freq = Period2Freq(m_TrackDat[track].period); - break; - - // Porta down - case 0x02: - m_TrackDat[track].period += eparm; // add freq - m_TrackDat[track].freq = Period2Freq(m_TrackDat[track].period); - break; - - // Porta to note - case 0x03: - DoPorta(track); - break; - - // Vibrato - case 0x04: - DoVibrato(track); - break; - - // Porta + Vol Slide - case 0x05: - DoPorta(track); - SlideVolume(track, eparmx - eparmy); - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - break; - - // Vibrato + Vol Slide - case 0x06: - DoVibrato(track); - SlideVolume(track, eparmx - eparmy); - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - break; - - // Tremolo - case 0x07: - DoTremalo(track); - break; - - // Pan - case 0x08: - break; // note effect - - // Sample offset - case 0x09: - break; // note effect - - // Volume slide - case 0x0A: - SlideVolume(track, eparmx - eparmy); - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - break; - - // Jump To Pattern - case 0x0B: - break; // note effect - - // Set Volume - case 0x0C: - break; // note effect - - // Pattern Break - case 0x0D: - break; // note effect - - // Extended effects - case 0x0E: - switch (eparmx) { - // Retrig note - case 0x9: - break; // not supported - - // Cut note - case 0xC: - if (m_nTick == eparmy) { - m_TrackDat[track].volume = 0; - m_TrackDat[track].mixvol = m_TrackDat[track].volume; - } - break; - - // Delay note - case 0xD: - break; // not supported - - // All other Exy effects are note effects - } - - // Set Speed - case 0x0F: - break; // note effect - } - } -} - -static void SlideVolume(int track, int amount) -{ - amount += m_TrackDat[track].volume; - m_TrackDat[track].volume = amount < 0 ? 0 : amount > 64 ? 64 : amount; -} - -static void DoPorta(int track) -{ - if (m_TrackDat[track].period < m_TrackDat[track].porta) { - m_TrackDat[track].period += m_TrackDat[track].portasp; - if (m_TrackDat[track].period > m_TrackDat[track].porta) - m_TrackDat[track].period = m_TrackDat[track].porta; - } else if (m_TrackDat[track].period > m_TrackDat[track].porta) { - m_TrackDat[track].period -= m_TrackDat[track].portasp; - if (m_TrackDat[track].period < m_TrackDat[track].porta) - m_TrackDat[track].period = m_TrackDat[track].porta; - } - m_TrackDat[track].freq = Period2Freq(m_TrackDat[track].period); -} - -static void DoVibrato(int track) -{ - int vib = m_TrackDat[track].vibdep * sintab[m_TrackDat[track].sinepos] >> 7; // div 128 - if (m_TrackDat[track].sineneg == 0) - m_TrackDat[track].freq = Period2Freq(m_TrackDat[track].period + vib); - else - m_TrackDat[track].freq = Period2Freq(m_TrackDat[track].period - vib); - m_TrackDat[track].sinepos += m_TrackDat[track].vibspe; - if (m_TrackDat[track].sinepos > 31) { - m_TrackDat[track].sinepos -= 32; - m_TrackDat[track].sineneg = ~m_TrackDat[track].sineneg; // flip pos/neg flag - } -} - -static void DoTremalo(int track) -{ - int vib = m_TrackDat[track].tremdep * sintab[m_TrackDat[track].sinepos] >> 6; // div64 - if (m_TrackDat[track].sineneg == 0) { - if (m_TrackDat[track].volume + vib > 64) - vib = 64 - m_TrackDat[track].volume; - m_TrackDat[track].mixvol = m_TrackDat[track].volume + vib; - } else { - if (m_TrackDat[track].volume - vib < 0) - vib = m_TrackDat[track].volume; - m_TrackDat[track].mixvol = m_TrackDat[track].volume + vib; - } - - m_TrackDat[track].sinepos += m_TrackDat[track].tremspe; - if (m_TrackDat[track].sinepos > 31) { - m_TrackDat[track].sinepos -= 32; - m_TrackDat[track].sineneg = ~m_TrackDat[track].sineneg; // flip pos/neg flag - } -} - -// Sets the master volume for the mod being played. -// The value should be from 0 (silence) to 64 (max volume) -static void SetMasterVolume(int volume) -{ - int i, j; - for (i = 0; i < 65; i++) - for (j = 0; j < 256; j++) - VolumeTable[i][j] = volume * i * (int) (char) j / 64; -} - -// 16-bit word values in a mod are stored in the Motorola -// Most-Significant-Byte-First format. -// They're also stored at half their actual value, thus doubling their range. -// This function accepts a pointer to such a word and returns it's integer value -// NOTE: relic from pc testing. -static int ReadModWord(unsigned char *data, int index) -{ - int byte1 = (int) (unsigned char) *(data + index); - int byte2 = (int) (unsigned char) *(data + index + 1); - return ((byte1 * 256) + byte2) * 2; -} diff --git a/source/liborbisAudio/orbisAudio.c b/source/liborbisAudio/orbisAudio.c deleted file mode 100644 index 7e3d8cf..0000000 --- a/source/liborbisAudio/orbisAudio.c +++ /dev/null @@ -1,601 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under the MIT license -# Review README & LICENSE files for further details. -*/ - -#include -#include -#include -#include -#include // sleep() -#include - -#include "orbisAudio.h" - - -#if defined (__PS4__) - -#include -#include -#define fprintf debugNetPrintf -#define ERROR DEBUGNET_ERROR -#define DEBUG DEBUGNET_DEBUG -#define INFO DEBUGNET_INFO - - -#elif defined HAVE_LIBAO // on pc - -#include -#define debugNetPrintf fprintf -#define ERROR stderr -#define DEBUG stdout -#define INFO stdout - -// we wrap sce calls below to use default audio device! -#define sceKernelUsleep usleep -#include -ao_device *device = NULL; -int default_driver = -1; -ao_sample_format format; - -// -- libao init -- -int sceAudioOutInit(void) -{ - // -- Setup for default audio driver -- - ao_initialize(); - // alsa pulls pulseaudio-alsa-plugin! - default_driver = ao_driver_id("alsa"); // or let 'ao_default_driver_id();' autoselect default - format.bits = 16; - format.channels = 2; - format.rate = 48000; - format.byte_format = AO_FMT_LITTLE; - - return 1; -} - -// -- libao open driver -- -int sceAudioOutOpen(int unused, int localChannel, int zero, int numSamples, int frequency, int unused_format) -{ - device = ao_open_live(default_driver, &format, NULL ); - if(device == NULL) { fprintf(ERROR, "Error opening device.\n"); return -1; } - - return default_driver; -} - -// -- libao play audio -- -int sceAudioOutOutput(int audioHandle, void *buf) -{ - ao_play(device, (char *)buf, 1024 *2 * sizeof(short)); return 1; -} - -// -- libao end -- -void sceAudioOutClose(int audioHandle) -{ - ao_close(device); - ao_shutdown(); -} -#endif - - -//static pthread_mutex_t wait_mutex; -static unsigned int localChannel = 0; - -OrbisAudioConfig *orbisAudioConf=NULL; -int orbisaudio_external_conf=-1; - -OrbisAudioConfig *orbisAudioGetConf() -{ - if(orbisAudioConf) return orbisAudioConf; - else return NULL; -} - -int orbisAudioCreateBuffersChannel(unsigned int channel, unsigned int samples, unsigned int format) -{ - int size = 0; - switch(format) - { - case ORBISAUDIO_FORMAT_S16_MONO: size = sizeof(OrbisAudioMonoSample); break; - case ORBISAUDIO_FORMAT_S16_STEREO: size = sizeof(OrbisAudioStereoSample); - default: break; - } - if(orbisAudioConf) - { - if(orbisAudioConf->channels[channel]) - { - if(orbisAudioConf->channels[channel]->orbisaudiochannel_initialized == -1) - { - for(int i=0; ichannels[channel]->sampleBuffer[i] = (short*)malloc(size * samples); - orbisAudioConf->channels[channel]->samples [i] = samples; - fprintf(DEBUG, "[orbisAudio] buffer %d for audio channel %d created (%db)\n", i, channel, size * samples); - } - orbisAudioConf->channels[channel]->stereo = format; - //fprintf(DEBUG, "setting format:%d\n", format); - } - else fprintf(DEBUG, "[orbisAudio] audio channel %d was already initialized\n", channel); - } - else return -1; - } - else { fprintf(ERROR, "[orbisAudio] orbisAudioCreateBuffersChannel orbisAudioConf is not created\n"); return -1; } - - return 0; -} - -int orbisAudioCreateConf() -{ - if(!orbisAudioConf) - { - orbisAudioConf = (OrbisAudioConfig *)malloc(sizeof(OrbisAudioConfig)); - memset(orbisAudioConf, 0, sizeof(OrbisAudioConfig)); - if(orbisAudioConf) - { - for(int i=0;ichannels[i] = (OrbisAudioChannel *)malloc(sizeof(OrbisAudioChannel)); - memset(orbisAudioConf->channels[i], 0, sizeof(OrbisAudioChannel)); - if(orbisAudioConf->channels[i]) - { - orbisAudioConf->channels[i]->audioHandle = -1; - orbisAudioConf->channels[i]->threadHandle = 0; - orbisAudioConf->channels[i]->leftVol = ORBISAUDIO_VOLUME_MAX; - orbisAudioConf->channels[i]->rightVol = ORBISAUDIO_VOLUME_MAX; - for(int j=0;jchannels[i]->sampleBuffer[j] = NULL; - orbisAudioConf->channels[i]->samples [j] = 0; - } - orbisAudioConf->channels[i]->callback = NULL; - orbisAudioConf->channels[i]->userData = NULL; - orbisAudioConf->channels[i]->paused = 1; - orbisAudioConf->channels[i]->currentBuffer = 0; - orbisAudioConf->channels[i]->orbisaudiochannel_initialized = -1; - } - } - orbisAudioConf->orbisaudio_stop = 0; - orbisAudioConf->orbisaudio_initialized = 1; - return 0; - } - } - if(orbisAudioConf->orbisaudio_initialized == 1) return 1; - - return -1; // something weird happened -} - -int orbisAudioSetConf(OrbisAudioConfig *conf) -{ - if(conf) - { - orbisAudioConf = conf; - orbisaudio_external_conf = 1; - return orbisAudioConf->orbisaudio_initialized; - } - - return 0; -} -int orbisAudioInitWithConf(OrbisAudioConfig *conf) -{ - int ret = orbisAudioSetConf(conf); - if(ret) - { - fprintf(DEBUG, "liborbisaudio already initialized using configuration external\n"); - fprintf(DEBUG, "orbisaudio_initialized=%d\n", orbisAudioConf->orbisaudio_initialized); - fprintf(DEBUG, "ready to have a lot of fun...\n"); - return orbisAudioConf->orbisaudio_initialized; - } - else return 0; -} - -int orbisAudioPlayBlock(unsigned int channel,unsigned int vol1,unsigned int vol2,void *buf) -{ - //int vols[2]={vol1,vol2}; - if (channel > ORBISAUDIO_CHANNELS) return 0; - - if(orbisAudioConf) - { - if(orbisAudioConf->channels[channel]) - { - if(orbisAudioConf->channels[channel]->orbisaudiochannel_initialized == 1 - && orbisAudioConf->orbisaudio_stop != 1) - { - // sceAudioOutSetVolume(orbisAudioConf->channels[channel]->audioHandle,ORBISAUDIO_VOLUME_FLAG_LEFT_CHANNEL|ORBISAUDIO_VOLUME_FLAG_RIGHT_CHANNEL,vols); - return sceAudioOutOutput(orbisAudioConf->channels[channel]->audioHandle, buf); - } - } - } - return -1; -} - -void * orbisAudioChannelThread(void *argp) -{ - fprintf(DEBUG, "-- audio thread --\n"); - int i, ret; - - OrbisAudioCallback callback = NULL; - // sound samples are shorts, s16le - void *buf; - unsigned int samples; - unsigned int channel = *((unsigned int*)argp); - -//long *p = (long*)argp; -//fprintf(2,"localChannel:%ld %d '%.16x' %p %lx %zu %.16x, %.16x\n", *p, (int)channel, channel, argp, (long)argp, sizeof(long), *(int*)argp, *((int*)argp)); - - if(channel != 0 - || channel != localChannel) - { - //printf("wtf! localChannel:%u '%.8x' %p %p %.8lx\n", channel, channel, argp, argp, *(long*)argp); - - channel = 0; // fix it, must be 0! - } - //static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER; - for(i=0; ichannels[channel]->stereo); - switch(orbisAudioConf->channels[channel]->stereo) - { - case 0: size = sizeof(OrbisAudioMonoSample); break; - case 1: size = sizeof(OrbisAudioStereoSample); - default: break; - } - //fprintf(DEBUG, "size: %zu * %d\n", size, orbisAudioConf->channels[channel]->samples[i]); - size *= orbisAudioConf->channels[channel]->samples[i]; -//fprintf(DEBUG, "i:%d, size: %zu %p\n", i, size, orbisAudioConf->channels[channel]->sampleBuffer[i]); - //pthread_mutex_lock(&wait_mutex); - memset(orbisAudioConf->channels[channel]->sampleBuffer[i], 0, size); - //pthread_mutex_unlock(&wait_mutex); - } - //pthread_mutex_unlock(&wait_mutex); - - fprintf(DEBUG, "[orbisAudio] orbisAudioChannelThread %d %d ready to have a lot of fun!\n", orbisAudioConf->orbisaudio_stop, orbisAudioConf->channels[channel]->paused); - // reset state and start it - orbisAudioConf->orbisaudio_stop = 0; - - while(!orbisAudioConf->orbisaudio_stop) - { - if(orbisAudioConf->channels[channel]->orbisaudiochannel_initialized == 1) - { - callback = orbisAudioConf->channels[channel]->callback; - buf = orbisAudioConf->channels[channel]->sampleBuffer[orbisAudioConf->channels[channel]->currentBuffer]; - samples = orbisAudioConf->channels[channel]->samples [orbisAudioConf->channels[channel]->currentBuffer]; - - if(callback && !orbisAudioConf->channels[channel]->paused) - { - /* Use user callback to fill buffer */ - callback(buf,samples,orbisAudioConf->channels[channel]->userData); - } - else - { - /* Fill buffer with silence (stereo/mono) */ - memset(buf, 0, samples * sizeof(short) - * (orbisAudioConf->channels[channel]->stereo + 1)); - } - - /* Play sound */ - ret = orbisAudioPlayBlock(channel,orbisAudioConf->channels[channel]->leftVol,orbisAudioConf->channels[channel]->rightVol,buf); - if(ret<0) { fprintf(ERROR, "[orbisAudio] orbisAudioPlayBlock error 0x%08X \n",ret); } - - /* Switch active buffer */ - orbisAudioConf->channels[channel]->currentBuffer=(orbisAudioConf->channels[channel]->currentBuffer?0:1); - } - /* wait a little */ - sceKernelUsleep(1000); - } - fprintf(DEBUG, "[orbisAudio] stop:%d, orbisAudioChannelThread exit...\n",orbisAudioConf->orbisaudio_stop); - //scePthreadExit(0); - pthread_join(orbisAudioConf->channels[channel]->threadHandle, NULL); - - return NULL; -} - -void orbisAudioDestroyBuffersChannel(unsigned int channel) -{ - if(orbisAudioConf) - { - if(orbisAudioConf->channels[channel]) - { - for(int i=0;ichannels[channel]->sampleBuffer[i]) free(orbisAudioConf->channels[channel]->sampleBuffer[i]); - } - } - } -} - -int orbisAudioGetStatus() -{ - if(orbisAudioConf) - { - return orbisAudioConf->orbisaudio_initialized; - } - else return -1; -} - -int orbisAudioGetChannelStatus(int chan) -{ - if(orbisAudioConf) - { - if(orbisAudioConf->channels[chan]) - { - return orbisAudioConf->channels[chan]->orbisaudiochannel_initialized; - } - return -1; - } - else return -1; -} - -int orbisAudioGetHandle(int chan) -{ - if(orbisAudioConf) - { - if(orbisAudioConf->channels[chan]) - { - return orbisAudioConf->channels[chan]->audioHandle; - } - return -1; - } - else return -1; -} - -int orbisAudioInitChannelWithoutCallback(unsigned int channel, unsigned int samples, unsigned int frequency, int format) -{ - int ret; - unsigned int numSamples = 0; - int handle; - localChannel = channel; - char label[32]; - strcpy(label,"audiotX"); - label[6]='0'+channel; - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[localChannel]!=NULL) - { - if(orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized==-1) - { - if (samples ORBISAUDIO_MAX_LEN) numSamples = ORBISAUDIO_MAX_LEN; - } - ret = orbisAudioCreateBuffersChannel(localChannel,numSamples,format); - if(ret!=0) - { - fprintf(ERROR, "[orbisAudio] error creating buffers for audio channel %d\n",localChannel); - orbisAudioDestroyBuffersChannel(localChannel); - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized=-1; - } - else - { - fprintf(DEBUG, "[orbisAudio] sceAudioOutOpen %d samples\n",numSamples); - - handle=sceAudioOutOpen(0xff,localChannel,0,numSamples,frequency,format); - fprintf(DEBUG, "handle: %d\n", handle); - if(handle>0) - { - orbisAudioConf->channels[localChannel]->audioHandle=handle; - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized=1; - return 0; - } - else - { - fprintf(ERROR, "[orbisAudio] error opening audio channel %d 0x%08X\n",localChannel, handle); - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized = -1; - } - } - } - else - { - fprintf(DEBUG, "[orbisAudio] audio channel %d already initialized",localChannel); - } - } - } - return -1; -} -int orbisAudioInitChannel(unsigned int channel, unsigned int samples, unsigned int frequency, int format) -{ - localChannel = channel; - - unsigned int numSamples = 0; - int ret, handle; - char label[32]; - strcpy(label, "audiotX"); - label[6] = '0' + channel; - - if(orbisAudioConf) - { - if(orbisAudioConf->channels[localChannel]) - { - if(orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized==-1) - { - if(samplesORBISAUDIO_MAX_LEN) numSamples = ORBISAUDIO_MAX_LEN; - } - - ret = orbisAudioCreateBuffersChannel(localChannel, numSamples, format); - if(ret) - { - fprintf(ERROR, "[orbisAudio] error creating buffers for audio channel %d\n", localChannel); - orbisAudioDestroyBuffersChannel(localChannel); - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized = -1; - } - else - { - fprintf(DEBUG, "[orbisAudio] sceAudioOutOpen %d samples\n",numSamples); - - handle=sceAudioOutOpen(0xff,localChannel,0,numSamples,frequency,format); -//fprintf(DEBUG, "handle:%d\n", handle); - if(handle>0) - { - // protect the localChannel variable - //static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER; - - orbisAudioConf->channels[localChannel]->audioHandle=handle; - - //ret=scePthreadCreate(&orbisAudioConf->channels[localChannel]->threadHandle,NULL,orbisAudioChannelThread, &localChannel,label); - ret = pthread_create(&orbisAudioConf->channels[localChannel]->threadHandle, - NULL, - orbisAudioChannelThread, - (void *)&localChannel); - - //pthread_mutex_lock(&wait_mutex); -//fprintf(DEBUG, "creating thread res:%d\n", ret); - //pthread_mutex_unlock(&wait_mutex); - //pthread_mutex_destroy(&wait_mutex); -//usleep(2000); - if(ret==0) - { - fprintf(DEBUG, "[orbisAudio] audio channel %u thread UID: 0x%08lX created\n", localChannel, orbisAudioConf->channels[localChannel]->threadHandle); - - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized = 1; - return 0; - } - else - { - fprintf(ERROR, "[orbisAudio] audio channel %u thread could not create error: 0x%08X\n",localChannel, ret); - //scePthreadCancel(orbisAudioConf->channels[localChannel]->threadHandle); - pthread_join(orbisAudioConf->channels[localChannel]->threadHandle, NULL); - - fprintf(DEBUG, "[orbisAudio] closing audio channel %d\n", channel); - - sceAudioOutClose(orbisAudioConf->channels[channel]->audioHandle); - - orbisAudioConf->channels[channel]->audioHandle = -1; - orbisAudioDestroyBuffersChannel(channel); - orbisAudioConf->channels[channel]->orbisaudiochannel_initialized = -1; - } - - } - else - { - fprintf(DEBUG, "[orbisAudio] error opening audio channel %u 0x%08X\n",localChannel, handle); - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized = -1; - } - } - } - else - { - fprintf(DEBUG, "[orbisAudio] audio channel %u already initialized",localChannel); - } - } - } - return -1; -} - -int orbisAudioSetCallback(unsigned int channel,OrbisAudioCallback callback,void *userdata) -{ - if(channel > ORBISAUDIO_CHANNELS) return 0; - - if(orbisAudioConf) - { - if(orbisAudioConf->channels[channel]) - { - orbisAudioConf->channels[channel]->callback = NULL; - orbisAudioConf->channels[channel]->userData = userdata; - orbisAudioConf->channels[channel]->callback = callback; - } - } - return 1; -} - -int orbisAudioStop() -{ - if(orbisAudioConf) orbisAudioConf->orbisaudio_stop = 1; sleep(1); - - return 1; -} - -int orbisAudioResume(unsigned int channel) -{ - if (channel > ORBISAUDIO_CHANNELS) return 0; - - if(orbisAudioConf) - { - if(orbisAudioConf->channels[channel]) orbisAudioConf->channels[channel]->paused = 0; - } - return 1; -} - -int orbisAudioPause(unsigned int channel) -{ - if (channel > ORBISAUDIO_CHANNELS) return 0; - - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]) orbisAudioConf->channels[channel]->paused = 1; - } - return 1; -} - -void orbisAudioFinish() -{ - //pthread_mutex_destroy(&wait_mutex); - - int i; - if(orbisAudioConf) - { - orbisAudioStop(); - for(i=0;ichannels[i]) - { - if(orbisAudioConf->channels[i]->orbisaudiochannel_initialized==1) - { - //scePthreadCancel(orbisAudioConf->channels[i]->threadHandle); - orbisAudioConf->channels[i]->threadHandle=0; - - sceAudioOutClose(orbisAudioConf->channels[i]->audioHandle); - fprintf(DEBUG, "[orbisAudio] closing audio handle\n"); - - orbisAudioConf->channels[i]->audioHandle=-1; - orbisAudioDestroyBuffersChannel(i); - fprintf(DEBUG, "[orbisAudio] free buffers channel\n"); - - orbisAudioConf->channels[i]->orbisaudiochannel_initialized=-1; - } - //free(orbisAudioConf->channels[i]); - } - } - //free(orbisAudioConf); - fprintf(DEBUG, "[orbisAudio] finished\n"); - } -} - -int orbisAudioInit() -{ - //pthread_mutex_init(&wait_mutex, NULL);// = PTHREAD_MUTEX_INITIALIZER; - - int ret = sceAudioOutInit(); - if(ret<0) - { - fprintf(ERROR, "[orbisAudio] sceAudioOutInit error 0x%08X\n",ret); return -1; - } - fprintf(DEBUG, "[orbisAudio] sceAudioOutInit return %d\n",ret); - - if(orbisAudioCreateConf() == 0) - { - fprintf(DEBUG, "[orbisAudio] initialized!\n"); - return orbisAudioConf->orbisaudio_initialized; - } - if (orbisAudioConf->orbisaudio_initialized == 1) - { - fprintf(DEBUG, "[orbisAudio] is already initialized!\n"); - return orbisAudioConf->orbisaudio_initialized; - } - return -1; -} diff --git a/source/liborbisAudio/orbisAudio.c.old b/source/liborbisAudio/orbisAudio.c.old deleted file mode 100644 index 5dc4db5..0000000 --- a/source/liborbisAudio/orbisAudio.c.old +++ /dev/null @@ -1,493 +0,0 @@ -/* - * liborbis - * Copyright (C) 2015,2016,2017 Antonio Jose Ramos Marquez (aka bigboss) @psxdev on twitter - * Repository https://github.com/psxdev/liborbis - */ -#include -#include -#include -#include -#include -#include -#include "orbisAudio.h" - - - -OrbisAudioConfig *orbisAudioConf=NULL; -int orbisaudio_external_conf=-1; - -OrbisAudioConfig *orbisAudioGetConf() -{ - if(orbisAudioConf) - { - return orbisAudioConf; - } - - return NULL; -} - -int orbisAudioCreateBuffersChannel(unsigned int channel, unsigned int samples, unsigned int format) -{ - int j; - int size; - switch(format) - { - case ORBISAUDIO_FORMAT_S16_MONO: - size=sizeof(OrbisAudioMonoSample); - break; - case ORBISAUDIO_FORMAT_S16_STEREO: - size=sizeof(OrbisAudioStereoSample); - break; - default: - break; - - } - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]!=NULL) - { - if(orbisAudioConf->channels[channel]->orbisaudiochannel_initialized==-1) - { - for(j=0;jchannels[channel]->sampleBuffer[j]=(short *)malloc(size*samples); - orbisAudioConf->channels[channel]->samples[j] = samples; - debugNetPrintf(3,"[orbisAudio] buffers %d for audio 0 %x created\n",j,orbisAudioConf->channels[channel]->sampleBuffer[j]); - - - - } - - orbisAudioConf->channels[channel]->stereo=format; - debugNetPrintf(3,"[orbisAudio] buffers for audio channel %d created\n",channel); - } - else - { - debugNetPrintf(3,"[orbisAudio] audio channel %d was already initialized\n",channel); - - } - - - } - else - { - return -1; - } - } - else - { - debugNetPrintf(3,"[orbisAudio] orbisAudioCreateBuffersChannel orbisAudioConf is not created\n"); - return -1; - } - return 0; -} - -int orbisAudioCreateConf() -{ - if(orbisAudioConf==NULL) - { - orbisAudioConf=(OrbisAudioConfig *)malloc(sizeof(OrbisAudioConfig)); - if(orbisAudioConf!=NULL) - { - for(int i=0;ichannels[i]=malloc(sizeof(OrbisAudioChannel)); - if(orbisAudioConf->channels[i]!=NULL) - { - orbisAudioConf->channels[i]->audioHandle=-1; - orbisAudioConf->channels[i]->threadHandle = 0; - orbisAudioConf->channels[i]->leftVol = ORBISAUDIO_VOLUME_MAX; - orbisAudioConf->channels[i]->rightVol = ORBISAUDIO_VOLUME_MAX; - for(int j=0;jchannels[i]->sampleBuffer[j] = NULL; - orbisAudioConf->channels[i]->samples[j] = 0; - } - orbisAudioConf->channels[i]->callback = NULL; - orbisAudioConf->channels[i]->userData = NULL; - orbisAudioConf->channels[i]->paused = 1; - orbisAudioConf->channels[i]->currentBuffer=0; - orbisAudioConf->channels[i]->orbisaudiochannel_initialized=-1; - } - } - orbisAudioConf->orbisaudio_stop=0; - orbisAudioConf->orbisaudio_initialized=1; - return 0; - - } - - } - - if(orbisAudioConf->orbisaudio_initialized==1) - { - return orbisAudioConf->orbisaudio_initialized; - } - //something weird happened - return -1; -} -int orbisAudioSetConf(OrbisAudioConfig *conf) -{ - if(conf) - { - orbisAudioConf=conf; - orbisaudio_external_conf=1; - return orbisAudioConf->orbisaudio_initialized; - } - - return 0; -} -int orbisAudioInitWithConf(OrbisAudioConfig *conf) -{ - int ret; - - ret=orbisAudioSetConf(conf); - if(ret) - { - debugNetPrintf(3,"liborbisaudio already initialized using configuration external\n"); - debugNetPrintf(3,"orbisaudio_initialized=%d\n",orbisAudioConf->orbisaudio_initialized); - debugNetPrintf(3,"ready to have a lot of fun...\n"); - return orbisAudioConf->orbisaudio_initialized; - } - else - { - return 0; - } -} - -static inline int orbisAudioPlayBlock(unsigned int channel,unsigned int vol1,unsigned int vol2,void *buf) -{ - - int vols[2]={vol1,vol2}; - if (channel > ORBISAUDIO_CHANNELS) - { - return 0; - } - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]!=NULL) - { - if(orbisAudioConf->channels[channel]->orbisaudiochannel_initialized==1 && orbisAudioConf->orbisaudio_stop!=1) - { - //sceAudioOutSetVolume(orbisAudioConf->channels[channel]->audioHandle,ORBISAUDIO_VOLUME_FLAG_LEFT_CHANNEL|ORBISAUDIO_VOLUME_FLAG_RIGHT_CHANNEL,vols); - return sceAudioOutOutput(orbisAudioConf->channels[channel]->audioHandle,buf); - - } - - } - } - return -1; - -} - -void * orbisAudioChannelThread(void *argp) -{ - unsigned int channel=*(unsigned int *)argp; - int i,ret; - unsigned short *bufMono; - unsigned int *bufStereo; - void *buf; - OrbisAudioCallback callback=NULL; - unsigned int samples; - - debugNetPrintf(3,"orbisAudioChannelThread channel %d\n",channel); - debugNetPrintf(3,"orbisAudioChannelThread channel samples 0 %d\n",orbisAudioConf->channels[channel]->samples[0]); - debugNetPrintf(3,"orbisAudioChannelThread channel samples 1 %d\n",orbisAudioConf->channels[channel]->samples[1]); - //sleep(1); - debugNetPrintf(3,"orbisAudioChannelThread buffer 0 %x\n",orbisAudioConf->channels[channel]->sampleBuffer[0]); - debugNetPrintf(3,"orbisAudioChannelThread buffer 1 %x\n",orbisAudioConf->channels[channel]->sampleBuffer[1]); - - - for(i=0;ichannels[channel]->sampleBuffer[i],0,orbisAudioConf->channels[channel]->samples[i]*(orbisAudioConf->channels[channel]->stereo?sizeof(OrbisAudioStereoSample):sizeof(OrbisAudioMonoSample))*orbisAudioConf->channels[channel]->samples[i]); - //debugNetPrintf(3,"orbisAudioChannelThread memset buffer %d\n",i); - - } - debugNetPrintf(3,"[orbisAudio] orbisAudioChannelThread %d %d ready to have a lot of fun...\n",orbisAudioConf->orbisaudio_stop,orbisAudioConf->channels[channel]->paused); - - //sleep(1); - //buf=malloc(orbisAudioConf->channels[channel]->samples[0]*(orbisAudioConf->channels[channel]->stereo?sizeof(OrbisAudioStereoSample):sizeof(OrbisAudioMonoSample))*orbisAudioConf->channels[channel]->samples[0]) - orbisAudioConf->channels[channel]->currentBuffer=0; - while(!orbisAudioConf->orbisaudio_stop) - { - if(orbisAudioConf->channels[channel]->orbisaudiochannel_initialized==1) - { - callback=orbisAudioConf->channels[channel]->callback; - buf=orbisAudioConf->channels[channel]->sampleBuffer[orbisAudioConf->channels[channel]->currentBuffer]; - samples=orbisAudioConf->channels[channel]->samples[orbisAudioConf->channels[channel]->currentBuffer]; - - if (callback!=NULL && !orbisAudioConf->channels[channel]->paused) - { - /* User callback to fill buffer */ - callback(buf,samples,orbisAudioConf->channels[channel]->userData); - } - else - { - /* Fill buffer with silence */ - if (orbisAudioConf->channels[channel]->stereo==1) - { - bufStereo=(unsigned int *)buf; - for (i=0;ichannels[channel]->leftVol,orbisAudioConf->channels[channel]->rightVol,buf); - if(ret<0) - { - debugNetPrintf(3,"[orbisAudio] orbisAudioPlayBlock error 0x%08X \n",ret); - } - /* Switch active buffer */ - orbisAudioConf->channels[channel]->currentBuffer=(orbisAudioConf->channels[channel]->currentBuffer?0:1); - } - } - - debugNetPrintf(3,"[orbisAudio] orbisAudioChannelThread %d exit...\n",orbisAudioConf->orbisaudio_stop); - - scePthreadExit(0); - return NULL; - - - - -} -void orbisAudioDestroyBuffersChannel(unsigned int channel) -{ - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]!=NULL) - { - for(int i=0;ichannels[channel]->sampleBuffer[i]); - } - } - - } -} -int orbisAudioInitChannel(unsigned int channel, unsigned int samples, unsigned int frequency, int format) -{ - int ret; - unsigned int numSamples=0; - int handle; - unsigned int localChannel=channel; - char label[32]; - strcpy(label,"audiotX"); - label[6]='0'+channel; - //sprintf("audiot%d",channel) - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[localChannel]!=NULL) - { - if(orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized==-1) - { - if (samplesORBISAUDIO_MAX_LEN) - { - numSamples=ORBISAUDIO_MAX_LEN; - } - } - ret=orbisAudioCreateBuffersChannel(localChannel,numSamples,format); - if(ret!=0) - { - debugNetPrintf(3,"[orbisAudio] error creating buffers for audio channel %d\n",localChannel); - orbisAudioDestroyBuffersChannel(localChannel); - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized=-1; - } - else - { - debugNetPrintf(3,"[orbisAudio] sceAudioOutOpen %d samples\n",numSamples); - - handle=sceAudioOutOpen(0xff,localChannel,0,numSamples,frequency,format); - if(handle>0) - { - debugNetPrintf(3,"[orbisAudio] sceAudioOutOpen handle %x \n",handle); - - // sleep(1); - - orbisAudioConf->channels[localChannel]->audioHandle=handle; - - ret=scePthreadCreate(&orbisAudioConf->channels[localChannel]->threadHandle,NULL,orbisAudioChannelThread, &localChannel,label); - if(ret==0) - { - debugNetPrintf(3,"[orbisAudio] audio channel %d thread UID: 0x%08X created\n",localChannel, orbisAudioConf->channels[localChannel]->threadHandle); - - - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized=1; - return 0; - - - } - else - { - debugNetPrintf(3,"[orbisAudio] audio channel %d thread could not create error: 0x%08X\n",localChannel, ret); - scePthreadCancel(orbisAudioConf->channels[localChannel]->threadHandle); - debugNetPrintf(3,"[orbisAudio] closing audio channel %d\n",channel); - sceAudioOutClose(orbisAudioConf->channels[channel]->audioHandle); - orbisAudioConf->channels[channel]->audioHandle=-1; - orbisAudioDestroyBuffersChannel(channel); - orbisAudioConf->channels[channel]->orbisaudiochannel_initialized=-1; - - } - - - } - else - { - debugNetPrintf(3,"[orbisAudio] error opening audio channel %d 0x%08X\n",localChannel, handle); - orbisAudioConf->channels[localChannel]->orbisaudiochannel_initialized=-1; - - } - - } - } - - else - { - debugNetPrintf(3,"[orbisAudio] audio channel %d already initialized",localChannel); - } - } - } - return -1; - - - -} - -int orbisAudioSetCallback(unsigned int channel,OrbisAudioCallback callback,void *userdata) -{ - if (channel > ORBISAUDIO_CHANNELS) - { - return 0; - } - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]!=NULL) - { - orbisAudioConf->channels[channel]->callback=NULL; - orbisAudioConf->channels[channel]->userData = userdata; - orbisAudioConf->channels[channel]->callback = callback; - } - } - return 1; -} -int orbisAudioStop() -{ - if(orbisAudioConf!=NULL) - { - - orbisAudioConf->orbisaudio_stop=1; - sleep(2); - - } - return 1; -} -int orbisAudioResume(unsigned int channel) -{ - if (channel > ORBISAUDIO_CHANNELS) - { - return 0; - } - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]!=NULL) - { - orbisAudioConf->channels[channel]->paused=0; - } - } - - return 1; -} - -int orbisAudioPause(unsigned int channel) -{ - if (channel > ORBISAUDIO_CHANNELS) - { - return 0; - } - if(orbisAudioConf!=NULL) - { - if(orbisAudioConf->channels[channel]!=NULL) - { - orbisAudioConf->channels[channel]->paused=1; - } - } - - return 1; -} -void orbisAudioFinish() -{ - int i; - if(orbisAudioConf!=NULL) - { - orbisAudioStop(); - for(i=0;ichannels[i]!=NULL) - { - if(orbisAudioConf->channels[i]->orbisaudiochannel_initialized==1) - { - - //scePthreadCancel(orbisAudioConf->channels[i]->threadHandle); - orbisAudioConf->channels[i]->threadHandle=0; - sceAudioOutClose(orbisAudioConf->channels[i]->audioHandle); - debugNetPrintf(3,"[orbisAudio] closing audio handle\n"); - - orbisAudioConf->channels[i]->audioHandle=-1; - //orbisAudioDestroyBuffersChannel(i); - debugNetPrintf(3,"[orbisAudio] free buffers channel\n"); - - orbisAudioConf->channels[i]->orbisaudiochannel_initialized=-1; - - } - - //free(orbisAudioConf->channels[i]); - } - } - //free(orbisAudioConf); - debugNetPrintf(3,"[orbisAudio] finished\n"); - - } -} -int orbisAudioInit() -{ - int ret; - ret=sceAudioOutInit(); - if(ret<0) - { - debugNetPrintf(3,"[orbisAudio] sceAudioOutInit error 0x%08X\n",ret); - return -1; - } - debugNetPrintf(3,"[orbisAudio] sceAudioOutInit return %d\n",ret); - if(orbisAudioCreateConf()==0) - { - debugNetPrintf(3,"[orbisAudio] initialized!\n"); - return orbisAudioConf->orbisaudio_initialized; - } - if (orbisAudioConf->orbisaudio_initialized==1) - { - debugNetPrintf(3,"[orbisAudio] is already initialized!\n"); - return orbisAudioConf->orbisaudio_initialized; - } - return -1; -} diff --git a/source/liborbisKeyboard/orbisKeyboard.c b/source/liborbisKeyboard/orbisKeyboard.c deleted file mode 100644 index 4c8a3bd..0000000 --- a/source/liborbisKeyboard/orbisKeyboard.c +++ /dev/null @@ -1,795 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#include -#include -#include -#include -#include -#include "orbisKeyboard.h" -#include "kb.h" -#include - -OrbisKeyboardConfig *orbisKeyboardConf=NULL; -int orbiskeyboard_external_conf=-1; -uint8_t orbisKeyboardNames[3][256]; -void orbisKeyboardInitKeyNames() -{ - orbisKeyboardNames[0][KEY_A]=0x61; //0x0004 Keyboard a and A - orbisKeyboardNames[0][KEY_B]=0x62; //0x0005 // Keyboard b and B - orbisKeyboardNames[0][KEY_C]=0x63; //0x0006 // Keyboard c and C - orbisKeyboardNames[0][KEY_D]=0x64; //0x0007 // Keyboard d and D - orbisKeyboardNames[0][KEY_E]=0x65; //0x0008 // Keyboard e and E - orbisKeyboardNames[0][KEY_F]=0x66; //0x0009 // Keyboard f and F - orbisKeyboardNames[0][KEY_G]=0x67; //0x000a // Keyboard g and G - orbisKeyboardNames[0][KEY_H]=0x68; //0x000b // Keyboard h and H - orbisKeyboardNames[0][KEY_I]=0x69; //0x000c // Keyboard i and I - orbisKeyboardNames[0][KEY_J]=0x6a; //0x000d // Keyboard j and J - orbisKeyboardNames[0][KEY_K]=0x6b; //0x000e // Keyboard k and K - orbisKeyboardNames[0][KEY_L]=0x6c; //0x000f // Keyboard l and L - orbisKeyboardNames[0][KEY_M]=0x6d; //0x0010 // Keyboard m and M - orbisKeyboardNames[0][KEY_N]=0x6e; //0x0011 // Keyboard n and N - orbisKeyboardNames[0][KEY_O]=0x6f; //0x0012 // Keyboard o and O - orbisKeyboardNames[0][KEY_P]=0x70; //0x0013 // Keyboard p and P - orbisKeyboardNames[0][KEY_Q]=0x71; //0x0014 // Keyboard q and Q - orbisKeyboardNames[0][KEY_R]=0x72; //0x0015 // Keyboard r and R - orbisKeyboardNames[0][KEY_S]=0x73; //0x0016 // Keyboard s and S - orbisKeyboardNames[0][KEY_T]=0x74; //0x0017 // Keyboard t and T - orbisKeyboardNames[0][KEY_U]=0x75; //0x0018 // Keyboard u and U - orbisKeyboardNames[0][KEY_V]=0x76; //0x0019 // Keyboard v and V - orbisKeyboardNames[0][KEY_W]=0x77; //0x001a // Keyboard w and W - orbisKeyboardNames[0][KEY_X]=0x78; //0x001b // Keyboard x and X - orbisKeyboardNames[0][KEY_Y]=0x79; //0x001c // Keyboard y and Y - orbisKeyboardNames[0][KEY_Z]=0x7a; //0x001d // Keyboard z and Z - - orbisKeyboardNames[1][KEY_A]=0x41; //0x0004 Keyboard a and A - orbisKeyboardNames[1][KEY_B]=0x42; //0x0005 // Keyboard b and B - orbisKeyboardNames[1][KEY_C]=0x43; //0x0006 // Keyboard c and C - orbisKeyboardNames[1][KEY_D]=0x44; //0x0007 // Keyboard d and D - orbisKeyboardNames[1][KEY_E]=0x45; //0x0008 // Keyboard e and E - orbisKeyboardNames[1][KEY_F]=0x46; //0x0009 // Keyboard f and F - orbisKeyboardNames[1][KEY_G]=0x47; //0x000a // Keyboard g and G - orbisKeyboardNames[1][KEY_H]=0x48; //0x000b // Keyboard h and H - orbisKeyboardNames[1][KEY_I]=0x49; //0x000c // Keyboard i and I - orbisKeyboardNames[1][KEY_J]=0x4a; //0x000d // Keyboard j and J - orbisKeyboardNames[1][KEY_K]=0x4b; //0x000e // Keyboard k and K - orbisKeyboardNames[1][KEY_L]=0x4c; //0x000f // Keyboard l and L - orbisKeyboardNames[1][KEY_M]=0x4d; //0x0010 // Keyboard m and M - orbisKeyboardNames[1][KEY_N]=0x4e; //0x0011 // Keyboard n and N - orbisKeyboardNames[1][KEY_O]=0x4f; //0x0012 // Keyboard o and O - orbisKeyboardNames[1][KEY_P]=0x50; //0x0013 // Keyboard p and P - orbisKeyboardNames[1][KEY_Q]=0x51; //0x0014 // Keyboard q and Q - orbisKeyboardNames[1][KEY_R]=0x52; //0x0015 // Keyboard r and R - orbisKeyboardNames[1][KEY_S]=0x53; //0x0016 // Keyboard s and S - orbisKeyboardNames[1][KEY_T]=0x54; //0x0017 // Keyboard t and T - orbisKeyboardNames[1][KEY_U]=0x55; //0x0018 // Keyboard u and U - orbisKeyboardNames[1][KEY_V]=0x56; //0x0019 // Keyboard v and V - orbisKeyboardNames[1][KEY_W]=0x57; //0x001a // Keyboard w and W - orbisKeyboardNames[1][KEY_X]=0x58; //0x001b // Keyboard x and X - orbisKeyboardNames[1][KEY_Y]=0x59; //0x001c // Keyboard y and Y - orbisKeyboardNames[1][KEY_Z]=0x5a; //0x001d // Keyboard z and Z - - orbisKeyboardNames[0][KEY_1]=0x31; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[0][KEY_2]=0x32; //0x001f // Keyboard 2 and @ - orbisKeyboardNames[0][KEY_3]=0x33; //0x0020 // Keyboard 3 and # - orbisKeyboardNames[0][KEY_4]=0x34; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[0][KEY_5]=0x35; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[0][KEY_6]=0x36; //0x0023 // Keyboard 6 and ^ - orbisKeyboardNames[0][KEY_7]=0x37; //0x0024 // Keyboard 7 and & - orbisKeyboardNames[0][KEY_8]=0x38; //0x0025 // Keyboard 8 and * - orbisKeyboardNames[0][KEY_9]=0x39; //0x0026 // Keyboard 9 and ( - orbisKeyboardNames[0][KEY_0]=0x30; //0x0027 // Keyboard 0 and ) - - orbisKeyboardNames[1][KEY_1]=0x21; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[1][KEY_2]=0x22; //0x001f // Keyboard 2 and " - orbisKeyboardNames[1][KEY_3]=0x23; //0x0020 // Keyboard 3 and # - orbisKeyboardNames[1][KEY_4]=0x24; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[1][KEY_5]=0x25; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[1][KEY_6]=0x26; //0x0023 // Keyboard 6 and & - orbisKeyboardNames[1][KEY_7]=0x27; //0x0024 // Keyboard 7 and ` - orbisKeyboardNames[1][KEY_8]=0x28; //0x0025 // Keyboard 8 and ( - orbisKeyboardNames[1][KEY_9]=0x29; //0x0026 // Keyboard 9 and ) - orbisKeyboardNames[1][KEY_0]=0; //0x0027 // Keyboard 0 and = - - - orbisKeyboardNames[0][KEY_ENTER]=0x0d; //0x0028 // Keyboard Return (ENTER) - orbisKeyboardNames[0][KEY_ESC]=0x1b; //0x0029 // Keyboard ESCAPE - orbisKeyboardNames[0][KEY_BACKSPACE]=0x08; //0x002a // Keyboard DELETE (Backspace) - orbisKeyboardNames[0][KEY_TAB]=0x09; //0x002b // Keyboard Tab - orbisKeyboardNames[0][KEY_SPACE]=0x20; //0x002c // Keyboard Spacebar - orbisKeyboardNames[0][KEY_MINUS]=0x27; //0x002d // Keyboard - and _ in spanish ' - orbisKeyboardNames[1][KEY_MINUS]=0x3f; //0x002d // Keyboard - and _ in spanish ? - //orbisKeyboardNames[0][KEY_EQUAL]="¡"; //0x002e // Keyboard = and + in spanjish ¡ - //orbisKeyboardNames[1][KEY_EQUAL]="¿"; //0x002e // Keyboard = and + in spanish ¿ - - orbisKeyboardNames[0][KEY_LEFTBRACE]=0x60; //0x2f // Keyboard [ and { in spanish ` - orbisKeyboardNames[1][KEY_LEFTBRACE]=0x7e; //0x2f // Keyboard [ and { in spanish - //orbisKeyboardNames[0][KEY_RIGHTBRACE]="+"; //0x30 // Keyboard ] and } in spanish + - orbisKeyboardNames[1][KEY_RIGHTBRACE]=0x2a; //0x30 // Keyboard ] and } in spanish * - - //orbisKeyboardNames[0][KEY_BACKSLASH]="\\"; //0x31 // Keyboard \ and | not in spanish - //orbisKeyboardNames[1][KEY_BACKSLASH]="|"; //0x31 // Keyboard \ and | not in spanish - - //orbisKeyboardNames[0][KEY_HASHTILDE]="#"; //0x32 // Keyboard Non-US # and ~ in spanish ç - //orbisKeyboardNames[1][KEY_HASHTILDE]="~"; //0x32 // Keyboard Non-US # and ~ in spanish ç - - //orbisKeyboardNames[0][KEY_SEMICOLON]="ñ"; //0x33 // Keyboard ; and : in spanish ñ - //orbisKeyboardNames[1][KEY_SEMICOLON]="Ñ"; //0x33 // Keyboard ; and : in spanish Ñ - - //orbisKeyboardNames[0][KEY_APOSTROPHE]="´"; //0x34 // Keyboard ' and " in spanish ´ - //orbisKeyboardNames[1][KEY_APOSTROPHE]="¨"; //0x34 // Keyboard ' and " in spanish - - orbisKeyboardNames[0][KEY_GRAVE]=0x3c; //0x35 // Keyboard ` and ~ in spanish < - orbisKeyboardNames[1][KEY_GRAVE]=0x3e; //0x35 // Keyboard ` and ~ in spanish > - - orbisKeyboardNames[0][KEY_COMMA]=0x2c; //0x36 // Keyboard , and < in spanish , - orbisKeyboardNames[1][KEY_COMMA]=0x3b; //0x36 // Keyboard , and < in spanish ; - - orbisKeyboardNames[0][KEY_DOT]=0x2e; //0x37 // Keyboard . and > in spanish . - orbisKeyboardNames[1][KEY_DOT]=0x3a; //0x37 // Keyboard . and > in spanish : - - orbisKeyboardNames[0][KEY_SLASH]=0x2d; //0x38 // Keyboard / and ? in spanish - - orbisKeyboardNames[1][KEY_SLASH]=0x5f; //0x38 // Keyboard / and ? in spanish _ - - orbisKeyboardNames[0][KEY_CAPSLOCK]=0x0a; //0x39 // Keyboard Caps Lock not in normal keycode vita use special key 0x2 in reports.modifiers[1] - - orbisKeyboardNames[0][KEY_F1]=0x12; //0x3a // Keyboard F1 - orbisKeyboardNames[0][KEY_F2]=0x13; //0x3b // Keyboard F2 - orbisKeyboardNames[0][KEY_F3]=0x14; //0x3c // Keyboard F3 - orbisKeyboardNames[0][KEY_F4]=0x15; //0x3d // Keyboard F4 - orbisKeyboardNames[0][KEY_F5]=0x16; //0x3e // Keyboard F5 - orbisKeyboardNames[0][KEY_F6]=0; //0x3f // Keyboard F6 - orbisKeyboardNames[0][KEY_F7]=0; //0x40 // Keyboard F7 - orbisKeyboardNames[0][KEY_F8]=0; //0x41 // Keyboard F8 - orbisKeyboardNames[0][KEY_F9]=0; //0x42 // Keyboard F9 - orbisKeyboardNames[0][KEY_F10]=0; //0x43 // Keyboard F10 - orbisKeyboardNames[0][KEY_F11]=0; //0x44 // Keyboard F11 - orbisKeyboardNames[0][KEY_F12]=0x11; //0x45 // Keyboard F12 MSX STOP - - - orbisKeyboardNames[0][KEY_RIGHT]=0x03; //0x4f // Keyboard Right Arrow - orbisKeyboardNames[0][KEY_LEFT]=0x01; //0x50 // Keyboard Left Arrow - orbisKeyboardNames[0][KEY_DOWN]=0x04; //0x51 // Keyboard Down Arrow - orbisKeyboardNames[0][KEY_UP]=0x02; //0x52 // Keyboard Up Arrow - - //orbisKeyboardNames[0][KEY_NONUS_BACKSLASH]="º"; //0x0064 - //orbisKeyboardNames[1][KEY_NONUS_BACKSLASH]="ª"; //0x0064 - - orbisKeyboardNames[2][KEY_NONUS_BACKSLASH]=0x5c; //0x0064 with alt - orbisKeyboardNames[2][KEY_1]=0x7c; //0x001e with alt - orbisKeyboardNames[2][KEY_2]=0x40; //0x001f with alt - orbisKeyboardNames[2][KEY_3]=0x23; //0x0020 with alt - orbisKeyboardNames[2][KEY_4]=0x7e; //0x0021 with alt - //orbisKeyboardNames[2][KEY_6]="¬"; //0x0023 with alt - orbisKeyboardNames[2][KEY_LEFTBRACE]=0x5b; //0x002f with alt - orbisKeyboardNames[2][KEY_RIGHTBRACE]=0x5d; //0x0030 with alt - orbisKeyboardNames[2][KEY_APOSTROPHE]=0x7b; //0x0034 with alt - orbisKeyboardNames[2][KEY_BACKSLASH]=0x7d; //0x0031 with alt - - -} -/*void orbisKeyboardInitKeyNames() -{ - orbisKeyboardNames[0][KEY_A]="a"; //0x0004 Keyboard a and A - orbisKeyboardNames[0][KEY_B]="b"; //0x0005 // Keyboard b and B - orbisKeyboardNames[0][KEY_C]="c"; //0x0006 // Keyboard c and C - orbisKeyboardNames[0][KEY_D]="d"; //0x0007 // Keyboard d and D - orbisKeyboardNames[0][KEY_E]="e"; //0x0008 // Keyboard e and E - orbisKeyboardNames[0][KEY_F]="f"; //0x0009 // Keyboard f and F - orbisKeyboardNames[0][KEY_G]="g"; //0x000a // Keyboard g and G - orbisKeyboardNames[0][KEY_H]="h"; //0x000b // Keyboard h and H - orbisKeyboardNames[0][KEY_I]="i"; //0x000c // Keyboard i and I - orbisKeyboardNames[0][KEY_J]="j"; //0x000d // Keyboard j and J - orbisKeyboardNames[0][KEY_K]="k"; //0x000e // Keyboard k and K - orbisKeyboardNames[0][KEY_L]="l"; //0x000f // Keyboard l and L - orbisKeyboardNames[0][KEY_M]="m"; //0x0010 // Keyboard m and M - orbisKeyboardNames[0][KEY_N]="n"; //0x0011 // Keyboard n and N - orbisKeyboardNames[0][KEY_O]="o"; //0x0012 // Keyboard o and O - orbisKeyboardNames[0][KEY_P]="p"; //0x0013 // Keyboard p and P - orbisKeyboardNames[0][KEY_Q]="q"; //0x0014 // Keyboard q and Q - orbisKeyboardNames[0][KEY_R]="r"; //0x0015 // Keyboard r and R - orbisKeyboardNames[0][KEY_S]="s"; //0x0016 // Keyboard s and S - orbisKeyboardNames[0][KEY_T]="t"; //0x0017 // Keyboard t and T - orbisKeyboardNames[0][KEY_U]="u"; //0x0018 // Keyboard u and U - orbisKeyboardNames[0][KEY_V]="v"; //0x0019 // Keyboard v and V - orbisKeyboardNames[0][KEY_W]="w"; //0x001a // Keyboard w and W - orbisKeyboardNames[0][KEY_X]="x"; //0x001b // Keyboard x and X - orbisKeyboardNames[0][KEY_Y]="y"; //0x001c // Keyboard y and Y - orbisKeyboardNames[0][KEY_Z]="z"; //0x001d // Keyboard z and Z - - orbisKeyboardNames[1][KEY_A]="A"; //0x0004 Keyboard a and A - orbisKeyboardNames[1][KEY_B]="B"; //0x0005 // Keyboard b and B - orbisKeyboardNames[1][KEY_C]="C"; //0x0006 // Keyboard c and C - orbisKeyboardNames[1][KEY_D]="D"; //0x0007 // Keyboard d and D - orbisKeyboardNames[1][KEY_E]="E"; //0x0008 // Keyboard e and E - orbisKeyboardNames[1][KEY_F]="F"; //0x0009 // Keyboard f and F - orbisKeyboardNames[1][KEY_G]="G"; //0x000a // Keyboard g and G - orbisKeyboardNames[1][KEY_H]="H"; //0x000b // Keyboard h and H - orbisKeyboardNames[1][KEY_I]="I"; //0x000c // Keyboard i and I - orbisKeyboardNames[1][KEY_J]="J"; //0x000d // Keyboard j and J - orbisKeyboardNames[1][KEY_K]="K"; //0x000e // Keyboard k and K - orbisKeyboardNames[1][KEY_L]="L"; //0x000f // Keyboard l and L - orbisKeyboardNames[1][KEY_M]="M"; //0x0010 // Keyboard m and M - orbisKeyboardNames[1][KEY_N]="N"; //0x0011 // Keyboard n and N - orbisKeyboardNames[1][KEY_O]="O"; //0x0012 // Keyboard o and O - orbisKeyboardNames[1][KEY_P]="P"; //0x0013 // Keyboard p and P - orbisKeyboardNames[1][KEY_Q]="Q"; //0x0014 // Keyboard q and Q - orbisKeyboardNames[1][KEY_R]="R"; //0x0015 // Keyboard r and R - orbisKeyboardNames[1][KEY_S]="S"; //0x0016 // Keyboard s and S - orbisKeyboardNames[1][KEY_T]="T"; //0x0017 // Keyboard t and T - orbisKeyboardNames[1][KEY_U]="U"; //0x0018 // Keyboard u and U - orbisKeyboardNames[1][KEY_V]="V"; //0x0019 // Keyboard v and V - orbisKeyboardNames[1][KEY_W]="W"; //0x001a // Keyboard w and W - orbisKeyboardNames[1][KEY_X]="X"; //0x001b // Keyboard x and X - orbisKeyboardNames[1][KEY_Y]="Y"; //0x001c // Keyboard y and Y - orbisKeyboardNames[1][KEY_Z]="Z"; //0x001d // Keyboard z and Z - - orbisKeyboardNames[0][KEY_1]="1"; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[0][KEY_2]="2"; //0x001f // Keyboard 2 and @ - orbisKeyboardNames[0][KEY_3]="3"; //0x0020 // Keyboard 3 and # - orbisKeyboardNames[0][KEY_4]="4"; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[0][KEY_5]="5"; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[0][KEY_6]="6"; //0x0023 // Keyboard 6 and ^ - orbisKeyboardNames[0][KEY_7]="7"; //0x0024 // Keyboard 7 and & - orbisKeyboardNames[0][KEY_8]="8"; //0x0025 // Keyboard 8 and * - orbisKeyboardNames[0][KEY_9]="9"; //0x0026 // Keyboard 9 and ( - orbisKeyboardNames[0][KEY_0]="0"; //0x0027 // Keyboard 0 and ) - - orbisKeyboardNames[1][KEY_1]="!"; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[1][KEY_2]="\""; //0x001f // Keyboard 2 and " - orbisKeyboardNames[1][KEY_3]="·"; //0x0020 // Keyboard 3 and · - orbisKeyboardNames[1][KEY_4]="$"; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[1][KEY_5]="%"; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[1][KEY_6]="&"; //0x0023 // Keyboard 6 and & - orbisKeyboardNames[1][KEY_7]="/"; //0x0024 // Keyboard 7 and / - orbisKeyboardNames[1][KEY_8]="("; //0x0025 // Keyboard 8 and ( - orbisKeyboardNames[1][KEY_9]=")"; //0x0026 // Keyboard 9 and ) - orbisKeyboardNames[1][KEY_0]="="; //0x0027 // Keyboard 0 and = - - - orbisKeyboardNames[0][KEY_ENTER]="\n"; //0x0028 // Keyboard Return (ENTER) - orbisKeyboardNames[0][KEY_ESC]="^["; //0x0029 // Keyboard ESCAPE - orbisKeyboardNames[0][KEY_BACKSPACE]=""; //0x002a // Keyboard DELETE (Backspace) - orbisKeyboardNames[0][KEY_TAB]=" "; //0x002b // Keyboard Tab - orbisKeyboardNames[0][KEY_SPACE]=" "; //0x002c // Keyboard Spacebar - orbisKeyboardNames[0][KEY_MINUS]="'"; //0x002d // Keyboard - and _ in spanish ' - orbisKeyboardNames[1][KEY_MINUS]="?"; //0x002d // Keyboard - and _ in spanish ? - orbisKeyboardNames[0][KEY_EQUAL]="¡"; //0x002e // Keyboard = and + in spanjish ¡ - orbisKeyboardNames[1][KEY_EQUAL]="¿"; //0x002e // Keyboard = and + in spanish ¿ - - orbisKeyboardNames[0][KEY_LEFTBRACE]="`"; //0x2f // Keyboard [ and { in spanish ` - orbisKeyboardNames[1][KEY_LEFTBRACE]="^"; //0x2f // Keyboard [ and { in spanish - orbisKeyboardNames[0][KEY_RIGHTBRACE]="+"; //0x30 // Keyboard ] and } in spanish + - orbisKeyboardNames[1][KEY_RIGHTBRACE]="*"; //0x30 // Keyboard ] and } in spanish * - - orbisKeyboardNames[0][KEY_BACKSLASH]="\\"; //0x31 // Keyboard \ and | not in spanish - orbisKeyboardNames[1][KEY_BACKSLASH]="|"; //0x31 // Keyboard \ and | not in spanish - - orbisKeyboardNames[0][KEY_HASHTILDE]="#"; //0x32 // Keyboard Non-US # and ~ in spanish ç - orbisKeyboardNames[1][KEY_HASHTILDE]="~"; //0x32 // Keyboard Non-US # and ~ in spanish ç - - orbisKeyboardNames[0][KEY_SEMICOLON]="ñ"; //0x33 // Keyboard ; and : in spanish ñ - orbisKeyboardNames[1][KEY_SEMICOLON]="Ñ"; //0x33 // Keyboard ; and : in spanish Ñ - - orbisKeyboardNames[0][KEY_APOSTROPHE]="´"; //0x34 // Keyboard ' and " in spanish ´ - orbisKeyboardNames[1][KEY_APOSTROPHE]="¨"; //0x34 // Keyboard ' and " in spanish - - orbisKeyboardNames[0][KEY_GRAVE]="<"; //0x35 // Keyboard ` and ~ in spanish < - orbisKeyboardNames[1][KEY_GRAVE]=">"; //0x35 // Keyboard ` and ~ in spanish > - - orbisKeyboardNames[0][KEY_COMMA]=","; //0x36 // Keyboard , and < in spanish , - orbisKeyboardNames[1][KEY_COMMA]=";"; //0x36 // Keyboard , and < in spanish ; - - orbisKeyboardNames[0][KEY_DOT]="."; //0x37 // Keyboard . and > in spanish . - orbisKeyboardNames[1][KEY_DOT]=":"; //0x37 // Keyboard . and > in spanish : - - orbisKeyboardNames[0][KEY_SLASH]="-"; //0x38 // Keyboard / and ? in spanish - - orbisKeyboardNames[1][KEY_SLASH]="_"; //0x38 // Keyboard / and ? in spanish _ - - orbisKeyboardNames[0][KEY_CAPSLOCK]=""; //0x39 // Keyboard Caps Lock not in normal keycode vita use special key 0x2 in reports.modifiers[1] - - orbisKeyboardNames[0][KEY_F1]=""; //0x3a // Keyboard F1 - orbisKeyboardNames[0][KEY_F2]=""; //0x3b // Keyboard F2 - orbisKeyboardNames[0][KEY_F3]=""; //0x3c // Keyboard F3 - orbisKeyboardNames[0][KEY_F4]=""; //0x3d // Keyboard F4 - orbisKeyboardNames[0][KEY_F5]=""; //0x3e // Keyboard F5 - orbisKeyboardNames[0][KEY_F6]=""; //0x3f // Keyboard F6 - orbisKeyboardNames[0][KEY_F7]=""; //0x40 // Keyboard F7 - orbisKeyboardNames[0][KEY_F8]=""; //0x41 // Keyboard F8 - orbisKeyboardNames[0][KEY_F9]=""; //0x42 // Keyboard F9 - orbisKeyboardNames[0][KEY_F10]=""; //0x43 // Keyboard F10 - orbisKeyboardNames[0][KEY_F11]=""; //0x44 // Keyboard F11 - orbisKeyboardNames[0][KEY_F12]=""; //0x45 // Keyboard F12 - - orbisKeyboardNames[0][KEY_SYSRQ]=""; //0x46 // Keyboard Print Screen - orbisKeyboardNames[0][KEY_SCROLLLOCK]=""; //0x47 // Keyboard Scroll Lock - orbisKeyboardNames[0][KEY_PAUSE]=""; //0x48 // Keyboard Pause - orbisKeyboardNames[0][KEY_INSERT]=""; //0x49 // Keyboard Insert - orbisKeyboardNames[0][KEY_HOME]=""; //0x4a // Keyboard Home - orbisKeyboardNames[0][KEY_PAGEUP]=""; //0x4b // Keyboard Page Up - orbisKeyboardNames[0][KEY_DELETE]=""; //0x4c // Keyboard Delete Forward - orbisKeyboardNames[0][KEY_END]=""; //0x4d // Keyboard End - orbisKeyboardNames[0][KEY_PAGEDOWN]=""; //0x4e // Keyboard Page Down - - orbisKeyboardNames[0][KEY_RIGHT]=""; //0x4f // Keyboard Right Arrow - orbisKeyboardNames[0][KEY_LEFT]=""; //0x50 // Keyboard Left Arrow - orbisKeyboardNames[0][KEY_DOWN]=""; //0x51 // Keyboard Down Arrow - orbisKeyboardNames[0][KEY_UP]=""; //0x52 // Keyboard Up Arrow - - orbisKeyboardNames[0][KEY_NONUS_BACKSLASH]="º"; //0x0064 - orbisKeyboardNames[1][KEY_NONUS_BACKSLASH]="ª"; //0x0064 - - orbisKeyboardNames[2][KEY_NONUS_BACKSLASH]="\\"; //0x0064 with alt - orbisKeyboardNames[2][KEY_1]="|"; //0x001e with alt - orbisKeyboardNames[2][KEY_2]="@"; //0x001f with alt - orbisKeyboardNames[2][KEY_3]="#"; //0x0020 with alt - orbisKeyboardNames[2][KEY_4]="~"; //0x0021 with alt - orbisKeyboardNames[2][KEY_6]="¬"; //0x0023 with alt - orbisKeyboardNames[2][KEY_LEFTBRACE]="["; //0x002f with alt - orbisKeyboardNames[2][KEY_RIGHTBRACE]="]"; //0x0030 with alt - orbisKeyboardNames[2][KEY_APOSTROPHE]="{"; //0x0034 with alt - orbisKeyboardNames[2][KEY_BACKSLASH]="}"; //0x0031 with alt - - -}*/ -OrbisKeyboardConfig * orbisKeyboardGetConf() -{ - return orbisKeyboardConf; -} -uint8_t orbisKeyboardGetMsxKey() -{ - if(orbisKeyboardConf!=NULL) - { - //debugNetPrintf(DEBUG,"liborbiskeyboard orbisKeyboardGetMsxKey key:0x%08x status:%d \n",orbisKeyboardConf->key,orbisKeyboardConf->key_status); - - return orbisKeyboardConf->key; - - } - return 0; -} -uint8_t orbisKeyboardGetMsxKeyStatus() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->key_status; - } - return 0; -} -uint8_t orbisKeyboardGetMsxKeyShift() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - return 0; -} -uint8_t orbisKeyboardGetMsxKeyCtrl() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->control_key_left|orbisKeyboardConf->control_key_right; - } - return 0; -} -int orbisKeyboardCreateConf() -{ - if(!orbisKeyboardConf) - { - orbisKeyboardConf=(OrbisKeyboardConfig *)malloc(sizeof(OrbisKeyboardConfig)); - - orbisKeyboardConf->userId=0; - orbisKeyboardConf->status=-1; - orbisKeyboardConf->caps_key=0; - orbisKeyboardConf->control_key_left=0; - orbisKeyboardConf->control_key_right=0; - orbisKeyboardConf->shift_key_left=0; - orbisKeyboardConf->shift_key_right=0; - orbisKeyboardConf->alt_key_left=0; - orbisKeyboardConf->alt_key_right=0; - orbisKeyboardConf->cmd_key_left=0; - orbisKeyboardConf->cmd_key_right=0; - orbisKeyboardConf->key=0; - orbisKeyboardConf->key_status=0; - orbisKeyboardConf->orbiskeyboard_initialized=-1; - - return 0; - } - - if(orbisKeyboardConf->orbiskeyboard_initialized==1) - { - return orbisKeyboardConf->orbiskeyboard_initialized; - } - //something weird happened - return -1; -} -int orbisKeyboardGetHandle() -{ - //return 0 when keyboard is opened simulate handle for sdl stuff - return orbisKeyboardConf->status; -} -int orbisKeyboardGetStatus() -{ - return orbisKeyboardConf->orbiskeyboard_initialized; -} -uint8_t orbisKeyboardGetKey() -{ - return orbisKeyboardConf->key; -} -int orbisKeyboardGetCapsKey() -{ - return orbisKeyboardConf->caps_key; -} -int orbisKeyboardGetControlKeyLeft() -{ - return orbisKeyboardConf->control_key_left; -} -int orbisKeyboardGetControlKeyRight() -{ - return orbisKeyboardConf->control_key_right; -} -int orbisKeyboardGetShiftKeyLeft() -{ - return orbisKeyboardConf->shift_key_left; -} -int orbisKeyboardGetShiftKeyRight() -{ - return orbisKeyboardConf->shift_key_right; -} -int orbisKeyboardGetAltKeyLeft() -{ - return orbisKeyboardConf->alt_key_left; -} -int orbisKeyboardGetAltKeyRight() -{ - return orbisKeyboardConf->alt_key_right; -} -int orbisKeyboardGetCmdKeyLeft() -{ - return orbisKeyboardConf->cmd_key_left; -} -int orbisKeyboardGetCmdKeyRight() -{ - return orbisKeyboardConf->cmd_key_right; -} -uint8_t orbisKeyboardGetSpecials() -{ - return orbisKeyboardConf->control_key_left|orbisKeyboardConf->control_key_right<<1|orbisKeyboardConf->shift_key_left<<2|orbisKeyboardConf->shift_key_right<<3|orbisKeyboardConf->alt_key_left<<4|orbisKeyboardConf->alt_key_right<<5|orbisKeyboardConf->cmd_key_left<<6|orbisKeyboardConf->alt_key_right<<7; -} -void orbisKeybordGetSpecialKeys(const OrbisKeyboardEvent *e) -{ - if(e->param.keycode.status&0x00020000) - { - orbisKeyboardConf->caps_key=1; - } - else - { - orbisKeyboardConf->caps_key=0; - } - if(e->param.keycode.status&0x00000100) - { - orbisKeyboardConf->control_key_left=1; - } - else - { - orbisKeyboardConf->control_key_left=0; - } - if(e->param.keycode.status&0x00001000) - { - orbisKeyboardConf->control_key_right=1; - } - else - { - orbisKeyboardConf->control_key_right=0; - } - if(e->param.keycode.status&0x00000200) - { - orbisKeyboardConf->shift_key_left=1; - } - else - { - orbisKeyboardConf->shift_key_left=0; - } - if(e->param.keycode.status&0x00002000) - { - orbisKeyboardConf->shift_key_right=1; - } - else - { - orbisKeyboardConf->shift_key_right=0; - } - if(e->param.keycode.status&0x00000400) - { - orbisKeyboardConf->alt_key_left=1; - } - else - { - orbisKeyboardConf->alt_key_left=0; - } - if(e->param.keycode.status&0x00004000) - { - orbisKeyboardConf->alt_key_right=1; - } - else - { - orbisKeyboardConf->alt_key_right=0; - } - if(e->param.keycode.status&0x00000800) - { - orbisKeyboardConf->cmd_key_left=1; - } - else - { - orbisKeyboardConf->cmd_key_left=0; - } - if(e->param.keycode.status&0x00008000) - { - orbisKeyboardConf->cmd_key_right=1; - } - else - { - orbisKeyboardConf->cmd_key_right=0; - } -} -static void orbisKeyboardEventUpdate(void *arg,const OrbisKeyboardEvent *e) -{ - int i; - int index; - switch(e->id) - { - case ORBIS_KEYBOARD_EVENT_OPEN: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard opened for userId:0x%08x\n",e->param.resourceIdArray.userId); - for(i=0;i<3;i++) - { - debugNetPrintf(DEBUGNET_DEBUG,"%d ",e->param.resourceIdArray.resourceId[i]); - } - debugNetPrintf(DEBUGNET_DEBUG,"\n"); - break; - case ORBIS_KEYBOARD_EVENT_KEYCODE_DOWN: - - orbisKeybordGetSpecialKeys(e); - - if(e->param.keycode.keycode<0x001e || e->param.keycode.keycode==0x0033) - { - index=orbisKeyboardConf->caps_key|orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - else - { - index=orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - if(orbisKeyboardConf->alt_key_left|orbisKeyboardConf->alt_key_right) - { - index=2; - } - debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for keycode:0x%04X\n",e->param.keycode.keycode); - debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for status:%8x\n",e->param.keycode.status); - //debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for unknown1:%8x\n",e->param.keycode.unknown1); - //debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for userId:%8x\n",e->param.keycode.userId); - //debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for resourceId:%8x\n",e->param.keycode.resourceId); - //debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for unknown2:%8x\n",e->param.keycode.unknown2); - - //debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for timestamp:%lu\n",e->param.keycode.timestamp); - debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down for caps %d ctrll %d ctrlr %d shiftl %d shiftr %d altl %d altr %d cmdl %d cmdr %d\n",orbisKeyboardConf->caps_key,orbisKeyboardConf->control_key_left,orbisKeyboardConf->control_key_right,orbisKeyboardConf->shift_key_left,orbisKeyboardConf->shift_key_right,orbisKeyboardConf->alt_key_left,orbisKeyboardConf->alt_key_right,orbisKeyboardConf->cmd_key_left,orbisKeyboardConf->cmd_key_right); - // if((e->param.keycode.status&0x00000003)==0x00000003) - - if((e->param.keycode.status&0x00000003)) - { - debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down :%02X\n",orbisKeyboardNames[index][e->param.keycode.keycode]); - orbisKeyboardConf->key=orbisKeyboardNames[index][e->param.keycode.keycode]; - debugNetPrintf(DEBUGNET_DEBUG, "liborbiskeyboard key down :%02X\n",orbisKeyboardConf->key); - - orbisKeyboardConf->key_status=1; - } - - - - break; - - case ORBIS_KEYBOARD_EVENT_KEYCODE_UP: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard key up for keycode:0x%04x\n",e->param.keycode.keycode); - orbisKeybordGetSpecialKeys(e); - if(e->param.keycode.keycode<0x001e || e->param.keycode.keycode==0x0033) - { - index=orbisKeyboardConf->caps_key|orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - else - { - index=orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - if(orbisKeyboardConf->alt_key_left|orbisKeyboardConf->alt_key_right) - { - index=2; - } - orbisKeyboardConf->key=orbisKeyboardNames[index][e->param.keycode.keycode]; - orbisKeyboardConf->key_status=0; - - break; - case ORBIS_KEYBOARD_EVENT_KEYCODE_REPEAT: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard key repeat for keycode:0x%04x\n",e->param.keycode.keycode); - break; - case ORBIS_KEYBOARD_EVENT_CONNECTION: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard connected for userId:0x%08x\n",e->param.resourceIdArray.userId); - for(i=0;i<3;i++) - { - debugNetPrintf(DEBUGNET_DEBUG,"%d ",e->param.resourceIdArray.resourceId[i]); - } - debugNetPrintf(DEBUGNET_DEBUG,"\n"); - break; - case ORBIS_KEYBOARD_EVENT_DISCONNECTION: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard disconnected for userId:0x%08x\n",e->param.resourceIdArray.userId); - for(i=0;i<3;i++) - { - debugNetPrintf(DEBUGNET_DEBUG,"%d ",e->param.resourceIdArray.resourceId[i]); - } - debugNetPrintf(DEBUGNET_DEBUG,"\n"); - break; - case ORBIS_KEYBOARD_EVENT_ABORT: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard aborted\n"); - - break; - default: - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard unknown event\n"); - - break; - } -} -void orbisKeyboardUpdate() -{ - if(orbisKeyboardConf!=NULL) - { - //if(orbisKeyboardConf->orbiskeyboard_initialized==1 && orbisKeyboardConf->status==0) - //{ - //debugNetPrintf(DEBUG,"orbisKeyboardUpdate 0x%8x \n",sceImeUpdate(orbisKeyboardEventUpdate)); - sceImeUpdate(orbisKeyboardEventUpdate); - - //} - } -} -void orbisKeyboardClose() -{ - int ret; - if(orbisKeyboardConf!=NULL) - { - if(orbisKeyboardConf->orbiskeyboard_initialized!=1) - { - return; - } - if(orbisKeyboardConf->status==0 ) - { - ret=sceImeKeyboardClose(orbisKeyboardConf->userId); - if(ret<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard sceImeKeyboardClose return error 0x%8x\n",ret); - - } - orbisKeyboardConf->status=-1; - - } - } -} -int orbisKeyboardOpen() -{ - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard sceImeKeyboardOpen in\n"); - sleep(1); - OrbisKeyboardParam param; - int ret; - if(orbisKeyboardConf!=NULL) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard orbisKeyboardConf not null \n"); - - if(orbisKeyboardConf->orbiskeyboard_initialized!=1 ) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard orbisKeyboardConf %d \n",orbisKeyboardConf->orbiskeyboard_initialized); - - return -1; - } - - memset(¶m,0,sizeof(OrbisKeyboardParam)); - param.option=0; - param.handler=orbisKeyboardEventUpdate; - ret=sceImeKeyboardOpen(orbisKeyboardConf->userId,¶m); - sleep(1); - if(ret<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard sceImeKeyboardOpen return error 0x%8x\n",ret); - return -1; - } - sleep(1); - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard sceImeKeyboardOpen return success %d\n",ret); - orbisKeyboardConf->status=0; //opened - return 0; - } - else - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard orbisKeyboardOpen error config null\n"); - - return -1; - } -} -void orbisKeyboardFinish() -{ - if(orbiskeyboard_external_conf!=1) - { - if(orbisKeyboardConf!=NULL) - { - orbisKeyboardClose(); - sceSysmoduleUnloadModule(ORBIS_IME_MODULE); - orbisKeyboardConf->userId=0; - orbisKeyboardConf->orbiskeyboard_initialized=-1; - debugNetPrintf(DEBUGNET_DEBUG,"liborbisKeyboard finished\n"); - - } - } - -} -int orbisKeyboardSetConf(OrbisKeyboardConfig *conf) -{ - if(conf) - { - orbisKeyboardConf=conf; - orbiskeyboard_external_conf=1; - return orbisKeyboardConf->orbiskeyboard_initialized; - } - - return 0; -} -int orbisKeyboardInitWithConf(OrbisKeyboardConfig *conf) -{ - int ret=orbisKeyboardSetConf(conf); - if(ret) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbisKeyboard already initialized using configuration external\n"); - debugNetPrintf(DEBUGNET_DEBUG,"orbiskeyboard_initialized=%d\n",orbisKeyboardConf->orbiskeyboard_initialized); - debugNetPrintf(DEBUGNET_DEBUG,"ready to have a lot of fun :P ...\n"); - return orbisKeyboardConf->orbiskeyboard_initialized; - } - else - { - return 0; - } -} - -int orbisKeyboardInit() -{ - int ret; - if(orbisKeyboardCreateConf()==1) - { - return orbisKeyboardConf->orbiskeyboard_initialized; - } - if (orbisKeyboardConf->orbiskeyboard_initialized==1) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard is already initialized!\n"); - return orbisKeyboardConf->orbiskeyboard_initialized; - } - - ret=sceSysmoduleLoadModule(ORBIS_IME_MODULE); - - if(ret<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard sceSysmoduleLoadModule return error 0x%8x\n",ret); - return -1; - } - //if we have orbisPad initialized then UserService module is already loaded, so first call orbisPadInit before orbisKeyboardInit - ret=sceUserServiceGetInitialUser(&orbisKeyboardConf->userId); - - if(ret<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard sceUserServiceGetInitialUser return error 0x%8x\n",ret); - return -1; - - } - orbisKeyboardInitKeyNames(); - - orbisKeyboardConf->orbiskeyboard_initialized=1; - - debugNetPrintf(DEBUGNET_DEBUG,"liborbiskeyboard is initialized!\n"); - - return orbisKeyboardConf->orbiskeyboard_initialized; - -} diff --git a/source/liborbisKeyboard/orbisKeyboard.c.old b/source/liborbisKeyboard/orbisKeyboard.c.old deleted file mode 100644 index 8e8de65..0000000 --- a/source/liborbisKeyboard/orbisKeyboard.c.old +++ /dev/null @@ -1,791 +0,0 @@ -/* - * liborbis - * Copyright (C) 2015,2016,2017 Antonio Jose Ramos Marquez (aka bigboss) @psxdev on twitter - * Repository https://github.com/psxdev/liborbis - */ -#include -#include -#include -#include -#include -#include -#include -#include "orbisKeyboard.h" -#include "kb.h" - -OrbisKeyboardConfig *orbisKeyboardConf=NULL; -int orbiskeyboard_external_conf=-1; -uint8_t orbisKeyboardNames[3][256]; -void orbisKeyboardInitKeyNames() -{ - orbisKeyboardNames[0][KEY_A]=0x61; //0x0004 Keyboard a and A - orbisKeyboardNames[0][KEY_B]=0x62; //0x0005 // Keyboard b and B - orbisKeyboardNames[0][KEY_C]=0x63; //0x0006 // Keyboard c and C - orbisKeyboardNames[0][KEY_D]=0x64; //0x0007 // Keyboard d and D - orbisKeyboardNames[0][KEY_E]=0x65; //0x0008 // Keyboard e and E - orbisKeyboardNames[0][KEY_F]=0x66; //0x0009 // Keyboard f and F - orbisKeyboardNames[0][KEY_G]=0x67; //0x000a // Keyboard g and G - orbisKeyboardNames[0][KEY_H]=0x68; //0x000b // Keyboard h and H - orbisKeyboardNames[0][KEY_I]=0x69; //0x000c // Keyboard i and I - orbisKeyboardNames[0][KEY_J]=0x6a; //0x000d // Keyboard j and J - orbisKeyboardNames[0][KEY_K]=0x6b; //0x000e // Keyboard k and K - orbisKeyboardNames[0][KEY_L]=0x6c; //0x000f // Keyboard l and L - orbisKeyboardNames[0][KEY_M]=0x6d; //0x0010 // Keyboard m and M - orbisKeyboardNames[0][KEY_N]=0x6e; //0x0011 // Keyboard n and N - orbisKeyboardNames[0][KEY_O]=0x6f; //0x0012 // Keyboard o and O - orbisKeyboardNames[0][KEY_P]=0x70; //0x0013 // Keyboard p and P - orbisKeyboardNames[0][KEY_Q]=0x71; //0x0014 // Keyboard q and Q - orbisKeyboardNames[0][KEY_R]=0x72; //0x0015 // Keyboard r and R - orbisKeyboardNames[0][KEY_S]=0x73; //0x0016 // Keyboard s and S - orbisKeyboardNames[0][KEY_T]=0x74; //0x0017 // Keyboard t and T - orbisKeyboardNames[0][KEY_U]=0x75; //0x0018 // Keyboard u and U - orbisKeyboardNames[0][KEY_V]=0x76; //0x0019 // Keyboard v and V - orbisKeyboardNames[0][KEY_W]=0x77; //0x001a // Keyboard w and W - orbisKeyboardNames[0][KEY_X]=0x78; //0x001b // Keyboard x and X - orbisKeyboardNames[0][KEY_Y]=0x79; //0x001c // Keyboard y and Y - orbisKeyboardNames[0][KEY_Z]=0x7a; //0x001d // Keyboard z and Z - - orbisKeyboardNames[1][KEY_A]=0x41; //0x0004 Keyboard a and A - orbisKeyboardNames[1][KEY_B]=0x42; //0x0005 // Keyboard b and B - orbisKeyboardNames[1][KEY_C]=0x43; //0x0006 // Keyboard c and C - orbisKeyboardNames[1][KEY_D]=0x44; //0x0007 // Keyboard d and D - orbisKeyboardNames[1][KEY_E]=0x45; //0x0008 // Keyboard e and E - orbisKeyboardNames[1][KEY_F]=0x46; //0x0009 // Keyboard f and F - orbisKeyboardNames[1][KEY_G]=0x47; //0x000a // Keyboard g and G - orbisKeyboardNames[1][KEY_H]=0x48; //0x000b // Keyboard h and H - orbisKeyboardNames[1][KEY_I]=0x49; //0x000c // Keyboard i and I - orbisKeyboardNames[1][KEY_J]=0x4a; //0x000d // Keyboard j and J - orbisKeyboardNames[1][KEY_K]=0x4b; //0x000e // Keyboard k and K - orbisKeyboardNames[1][KEY_L]=0x4c; //0x000f // Keyboard l and L - orbisKeyboardNames[1][KEY_M]=0x4d; //0x0010 // Keyboard m and M - orbisKeyboardNames[1][KEY_N]=0x4e; //0x0011 // Keyboard n and N - orbisKeyboardNames[1][KEY_O]=0x4f; //0x0012 // Keyboard o and O - orbisKeyboardNames[1][KEY_P]=0x50; //0x0013 // Keyboard p and P - orbisKeyboardNames[1][KEY_Q]=0x51; //0x0014 // Keyboard q and Q - orbisKeyboardNames[1][KEY_R]=0x52; //0x0015 // Keyboard r and R - orbisKeyboardNames[1][KEY_S]=0x53; //0x0016 // Keyboard s and S - orbisKeyboardNames[1][KEY_T]=0x54; //0x0017 // Keyboard t and T - orbisKeyboardNames[1][KEY_U]=0x55; //0x0018 // Keyboard u and U - orbisKeyboardNames[1][KEY_V]=0x56; //0x0019 // Keyboard v and V - orbisKeyboardNames[1][KEY_W]=0x57; //0x001a // Keyboard w and W - orbisKeyboardNames[1][KEY_X]=0x58; //0x001b // Keyboard x and X - orbisKeyboardNames[1][KEY_Y]=0x59; //0x001c // Keyboard y and Y - orbisKeyboardNames[1][KEY_Z]=0x5a; //0x001d // Keyboard z and Z - - orbisKeyboardNames[0][KEY_1]=0x31; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[0][KEY_2]=0x32; //0x001f // Keyboard 2 and @ - orbisKeyboardNames[0][KEY_3]=0x33; //0x0020 // Keyboard 3 and # - orbisKeyboardNames[0][KEY_4]=0x34; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[0][KEY_5]=0x35; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[0][KEY_6]=0x36; //0x0023 // Keyboard 6 and ^ - orbisKeyboardNames[0][KEY_7]=0x37; //0x0024 // Keyboard 7 and & - orbisKeyboardNames[0][KEY_8]=0x38; //0x0025 // Keyboard 8 and * - orbisKeyboardNames[0][KEY_9]=0x39; //0x0026 // Keyboard 9 and ( - orbisKeyboardNames[0][KEY_0]=0x30; //0x0027 // Keyboard 0 and ) - - orbisKeyboardNames[1][KEY_1]=0x21; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[1][KEY_2]=0x22; //0x001f // Keyboard 2 and " - orbisKeyboardNames[1][KEY_3]=0x23; //0x0020 // Keyboard 3 and # - orbisKeyboardNames[1][KEY_4]=0x24; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[1][KEY_5]=0x25; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[1][KEY_6]=0x26; //0x0023 // Keyboard 6 and & - orbisKeyboardNames[1][KEY_7]=0x27; //0x0024 // Keyboard 7 and ` - orbisKeyboardNames[1][KEY_8]=0x28; //0x0025 // Keyboard 8 and ( - orbisKeyboardNames[1][KEY_9]=0x29; //0x0026 // Keyboard 9 and ) - orbisKeyboardNames[1][KEY_0]=0; //0x0027 // Keyboard 0 and = - - - orbisKeyboardNames[0][KEY_ENTER]=0x0d; //0x0028 // Keyboard Return (ENTER) - orbisKeyboardNames[0][KEY_ESC]=0x1b; //0x0029 // Keyboard ESCAPE - orbisKeyboardNames[0][KEY_BACKSPACE]=0x08; //0x002a // Keyboard DELETE (Backspace) - orbisKeyboardNames[0][KEY_TAB]=0x09; //0x002b // Keyboard Tab - orbisKeyboardNames[0][KEY_SPACE]=0x20; //0x002c // Keyboard Spacebar - orbisKeyboardNames[0][KEY_MINUS]=0x27; //0x002d // Keyboard - and _ in spanish ' - orbisKeyboardNames[1][KEY_MINUS]=0x3f; //0x002d // Keyboard - and _ in spanish ? - //orbisKeyboardNames[0][KEY_EQUAL]="¡"; //0x002e // Keyboard = and + in spanjish ¡ - //orbisKeyboardNames[1][KEY_EQUAL]="¿"; //0x002e // Keyboard = and + in spanish ¿ - - orbisKeyboardNames[0][KEY_LEFTBRACE]=0x60; //0x2f // Keyboard [ and { in spanish ` - orbisKeyboardNames[1][KEY_LEFTBRACE]=0x7e; //0x2f // Keyboard [ and { in spanish - //orbisKeyboardNames[0][KEY_RIGHTBRACE]="+"; //0x30 // Keyboard ] and } in spanish + - orbisKeyboardNames[1][KEY_RIGHTBRACE]=0x2a; //0x30 // Keyboard ] and } in spanish * - - //orbisKeyboardNames[0][KEY_BACKSLASH]="\\"; //0x31 // Keyboard \ and | not in spanish - //orbisKeyboardNames[1][KEY_BACKSLASH]="|"; //0x31 // Keyboard \ and | not in spanish - - //orbisKeyboardNames[0][KEY_HASHTILDE]="#"; //0x32 // Keyboard Non-US # and ~ in spanish ç - //orbisKeyboardNames[1][KEY_HASHTILDE]="~"; //0x32 // Keyboard Non-US # and ~ in spanish ç - - //orbisKeyboardNames[0][KEY_SEMICOLON]="ñ"; //0x33 // Keyboard ; and : in spanish ñ - //orbisKeyboardNames[1][KEY_SEMICOLON]="Ñ"; //0x33 // Keyboard ; and : in spanish Ñ - - //orbisKeyboardNames[0][KEY_APOSTROPHE]="´"; //0x34 // Keyboard ' and " in spanish ´ - //orbisKeyboardNames[1][KEY_APOSTROPHE]="¨"; //0x34 // Keyboard ' and " in spanish - - orbisKeyboardNames[0][KEY_GRAVE]=0x3c; //0x35 // Keyboard ` and ~ in spanish < - orbisKeyboardNames[1][KEY_GRAVE]=0x3e; //0x35 // Keyboard ` and ~ in spanish > - - orbisKeyboardNames[0][KEY_COMMA]=0x2c; //0x36 // Keyboard , and < in spanish , - orbisKeyboardNames[1][KEY_COMMA]=0x3b; //0x36 // Keyboard , and < in spanish ; - - orbisKeyboardNames[0][KEY_DOT]=0x2e; //0x37 // Keyboard . and > in spanish . - orbisKeyboardNames[1][KEY_DOT]=0x3a; //0x37 // Keyboard . and > in spanish : - - orbisKeyboardNames[0][KEY_SLASH]=0x2d; //0x38 // Keyboard / and ? in spanish - - orbisKeyboardNames[1][KEY_SLASH]=0x5f; //0x38 // Keyboard / and ? in spanish _ - - orbisKeyboardNames[0][KEY_CAPSLOCK]=0x0a; //0x39 // Keyboard Caps Lock not in normal keycode vita use special key 0x2 in reports.modifiers[1] - - orbisKeyboardNames[0][KEY_F1]=0x12; //0x3a // Keyboard F1 - orbisKeyboardNames[0][KEY_F2]=0x13; //0x3b // Keyboard F2 - orbisKeyboardNames[0][KEY_F3]=0x14; //0x3c // Keyboard F3 - orbisKeyboardNames[0][KEY_F4]=0x15; //0x3d // Keyboard F4 - orbisKeyboardNames[0][KEY_F5]=0x16; //0x3e // Keyboard F5 - orbisKeyboardNames[0][KEY_F6]=0; //0x3f // Keyboard F6 - orbisKeyboardNames[0][KEY_F7]=0; //0x40 // Keyboard F7 - orbisKeyboardNames[0][KEY_F8]=0; //0x41 // Keyboard F8 - orbisKeyboardNames[0][KEY_F9]=0; //0x42 // Keyboard F9 - orbisKeyboardNames[0][KEY_F10]=0; //0x43 // Keyboard F10 - orbisKeyboardNames[0][KEY_F11]=0; //0x44 // Keyboard F11 - orbisKeyboardNames[0][KEY_F12]=0x11; //0x45 // Keyboard F12 MSX STOP - - - orbisKeyboardNames[0][KEY_RIGHT]=0x03; //0x4f // Keyboard Right Arrow - orbisKeyboardNames[0][KEY_LEFT]=0x01; //0x50 // Keyboard Left Arrow - orbisKeyboardNames[0][KEY_DOWN]=0x04; //0x51 // Keyboard Down Arrow - orbisKeyboardNames[0][KEY_UP]=0x02; //0x52 // Keyboard Up Arrow - - //orbisKeyboardNames[0][KEY_NONUS_BACKSLASH]="º"; //0x0064 - //orbisKeyboardNames[1][KEY_NONUS_BACKSLASH]="ª"; //0x0064 - - orbisKeyboardNames[2][KEY_NONUS_BACKSLASH]=0x5c; //0x0064 with alt - orbisKeyboardNames[2][KEY_1]=0x7c; //0x001e with alt - orbisKeyboardNames[2][KEY_2]=0x40; //0x001f with alt - orbisKeyboardNames[2][KEY_3]=0x23; //0x0020 with alt - orbisKeyboardNames[2][KEY_4]=0x7e; //0x0021 with alt - //orbisKeyboardNames[2][KEY_6]="¬"; //0x0023 with alt - orbisKeyboardNames[2][KEY_LEFTBRACE]=0x5b; //0x002f with alt - orbisKeyboardNames[2][KEY_RIGHTBRACE]=0x5d; //0x0030 with alt - orbisKeyboardNames[2][KEY_APOSTROPHE]=0x7b; //0x0034 with alt - orbisKeyboardNames[2][KEY_BACKSLASH]=0x7d; //0x0031 with alt - - -} -/*void orbisKeyboardInitKeyNames() -{ - orbisKeyboardNames[0][KEY_A]="a"; //0x0004 Keyboard a and A - orbisKeyboardNames[0][KEY_B]="b"; //0x0005 // Keyboard b and B - orbisKeyboardNames[0][KEY_C]="c"; //0x0006 // Keyboard c and C - orbisKeyboardNames[0][KEY_D]="d"; //0x0007 // Keyboard d and D - orbisKeyboardNames[0][KEY_E]="e"; //0x0008 // Keyboard e and E - orbisKeyboardNames[0][KEY_F]="f"; //0x0009 // Keyboard f and F - orbisKeyboardNames[0][KEY_G]="g"; //0x000a // Keyboard g and G - orbisKeyboardNames[0][KEY_H]="h"; //0x000b // Keyboard h and H - orbisKeyboardNames[0][KEY_I]="i"; //0x000c // Keyboard i and I - orbisKeyboardNames[0][KEY_J]="j"; //0x000d // Keyboard j and J - orbisKeyboardNames[0][KEY_K]="k"; //0x000e // Keyboard k and K - orbisKeyboardNames[0][KEY_L]="l"; //0x000f // Keyboard l and L - orbisKeyboardNames[0][KEY_M]="m"; //0x0010 // Keyboard m and M - orbisKeyboardNames[0][KEY_N]="n"; //0x0011 // Keyboard n and N - orbisKeyboardNames[0][KEY_O]="o"; //0x0012 // Keyboard o and O - orbisKeyboardNames[0][KEY_P]="p"; //0x0013 // Keyboard p and P - orbisKeyboardNames[0][KEY_Q]="q"; //0x0014 // Keyboard q and Q - orbisKeyboardNames[0][KEY_R]="r"; //0x0015 // Keyboard r and R - orbisKeyboardNames[0][KEY_S]="s"; //0x0016 // Keyboard s and S - orbisKeyboardNames[0][KEY_T]="t"; //0x0017 // Keyboard t and T - orbisKeyboardNames[0][KEY_U]="u"; //0x0018 // Keyboard u and U - orbisKeyboardNames[0][KEY_V]="v"; //0x0019 // Keyboard v and V - orbisKeyboardNames[0][KEY_W]="w"; //0x001a // Keyboard w and W - orbisKeyboardNames[0][KEY_X]="x"; //0x001b // Keyboard x and X - orbisKeyboardNames[0][KEY_Y]="y"; //0x001c // Keyboard y and Y - orbisKeyboardNames[0][KEY_Z]="z"; //0x001d // Keyboard z and Z - - orbisKeyboardNames[1][KEY_A]="A"; //0x0004 Keyboard a and A - orbisKeyboardNames[1][KEY_B]="B"; //0x0005 // Keyboard b and B - orbisKeyboardNames[1][KEY_C]="C"; //0x0006 // Keyboard c and C - orbisKeyboardNames[1][KEY_D]="D"; //0x0007 // Keyboard d and D - orbisKeyboardNames[1][KEY_E]="E"; //0x0008 // Keyboard e and E - orbisKeyboardNames[1][KEY_F]="F"; //0x0009 // Keyboard f and F - orbisKeyboardNames[1][KEY_G]="G"; //0x000a // Keyboard g and G - orbisKeyboardNames[1][KEY_H]="H"; //0x000b // Keyboard h and H - orbisKeyboardNames[1][KEY_I]="I"; //0x000c // Keyboard i and I - orbisKeyboardNames[1][KEY_J]="J"; //0x000d // Keyboard j and J - orbisKeyboardNames[1][KEY_K]="K"; //0x000e // Keyboard k and K - orbisKeyboardNames[1][KEY_L]="L"; //0x000f // Keyboard l and L - orbisKeyboardNames[1][KEY_M]="M"; //0x0010 // Keyboard m and M - orbisKeyboardNames[1][KEY_N]="N"; //0x0011 // Keyboard n and N - orbisKeyboardNames[1][KEY_O]="O"; //0x0012 // Keyboard o and O - orbisKeyboardNames[1][KEY_P]="P"; //0x0013 // Keyboard p and P - orbisKeyboardNames[1][KEY_Q]="Q"; //0x0014 // Keyboard q and Q - orbisKeyboardNames[1][KEY_R]="R"; //0x0015 // Keyboard r and R - orbisKeyboardNames[1][KEY_S]="S"; //0x0016 // Keyboard s and S - orbisKeyboardNames[1][KEY_T]="T"; //0x0017 // Keyboard t and T - orbisKeyboardNames[1][KEY_U]="U"; //0x0018 // Keyboard u and U - orbisKeyboardNames[1][KEY_V]="V"; //0x0019 // Keyboard v and V - orbisKeyboardNames[1][KEY_W]="W"; //0x001a // Keyboard w and W - orbisKeyboardNames[1][KEY_X]="X"; //0x001b // Keyboard x and X - orbisKeyboardNames[1][KEY_Y]="Y"; //0x001c // Keyboard y and Y - orbisKeyboardNames[1][KEY_Z]="Z"; //0x001d // Keyboard z and Z - - orbisKeyboardNames[0][KEY_1]="1"; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[0][KEY_2]="2"; //0x001f // Keyboard 2 and @ - orbisKeyboardNames[0][KEY_3]="3"; //0x0020 // Keyboard 3 and # - orbisKeyboardNames[0][KEY_4]="4"; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[0][KEY_5]="5"; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[0][KEY_6]="6"; //0x0023 // Keyboard 6 and ^ - orbisKeyboardNames[0][KEY_7]="7"; //0x0024 // Keyboard 7 and & - orbisKeyboardNames[0][KEY_8]="8"; //0x0025 // Keyboard 8 and * - orbisKeyboardNames[0][KEY_9]="9"; //0x0026 // Keyboard 9 and ( - orbisKeyboardNames[0][KEY_0]="0"; //0x0027 // Keyboard 0 and ) - - orbisKeyboardNames[1][KEY_1]="!"; //0x001e // Keyboard 1 and ! - orbisKeyboardNames[1][KEY_2]="\""; //0x001f // Keyboard 2 and " - orbisKeyboardNames[1][KEY_3]="·"; //0x0020 // Keyboard 3 and · - orbisKeyboardNames[1][KEY_4]="$"; //0x0021 // Keyboard 4 and $ - orbisKeyboardNames[1][KEY_5]="%"; //0x0022 // Keyboard 5 and % - orbisKeyboardNames[1][KEY_6]="&"; //0x0023 // Keyboard 6 and & - orbisKeyboardNames[1][KEY_7]="/"; //0x0024 // Keyboard 7 and / - orbisKeyboardNames[1][KEY_8]="("; //0x0025 // Keyboard 8 and ( - orbisKeyboardNames[1][KEY_9]=")"; //0x0026 // Keyboard 9 and ) - orbisKeyboardNames[1][KEY_0]="="; //0x0027 // Keyboard 0 and = - - - orbisKeyboardNames[0][KEY_ENTER]="\n"; //0x0028 // Keyboard Return (ENTER) - orbisKeyboardNames[0][KEY_ESC]="^["; //0x0029 // Keyboard ESCAPE - orbisKeyboardNames[0][KEY_BACKSPACE]=""; //0x002a // Keyboard DELETE (Backspace) - orbisKeyboardNames[0][KEY_TAB]=" "; //0x002b // Keyboard Tab - orbisKeyboardNames[0][KEY_SPACE]=" "; //0x002c // Keyboard Spacebar - orbisKeyboardNames[0][KEY_MINUS]="'"; //0x002d // Keyboard - and _ in spanish ' - orbisKeyboardNames[1][KEY_MINUS]="?"; //0x002d // Keyboard - and _ in spanish ? - orbisKeyboardNames[0][KEY_EQUAL]="¡"; //0x002e // Keyboard = and + in spanjish ¡ - orbisKeyboardNames[1][KEY_EQUAL]="¿"; //0x002e // Keyboard = and + in spanish ¿ - - orbisKeyboardNames[0][KEY_LEFTBRACE]="`"; //0x2f // Keyboard [ and { in spanish ` - orbisKeyboardNames[1][KEY_LEFTBRACE]="^"; //0x2f // Keyboard [ and { in spanish - orbisKeyboardNames[0][KEY_RIGHTBRACE]="+"; //0x30 // Keyboard ] and } in spanish + - orbisKeyboardNames[1][KEY_RIGHTBRACE]="*"; //0x30 // Keyboard ] and } in spanish * - - orbisKeyboardNames[0][KEY_BACKSLASH]="\\"; //0x31 // Keyboard \ and | not in spanish - orbisKeyboardNames[1][KEY_BACKSLASH]="|"; //0x31 // Keyboard \ and | not in spanish - - orbisKeyboardNames[0][KEY_HASHTILDE]="#"; //0x32 // Keyboard Non-US # and ~ in spanish ç - orbisKeyboardNames[1][KEY_HASHTILDE]="~"; //0x32 // Keyboard Non-US # and ~ in spanish ç - - orbisKeyboardNames[0][KEY_SEMICOLON]="ñ"; //0x33 // Keyboard ; and : in spanish ñ - orbisKeyboardNames[1][KEY_SEMICOLON]="Ñ"; //0x33 // Keyboard ; and : in spanish Ñ - - orbisKeyboardNames[0][KEY_APOSTROPHE]="´"; //0x34 // Keyboard ' and " in spanish ´ - orbisKeyboardNames[1][KEY_APOSTROPHE]="¨"; //0x34 // Keyboard ' and " in spanish - - orbisKeyboardNames[0][KEY_GRAVE]="<"; //0x35 // Keyboard ` and ~ in spanish < - orbisKeyboardNames[1][KEY_GRAVE]=">"; //0x35 // Keyboard ` and ~ in spanish > - - orbisKeyboardNames[0][KEY_COMMA]=","; //0x36 // Keyboard , and < in spanish , - orbisKeyboardNames[1][KEY_COMMA]=";"; //0x36 // Keyboard , and < in spanish ; - - orbisKeyboardNames[0][KEY_DOT]="."; //0x37 // Keyboard . and > in spanish . - orbisKeyboardNames[1][KEY_DOT]=":"; //0x37 // Keyboard . and > in spanish : - - orbisKeyboardNames[0][KEY_SLASH]="-"; //0x38 // Keyboard / and ? in spanish - - orbisKeyboardNames[1][KEY_SLASH]="_"; //0x38 // Keyboard / and ? in spanish _ - - orbisKeyboardNames[0][KEY_CAPSLOCK]=""; //0x39 // Keyboard Caps Lock not in normal keycode vita use special key 0x2 in reports.modifiers[1] - - orbisKeyboardNames[0][KEY_F1]=""; //0x3a // Keyboard F1 - orbisKeyboardNames[0][KEY_F2]=""; //0x3b // Keyboard F2 - orbisKeyboardNames[0][KEY_F3]=""; //0x3c // Keyboard F3 - orbisKeyboardNames[0][KEY_F4]=""; //0x3d // Keyboard F4 - orbisKeyboardNames[0][KEY_F5]=""; //0x3e // Keyboard F5 - orbisKeyboardNames[0][KEY_F6]=""; //0x3f // Keyboard F6 - orbisKeyboardNames[0][KEY_F7]=""; //0x40 // Keyboard F7 - orbisKeyboardNames[0][KEY_F8]=""; //0x41 // Keyboard F8 - orbisKeyboardNames[0][KEY_F9]=""; //0x42 // Keyboard F9 - orbisKeyboardNames[0][KEY_F10]=""; //0x43 // Keyboard F10 - orbisKeyboardNames[0][KEY_F11]=""; //0x44 // Keyboard F11 - orbisKeyboardNames[0][KEY_F12]=""; //0x45 // Keyboard F12 - - orbisKeyboardNames[0][KEY_SYSRQ]=""; //0x46 // Keyboard Print Screen - orbisKeyboardNames[0][KEY_SCROLLLOCK]=""; //0x47 // Keyboard Scroll Lock - orbisKeyboardNames[0][KEY_PAUSE]=""; //0x48 // Keyboard Pause - orbisKeyboardNames[0][KEY_INSERT]=""; //0x49 // Keyboard Insert - orbisKeyboardNames[0][KEY_HOME]=""; //0x4a // Keyboard Home - orbisKeyboardNames[0][KEY_PAGEUP]=""; //0x4b // Keyboard Page Up - orbisKeyboardNames[0][KEY_DELETE]=""; //0x4c // Keyboard Delete Forward - orbisKeyboardNames[0][KEY_END]=""; //0x4d // Keyboard End - orbisKeyboardNames[0][KEY_PAGEDOWN]=""; //0x4e // Keyboard Page Down - - orbisKeyboardNames[0][KEY_RIGHT]=""; //0x4f // Keyboard Right Arrow - orbisKeyboardNames[0][KEY_LEFT]=""; //0x50 // Keyboard Left Arrow - orbisKeyboardNames[0][KEY_DOWN]=""; //0x51 // Keyboard Down Arrow - orbisKeyboardNames[0][KEY_UP]=""; //0x52 // Keyboard Up Arrow - - orbisKeyboardNames[0][KEY_NONUS_BACKSLASH]="º"; //0x0064 - orbisKeyboardNames[1][KEY_NONUS_BACKSLASH]="ª"; //0x0064 - - orbisKeyboardNames[2][KEY_NONUS_BACKSLASH]="\\"; //0x0064 with alt - orbisKeyboardNames[2][KEY_1]="|"; //0x001e with alt - orbisKeyboardNames[2][KEY_2]="@"; //0x001f with alt - orbisKeyboardNames[2][KEY_3]="#"; //0x0020 with alt - orbisKeyboardNames[2][KEY_4]="~"; //0x0021 with alt - orbisKeyboardNames[2][KEY_6]="¬"; //0x0023 with alt - orbisKeyboardNames[2][KEY_LEFTBRACE]="["; //0x002f with alt - orbisKeyboardNames[2][KEY_RIGHTBRACE]="]"; //0x0030 with alt - orbisKeyboardNames[2][KEY_APOSTROPHE]="{"; //0x0034 with alt - orbisKeyboardNames[2][KEY_BACKSLASH]="}"; //0x0031 with alt - - -}*/ -OrbisKeyboardConfig * orbisKeyboardGetConf() -{ - return orbisKeyboardConf; -} -uint8_t orbisKeyboardGetMsxKey() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->key; - - } - return 0; -} - -uint8_t orbisKeyboardGetMsxKeyStatus() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->key_status; - } - return 0; -} -uint8_t orbisKeyboardGetMsxKeyShift() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - return 0; -} -uint8_t orbisKeyboardGetMsxKeyCtrl() -{ - if(orbisKeyboardConf!=NULL) - { - return orbisKeyboardConf->control_key_left|orbisKeyboardConf->control_key_right; - } - return 0; -} -int orbisKeyboardCreateConf() -{ - if(!orbisKeyboardConf) - { - orbisKeyboardConf=(OrbisKeyboardConfig *)malloc(sizeof(OrbisKeyboardConfig)); - - orbisKeyboardConf->userId=0; - orbisKeyboardConf->status=-1; - orbisKeyboardConf->caps_key=0; - orbisKeyboardConf->control_key_left=0; - orbisKeyboardConf->control_key_right=0; - orbisKeyboardConf->shift_key_left=0; - orbisKeyboardConf->shift_key_right=0; - orbisKeyboardConf->alt_key_left=0; - orbisKeyboardConf->alt_key_right=0; - orbisKeyboardConf->cmd_key_left=0; - orbisKeyboardConf->cmd_key_right=0; - orbisKeyboardConf->key=0; - orbisKeyboardConf->key_status=0; - orbisKeyboardConf->orbiskeyboard_initialized=-1; - - return 0; - } - - if(orbisKeyboardConf->orbiskeyboard_initialized==1) - { - return orbisKeyboardConf->orbiskeyboard_initialized; - } - //something weird happened - return -1; -} -int orbisKeyboardGetHandle() -{ - //return 0 when keyboard is opened simulate handle for sdl stuff - return orbisKeyboardConf->status; -} -int orbisKeyboardGetStatus() -{ - return orbisKeyboardConf->orbiskeyboard_initialized; -} -uint8_t orbisKeyboardGetKey() -{ - return orbisKeyboardConf->key; -} -int orbisKeyboardGetCapsKey() -{ - return orbisKeyboardConf->caps_key; -} -int orbisKeyboardGetControlKeyLeft() -{ - return orbisKeyboardConf->control_key_left; -} -int orbisKeyboardGetControlKeyRight() -{ - return orbisKeyboardConf->control_key_right; -} -int orbisKeyboardGetShiftKeyLeft() -{ - return orbisKeyboardConf->shift_key_left; -} -int orbisKeyboardGetShiftKeyRight() -{ - return orbisKeyboardConf->shift_key_right; -} -int orbisKeyboardGetAltKeyLeft() -{ - return orbisKeyboardConf->alt_key_left; -} -int orbisKeyboardGetAltKeyRight() -{ - return orbisKeyboardConf->alt_key_right; -} -int orbisKeyboardGetCmdKeyLeft() -{ - return orbisKeyboardConf->cmd_key_left; -} -int orbisKeyboardGetCmdKeyRight() -{ - return orbisKeyboardConf->cmd_key_right; -} -uint8_t orbisKeyboardGetSpecials() -{ - return orbisKeyboardConf->control_key_left|orbisKeyboardConf->control_key_right<<1|orbisKeyboardConf->shift_key_left<<2|orbisKeyboardConf->shift_key_right<<3|orbisKeyboardConf->alt_key_left<<4|orbisKeyboardConf->alt_key_right<<5|orbisKeyboardConf->cmd_key_left<<6|orbisKeyboardConf->alt_key_right<<7; -} - -void orbisKeybordGetSpecialKeys(const OrbisKeyboardEvent *e) -{ - if(e->param.keycode.status&0x00020000) - { - orbisKeyboardConf->caps_key=1; - } - else - { - orbisKeyboardConf->caps_key=0; - } - if(e->param.keycode.status&0x00000100) - { - orbisKeyboardConf->control_key_left=1; - } - else - { - orbisKeyboardConf->control_key_left=0; - } - if(e->param.keycode.status&0x00001000) - { - orbisKeyboardConf->control_key_right=1; - } - else - { - orbisKeyboardConf->control_key_right=0; - } - if(e->param.keycode.status&0x00000200) - { - orbisKeyboardConf->shift_key_left=1; - } - else - { - orbisKeyboardConf->shift_key_left=0; - } - if(e->param.keycode.status&0x00002000) - { - orbisKeyboardConf->shift_key_right=1; - } - else - { - orbisKeyboardConf->shift_key_right=0; - } - if(e->param.keycode.status&0x00000400) - { - orbisKeyboardConf->alt_key_left=1; - } - else - { - orbisKeyboardConf->alt_key_left=0; - } - if(e->param.keycode.status&0x00004000) - { - orbisKeyboardConf->alt_key_right=1; - } - else - { - orbisKeyboardConf->alt_key_right=0; - } - if(e->param.keycode.status&0x00000800) - { - orbisKeyboardConf->cmd_key_left=1; - } - else - { - orbisKeyboardConf->cmd_key_left=0; - } - if(e->param.keycode.status&0x00008000) - { - orbisKeyboardConf->cmd_key_right=1; - } - else - { - orbisKeyboardConf->cmd_key_right=0; - } -} -static void orbisKeyboardEventUpdate(void *arg,const OrbisKeyboardEvent *e) -{ - int i; - int index; - switch(e->id) - { - case ORBIS_KEYBOARD_EVENT_OPEN: - debugNetPrintf(3,"liborbiskeyboard opened for userId:0x%08x\n",e->param.resourceIdArray.userId); - for(i=0;i<3;i++) - { - debugNetPrintf(3,"%d ",e->param.resourceIdArray.resourceId[i]); - } - debugNetPrintf(3,"\n"); - break; - case ORBIS_KEYBOARD_EVENT_KEYCODE_DOWN: - - orbisKeybordGetSpecialKeys(e); - - if(e->param.keycode.keycode<0x001e || e->param.keycode.keycode==0x0033) - { - index=orbisKeyboardConf->caps_key|orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - else - { - index=orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - if(orbisKeyboardConf->alt_key_left|orbisKeyboardConf->alt_key_right) - { - index=2; - } - debugNetPrintf(3,"liborbiskeyboard key down for keycode:0x%04X\n",e->param.keycode.keycode); - debugNetPrintf(3,"liborbiskeyboard key down for status:%8x\n",e->param.keycode.status); - //debugNetPrintf(3,"liborbiskeyboard key down for unknown1:%8x\n",e->param.keycode.unknown1); - //debugNetPrintf(3,"liborbiskeyboard key down for userId:%8x\n",e->param.keycode.userId); - //debugNetPrintf(3,"liborbiskeyboard key down for resourceId:%8x\n",e->param.keycode.resourceId); - //debugNetPrintf(3,"liborbiskeyboard key down for unknown2:%8x\n",e->param.keycode.unknown2); - - //debugNetPrintf(3,"liborbiskeyboard key down for timestamp:%lu\n",e->param.keycode.timestamp); - debugNetPrintf(3,"liborbiskeyboard key down for caps %d ctrll %d ctrlr %d shiftl %d shiftr %d altl %d altr %d cmdl %d cmdr %d\n",orbisKeyboardConf->caps_key,orbisKeyboardConf->control_key_left,orbisKeyboardConf->control_key_right,orbisKeyboardConf->shift_key_left,orbisKeyboardConf->shift_key_right,orbisKeyboardConf->alt_key_left,orbisKeyboardConf->alt_key_right,orbisKeyboardConf->cmd_key_left,orbisKeyboardConf->cmd_key_right); - // if((e->param.keycode.status&0x00000003)==0x00000003) - - if((e->param.keycode.status&0x00000003)) - { - debugNetPrintf(3,"liborbiskeyboard key down :%02X\n",orbisKeyboardNames[index][e->param.keycode.keycode]); - orbisKeyboardConf->key=orbisKeyboardNames[index][e->param.keycode.keycode]; - orbisKeyboardConf->key_status=1; - } - - - - break; - - case ORBIS_KEYBOARD_EVENT_KEYCODE_UP: - debugNetPrintf(3,"liborbiskeyboard key up for keycode:0x%04x\n",e->param.keycode.keycode); - orbisKeybordGetSpecialKeys(e); - if(e->param.keycode.keycode<0x001e || e->param.keycode.keycode==0x0033) - { - index=orbisKeyboardConf->caps_key|orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - else - { - index=orbisKeyboardConf->shift_key_left|orbisKeyboardConf->shift_key_right; - } - if(orbisKeyboardConf->alt_key_left|orbisKeyboardConf->alt_key_right) - { - index=2; - } - orbisKeyboardConf->key=orbisKeyboardNames[index][e->param.keycode.keycode]; - orbisKeyboardConf->key_status=0; - - break; - case ORBIS_KEYBOARD_EVENT_KEYCODE_REPEAT: - debugNetPrintf(3,"liborbiskeyboard key repeat for keycode:0x%04x\n",e->param.keycode.keycode); - break; - case ORBIS_KEYBOARD_EVENT_CONNECTION: - debugNetPrintf(3,"liborbiskeyboard connected for userId:0x%08x\n",e->param.resourceIdArray.userId); - for(i=0;i<3;i++) - { - debugNetPrintf(3,"%d ",e->param.resourceIdArray.resourceId[i]); - } - debugNetPrintf(3,"\n"); - break; - case ORBIS_KEYBOARD_EVENT_DISCONNECTION: - debugNetPrintf(3,"liborbiskeyboard disconnected for userId:0x%08x\n",e->param.resourceIdArray.userId); - for(i=0;i<3;i++) - { - debugNetPrintf(3,"%d ",e->param.resourceIdArray.resourceId[i]); - } - debugNetPrintf(3,"\n"); - break; - case ORBIS_KEYBOARD_EVENT_ABORT: - debugNetPrintf(3,"liborbiskeyboard aborted\n"); - - break; - default: - debugNetPrintf(3,"liborbiskeyboard unknown event\n"); - - break; - } -} -void orbisKeyboardUpdate() -{ - if(orbisKeyboardConf!=NULL) - { - //if(orbisKeyboardConf->orbiskeyboard_initialized==1 && orbisKeyboardConf->status==0) - //{ - sceImeUpdate(orbisKeyboardEventUpdate); - //} - } -} -void orbisKeyboardClose() -{ - int ret; - if(orbisKeyboardConf!=NULL) - { - if(orbisKeyboardConf->orbiskeyboard_initialized!=1) - { - return; - } - if(orbisKeyboardConf->status==0 ) - { - ret=sceImeKeyboardClose(orbisKeyboardConf->userId); - if(ret<0) - { - debugNetPrintf(3,"liborbiskeyboard sceImeKeyboardClose return error 0x%8x\n",ret); - - } - orbisKeyboardConf->status=-1; - - } - } -} -int orbisKeyboardOpen() -{ - debugNetPrintf(3,"liborbiskeyboard sceImeKeyboardOpen in\n"); - sleep(1); - OrbisKeyboardParam param; - int ret; - if(orbisKeyboardConf!=NULL) - { - debugNetPrintf(3,"liborbiskeyboard orbisKeyboardConf not null \n"); - - if(orbisKeyboardConf->orbiskeyboard_initialized!=1 ) - { - debugNetPrintf(3,"liborbiskeyboard orbisKeyboardConf %d \n",orbisKeyboardConf->orbiskeyboard_initialized); - - return -1; - } - - memset(¶m,0,sizeof(OrbisKeyboardParam)); - param.option=0; - param.handler=orbisKeyboardEventUpdate; - ret=sceImeKeyboardOpen(orbisKeyboardConf->userId,¶m); - //sleep(1); - if(ret<0) - { - debugNetPrintf(3,"liborbiskeyboard sceImeKeyboardOpen return error 0x%8x\n",ret); - return -1; - } - //sleep(1); - debugNetPrintf(3,"liborbiskeyboard sceImeKeyboardOpen return success %d\n",ret); - orbisKeyboardConf->status=0; //opened - return 0; - } - else - { - debugNetPrintf(3,"liborbiskeyboard orbisKeyboardOpen error config null\n"); - - return -1; - } -} -void orbisKeyboardFinish() -{ - - if(orbiskeyboard_external_conf!=1) - { - if(orbisKeyboardConf!=NULL) - { - orbisKeyboardClose(); - //sceSysmoduleUnloadModule(ORBIS_IME_MODULE); - orbisKeyboardConf->userId=0; - orbisKeyboardConf->orbiskeyboard_initialized=-1; - debugNetPrintf(3,"liborbisKeyboard finished\n"); - - } - } - -} -int orbisKeyboardSetConf(OrbisKeyboardConfig *conf) -{ - if(conf) - { - orbisKeyboardConf=conf; - orbiskeyboard_external_conf=1; - return orbisKeyboardConf->orbiskeyboard_initialized; - } - - return 0; -} -int orbisKeyboardInitWithConf(OrbisKeyboardConfig *conf) -{ - int ret=orbisKeyboardSetConf(conf); - if(ret) - { - debugNetPrintf(3,"liborbisKeyboard already initialized using configuration external\n"); - debugNetPrintf(3,"orbiskeyboard_initialized=%d\n",orbisKeyboardConf->orbiskeyboard_initialized); - debugNetPrintf(3,"ready to have a lot of fun...\n"); - return orbisKeyboardConf->orbiskeyboard_initialized; - } - else - { - return 0; - } -} -int orbisKeyboardInit() -{ - int ret; - if(orbisKeyboardCreateConf()==1) - { - return orbisKeyboardConf->orbiskeyboard_initialized; - } - if (orbisKeyboardConf->orbiskeyboard_initialized==1) - { - debugNetPrintf(3,"liborbiskeyboard is already initialized!\n"); - return orbisKeyboardConf->orbiskeyboard_initialized; - } - - //ret=sceSysmoduleLoadModule(ORBIS_IME_MODULE); - - //if(ret<0) - //{ - // debugNetPrintf(3,"liborbiskeyboard sceSysmoduleLoadModule return error 0x%8x\n",ret); - // return -1; - //} - //if we have orbisPad initialized then UserService module is already loaded, so first call orbisPadInit before orbisKeyboardInit - ret=sceUserServiceGetInitialUser(&orbisKeyboardConf->userId); - - if(ret<0) - { - debugNetPrintf(3,"liborbiskeyboard sceUserServiceGetInitialUser return error 0x%8x\n",ret); - orbisKeyboardConf->userId=0x10000000; - - //return -1; - - } - debugNetPrintf(3,"liborbiskeyboard userID r 0x%8x\n",orbisKeyboardConf->userId); - - orbisKeyboardInitKeyNames(); - - orbisKeyboardConf->orbiskeyboard_initialized=1; - - debugNetPrintf(3,"liborbiskeyboard is initialized!\n"); - - return orbisKeyboardConf->orbiskeyboard_initialized; - -} diff --git a/source/liborbisNfs/COPYING b/source/liborbisNfs/COPYING deleted file mode 100644 index e18e7a7..0000000 --- a/source/liborbisNfs/COPYING +++ /dev/null @@ -1,38 +0,0 @@ -Libnfs components fall under two separate licences - - -The library sources and include directories -=========================================== -The nfs client library itself, i.e. the lib and include directories, -is licenced under 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. - -The protocol definition, .x, files -================================== -These are based on old RFCs and studying how wireshark dissects various packets. -These are distributed under the simplified BSD licence. - -The files generated from the .x files -===================================== -The files that are generated from the .x sources, -i.e. */libnfs-raw-.[ch] -can be considered to be distributed under the simplified BSD licence. - -These files are only provided as a convenience, so that you do not need to -install and run rpcgen on the *.x files locally. -If you disagree with the simplified BSD licence I provide them under -then just delete them and then generate identical copies of these files yourself -using "make compile_rpc" in each protocol subdirectory. - -Then you can pick whatever licence you want on those files. - -The examples directory -================================ -The utility and example applications using this library, i.e. the -examples directory, are licenced under the GNU General Public License -as published by the Free Software Foundation; either version 3 of the -License, or (at your option) any later version. - - -To avoid any confusion, every source file contains a licence boilerplate. \ No newline at end of file diff --git a/source/liborbisNfs/LICENSE-BSD.txt b/source/liborbisNfs/LICENSE-BSD.txt deleted file mode 100644 index 941d925..0000000 --- a/source/liborbisNfs/LICENSE-BSD.txt +++ /dev/null @@ -1,23 +0,0 @@ -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. \ No newline at end of file diff --git a/source/liborbisNfs/LICENSE-GPL-3.txt b/source/liborbisNfs/LICENSE-GPL-3.txt deleted file mode 100644 index 81c9e88..0000000 --- a/source/liborbisNfs/LICENSE-GPL-3.txt +++ /dev/null @@ -1,674 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 - - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The GNU General Public License is a free, copyleft license for -software and other kinds of works. - - The licenses for most software and other practical works are designed -to take away your freedom to share and change the works. By contrast, -the GNU General Public License is intended to guarantee your freedom to -share and change all versions of a program--to make sure it remains free -software for all its users. We, the Free Software Foundation, use the -GNU General Public License for most of our software; it applies also to -any other work released this way by its authors. You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -them if you wish), that you receive source code or can get it if you -want it, that you can change the software or use pieces of it in new -free programs, and that you know you can do these things. - - To protect your rights, we need to prevent others from denying you -these rights or asking you to surrender the rights. Therefore, you have -certain responsibilities if you distribute copies of the software, or if -you modify it: responsibilities to respect the freedom of others. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must pass on to the recipients the same -freedoms that you received. You must make sure that they, too, receive -or can get the source code. And you must show them these terms so they -know their rights. - - Developers that use the GNU GPL protect your rights with two steps: -(1) assert copyright on the software, and (2) offer you this License -giving you legal permission to copy, distribute and/or modify it. - - For the developers' and authors' protection, the GPL clearly explains -that there is no warranty for this free software. For both users' and -authors' sake, the GPL requires that modified versions be marked as -changed, so that their problems will not be attributed erroneously to -authors of previous versions. - - Some devices are designed to deny users access to install or run -modified versions of the software inside them, although the manufacturer -can do so. This is fundamentally incompatible with the aim of -protecting users' freedom to change the software. The systematic -pattern of such abuse occurs in the area of products for individuals to -use, which is precisely where it is most unacceptable. Therefore, we -have designed this version of the GPL to prohibit the practice for those -products. If such problems arise substantially in other domains, we -stand ready to extend this provision to those domains in future versions -of the GPL, as needed to protect the freedom of users. - - Finally, every program is threatened constantly by software patents. -States should not allow patents to restrict development and use of -software on general-purpose computers, but in those that do, we wish to -avoid the special danger that patents applied to a free program could -make it effectively proprietary. To prevent this, the GPL assures that -patents cannot be used to render the program non-free. - - The precise terms and conditions for copying, distribution and -modification follow. - - TERMS AND CONDITIONS - - 0. Definitions. - - "This License" refers to version 3 of the GNU General Public License. - - "Copyright" also means copyright-like laws that apply to other kinds of -works, such as semiconductor masks. - - "The Program" refers to any copyrightable work licensed under this -License. Each licensee is addressed as "you". "Licensees" and -"recipients" may be individuals or organizations. - - To "modify" a work means to copy from or adapt all or part of the work -in a fashion requiring copyright permission, other than the making of an -exact copy. The resulting work is called a "modified version" of the -earlier work or a work "based on" the earlier work. - - A "covered work" means either the unmodified Program or a work based -on the Program. - - To "propagate" a work means to do anything with it that, without -permission, would make you directly or secondarily liable for -infringement under applicable copyright law, except executing it on a -computer or modifying a private copy. Propagation includes copying, -distribution (with or without modification), making available to the -public, and in some countries other activities as well. - - To "convey" a work means any kind of propagation that enables other -parties to make or receive copies. Mere interaction with a user through -a computer network, with no transfer of a copy, is not conveying. - - An interactive user interface displays "Appropriate Legal Notices" -to the extent that it includes a convenient and prominently visible -feature that (1) displays an appropriate copyright notice, and (2) -tells the user that there is no warranty for the work (except to the -extent that warranties are provided), that licensees may convey the -work under this License, and how to view a copy of this License. If -the interface presents a list of user commands or options, such as a -menu, a prominent item in the list meets this criterion. - - 1. Source Code. - - The "source code" for a work means the preferred form of the work -for making modifications to it. "Object code" means any non-source -form of a work. - - A "Standard Interface" means an interface that either is an official -standard defined by a recognized standards body, or, in the case of -interfaces specified for a particular programming language, one that -is widely used among developers working in that language. - - The "System Libraries" of an executable work include anything, other -than the work as a whole, that (a) is included in the normal form of -packaging a Major Component, but which is not part of that Major -Component, and (b) serves only to enable use of the work with that -Major Component, or to implement a Standard Interface for which an -implementation is available to the public in source code form. A -"Major Component", in this context, means a major essential component -(kernel, window system, and so on) of the specific operating system -(if any) on which the executable work runs, or a compiler used to -produce the work, or an object code interpreter used to run it. - - The "Corresponding Source" for a work in object code form means all -the source code needed to generate, install, and (for an executable -work) run the object code and to modify the work, including scripts to -control those activities. However, it does not include the work's -System Libraries, or general-purpose tools or generally available free -programs which are used unmodified in performing those activities but -which are not part of the work. For example, Corresponding Source -includes interface definition files associated with source files for -the work, and the source code for shared libraries and dynamically -linked subprograms that the work is specifically designed to require, -such as by intimate data communication or control flow between those -subprograms and other parts of the work. - - The Corresponding Source need not include anything that users -can regenerate automatically from other parts of the Corresponding -Source. - - The Corresponding Source for a work in source code form is that -same work. - - 2. Basic Permissions. - - All rights granted under this License are granted for the term of -copyright on the Program, and are irrevocable provided the stated -conditions are met. This License explicitly affirms your unlimited -permission to run the unmodified Program. The output from running a -covered work is covered by this License only if the output, given its -content, constitutes a covered work. This License acknowledges your -rights of fair use or other equivalent, as provided by copyright law. - - You may make, run and propagate covered works that you do not -convey, without conditions so long as your license otherwise remains -in force. You may convey covered works to others for the sole purpose -of having them make modifications exclusively for you, or provide you -with facilities for running those works, provided that you comply with -the terms of this License in conveying all material for which you do -not control copyright. Those thus making or running the covered works -for you must do so exclusively on your behalf, under your direction -and control, on terms that prohibit them from making any copies of -your copyrighted material outside their relationship with you. - - Conveying under any other circumstances is permitted solely under -the conditions stated below. Sublicensing is not allowed; section 10 -makes it unnecessary. - - 3. Protecting Users' Legal Rights From Anti-Circumvention Law. - - No covered work shall be deemed part of an effective technological -measure under any applicable law fulfilling obligations under article -11 of the WIPO copyright treaty adopted on 20 December 1996, or -similar laws prohibiting or restricting circumvention of such -measures. - - When you convey a covered work, you waive any legal power to forbid -circumvention of technological measures to the extent such circumvention -is effected by exercising rights under this License with respect to -the covered work, and you disclaim any intention to limit operation or -modification of the work as a means of enforcing, against the work's -users, your or third parties' legal rights to forbid circumvention of -technological measures. - - 4. Conveying Verbatim Copies. - - You may convey verbatim copies of the Program's source code as you -receive it, in any medium, provided that you conspicuously and -appropriately publish on each copy an appropriate copyright notice; -keep intact all notices stating that this License and any -non-permissive terms added in accord with section 7 apply to the code; -keep intact all notices of the absence of any warranty; and give all -recipients a copy of this License along with the Program. - - You may charge any price or no price for each copy that you convey, -and you may offer support or warranty protection for a fee. - - 5. Conveying Modified Source Versions. - - You may convey a work based on the Program, or the modifications to -produce it from the Program, in the form of source code under the -terms of section 4, provided that you also meet all of these conditions: - - a) The work must carry prominent notices stating that you modified - it, and giving a relevant date. - - b) The work must carry prominent notices stating that it is - released under this License and any conditions added under section - 7. This requirement modifies the requirement in section 4 to - "keep intact all notices". - - c) You must license the entire work, as a whole, under this - License to anyone who comes into possession of a copy. This - License will therefore apply, along with any applicable section 7 - additional terms, to the whole of the work, and all its parts, - regardless of how they are packaged. This License gives no - permission to license the work in any other way, but it does not - invalidate such permission if you have separately received it. - - d) If the work has interactive user interfaces, each must display - Appropriate Legal Notices; however, if the Program has interactive - interfaces that do not display Appropriate Legal Notices, your - work need not make them do so. - - A compilation of a covered work with other separate and independent -works, which are not by their nature extensions of the covered work, -and which are not combined with it such as to form a larger program, -in or on a volume of a storage or distribution medium, is called an -"aggregate" if the compilation and its resulting copyright are not -used to limit the access or legal rights of the compilation's users -beyond what the individual works permit. Inclusion of a covered work -in an aggregate does not cause this License to apply to the other -parts of the aggregate. - - 6. Conveying Non-Source Forms. - - You may convey a covered work in object code form under the terms -of sections 4 and 5, provided that you also convey the -machine-readable Corresponding Source under the terms of this License, -in one of these ways: - - a) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by the - Corresponding Source fixed on a durable physical medium - customarily used for software interchange. - - b) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by a - written offer, valid for at least three years and valid for as - long as you offer spare parts or customer support for that product - model, to give anyone who possesses the object code either (1) a - copy of the Corresponding Source for all the software in the - product that is covered by this License, on a durable physical - medium customarily used for software interchange, for a price no - more than your reasonable cost of physically performing this - conveying of source, or (2) access to copy the - Corresponding Source from a network server at no charge. - - c) Convey individual copies of the object code with a copy of the - written offer to provide the Corresponding Source. This - alternative is allowed only occasionally and noncommercially, and - only if you received the object code with such an offer, in accord - with subsection 6b. - - d) Convey the object code by offering access from a designated - place (gratis or for a charge), and offer equivalent access to the - Corresponding Source in the same way through the same place at no - further charge. You need not require recipients to copy the - Corresponding Source along with the object code. If the place to - copy the object code is a network server, the Corresponding Source - may be on a different server (operated by you or a third party) - that supports equivalent copying facilities, provided you maintain - clear directions next to the object code saying where to find the - Corresponding Source. Regardless of what server hosts the - Corresponding Source, you remain obligated to ensure that it is - available for as long as needed to satisfy these requirements. - - e) Convey the object code using peer-to-peer transmission, provided - you inform other peers where the object code and Corresponding - Source of the work are being offered to the general public at no - charge under subsection 6d. - - A separable portion of the object code, whose source code is excluded -from the Corresponding Source as a System Library, need not be -included in conveying the object code work. - - A "User Product" is either (1) a "consumer product", which means any -tangible personal property which is normally used for personal, family, -or household purposes, or (2) anything designed or sold for incorporation -into a dwelling. In determining whether a product is a consumer product, -doubtful cases shall be resolved in favor of coverage. For a particular -product received by a particular user, "normally used" refers to a -typical or common use of that class of product, regardless of the status -of the particular user or of the way in which the particular user -actually uses, or expects or is expected to use, the product. A product -is a consumer product regardless of whether the product has substantial -commercial, industrial or non-consumer uses, unless such uses represent -the only significant mode of use of the product. - - "Installation Information" for a User Product means any methods, -procedures, authorization keys, or other information required to install -and execute modified versions of a covered work in that User Product from -a modified version of its Corresponding Source. The information must -suffice to ensure that the continued functioning of the modified object -code is in no case prevented or interfered with solely because -modification has been made. - - If you convey an object code work under this section in, or with, or -specifically for use in, a User Product, and the conveying occurs as -part of a transaction in which the right of possession and use of the -User Product is transferred to the recipient in perpetuity or for a -fixed term (regardless of how the transaction is characterized), the -Corresponding Source conveyed under this section must be accompanied -by the Installation Information. But this requirement does not apply -if neither you nor any third party retains the ability to install -modified object code on the User Product (for example, the work has -been installed in ROM). - - The requirement to provide Installation Information does not include a -requirement to continue to provide support service, warranty, or updates -for a work that has been modified or installed by the recipient, or for -the User Product in which it has been modified or installed. Access to a -network may be denied when the modification itself materially and -adversely affects the operation of the network or violates the rules and -protocols for communication across the network. - - Corresponding Source conveyed, and Installation Information provided, -in accord with this section must be in a format that is publicly -documented (and with an implementation available to the public in -source code form), and must require no special password or key for -unpacking, reading or copying. - - 7. Additional Terms. - - "Additional permissions" are terms that supplement the terms of this -License by making exceptions from one or more of its conditions. -Additional permissions that are applicable to the entire Program shall -be treated as though they were included in this License, to the extent -that they are valid under applicable law. If additional permissions -apply only to part of the Program, that part may be used separately -under those permissions, but the entire Program remains governed by -this License without regard to the additional permissions. - - When you convey a copy of a covered work, you may at your option -remove any additional permissions from that copy, or from any part of -it. (Additional permissions may be written to require their own -removal in certain cases when you modify the work.) You may place -additional permissions on material, added by you to a covered work, -for which you have or can give appropriate copyright permission. - - Notwithstanding any other provision of this License, for material you -add to a covered work, you may (if authorized by the copyright holders of -that material) supplement the terms of this License with terms: - - a) Disclaiming warranty or limiting liability differently from the - terms of sections 15 and 16 of this License; or - - b) Requiring preservation of specified reasonable legal notices or - author attributions in that material or in the Appropriate Legal - Notices displayed by works containing it; or - - c) Prohibiting misrepresentation of the origin of that material, or - requiring that modified versions of such material be marked in - reasonable ways as different from the original version; or - - d) Limiting the use for publicity purposes of names of licensors or - authors of the material; or - - e) Declining to grant rights under trademark law for use of some - trade names, trademarks, or service marks; or - - f) Requiring indemnification of licensors and authors of that - material by anyone who conveys the material (or modified versions of - it) with contractual assumptions of liability to the recipient, for - any liability that these contractual assumptions directly impose on - those licensors and authors. - - All other non-permissive additional terms are considered "further -restrictions" within the meaning of section 10. If the Program as you -received it, or any part of it, contains a notice stating that it is -governed by this License along with a term that is a further -restriction, you may remove that term. If a license document contains -a further restriction but permits relicensing or conveying under this -License, you may add to a covered work material governed by the terms -of that license document, provided that the further restriction does -not survive such relicensing or conveying. - - If you add terms to a covered work in accord with this section, you -must place, in the relevant source files, a statement of the -additional terms that apply to those files, or a notice indicating -where to find the applicable terms. - - Additional terms, permissive or non-permissive, may be stated in the -form of a separately written license, or stated as exceptions; -the above requirements apply either way. - - 8. Termination. - - You may not propagate or modify a covered work except as expressly -provided under this License. Any attempt otherwise to propagate or -modify it is void, and will automatically terminate your rights under -this License (including any patent licenses granted under the third -paragraph of section 11). - - However, if you cease all violation of this License, then your -license from a particular copyright holder is reinstated (a) -provisionally, unless and until the copyright holder explicitly and -finally terminates your license, and (b) permanently, if the copyright -holder fails to notify you of the violation by some reasonable means -prior to 60 days after the cessation. - - Moreover, your license from a particular copyright holder is -reinstated permanently if the copyright holder notifies you of the -violation by some reasonable means, this is the first time you have -received notice of violation of this License (for any work) from that -copyright holder, and you cure the violation prior to 30 days after -your receipt of the notice. - - Termination of your rights under this section does not terminate the -licenses of parties who have received copies or rights from you under -this License. If your rights have been terminated and not permanently -reinstated, you do not qualify to receive new licenses for the same -material under section 10. - - 9. Acceptance Not Required for Having Copies. - - You are not required to accept this License in order to receive or -run a copy of the Program. Ancillary propagation of a covered work -occurring solely as a consequence of using peer-to-peer transmission -to receive a copy likewise does not require acceptance. However, -nothing other than this License grants you permission to propagate or -modify any covered work. These actions infringe copyright if you do -not accept this License. Therefore, by modifying or propagating a -covered work, you indicate your acceptance of this License to do so. - - 10. Automatic Licensing of Downstream Recipients. - - Each time you convey a covered work, the recipient automatically -receives a license from the original licensors, to run, modify and -propagate that work, subject to this License. You are not responsible -for enforcing compliance by third parties with this License. - - An "entity transaction" is a transaction transferring control of an -organization, or substantially all assets of one, or subdividing an -organization, or merging organizations. If propagation of a covered -work results from an entity transaction, each party to that -transaction who receives a copy of the work also receives whatever -licenses to the work the party's predecessor in interest had or could -give under the previous paragraph, plus a right to possession of the -Corresponding Source of the work from the predecessor in interest, if -the predecessor has it or can get it with reasonable efforts. - - You may not impose any further restrictions on the exercise of the -rights granted or affirmed under this License. For example, you may -not impose a license fee, royalty, or other charge for exercise of -rights granted under this License, and you may not initiate litigation -(including a cross-claim or counterclaim in a lawsuit) alleging that -any patent claim is infringed by making, using, selling, offering for -sale, or importing the Program or any portion of it. - - 11. Patents. - - A "contributor" is a copyright holder who authorizes use under this -License of the Program or a work on which the Program is based. The -work thus licensed is called the contributor's "contributor version". - - A contributor's "essential patent claims" are all patent claims -owned or controlled by the contributor, whether already acquired or -hereafter acquired, that would be infringed by some manner, permitted -by this License, of making, using, or selling its contributor version, -but do not include claims that would be infringed only as a -consequence of further modification of the contributor version. For -purposes of this definition, "control" includes the right to grant -patent sublicenses in a manner consistent with the requirements of -this License. - - Each contributor grants you a non-exclusive, worldwide, royalty-free -patent license under the contributor's essential patent claims, to -make, use, sell, offer for sale, import and otherwise run, modify and -propagate the contents of its contributor version. - - In the following three paragraphs, a "patent license" is any express -agreement or commitment, however denominated, not to enforce a patent -(such as an express permission to practice a patent or covenant not to -sue for patent infringement). To "grant" such a patent license to a -party means to make such an agreement or commitment not to enforce a -patent against the party. - - If you convey a covered work, knowingly relying on a patent license, -and the Corresponding Source of the work is not available for anyone -to copy, free of charge and under the terms of this License, through a -publicly available network server or other readily accessible means, -then you must either (1) cause the Corresponding Source to be so -available, or (2) arrange to deprive yourself of the benefit of the -patent license for this particular work, or (3) arrange, in a manner -consistent with the requirements of this License, to extend the patent -license to downstream recipients. "Knowingly relying" means you have -actual knowledge that, but for the patent license, your conveying the -covered work in a country, or your recipient's use of the covered work -in a country, would infringe one or more identifiable patents in that -country that you have reason to believe are valid. - - If, pursuant to or in connection with a single transaction or -arrangement, you convey, or propagate by procuring conveyance of, a -covered work, and grant a patent license to some of the parties -receiving the covered work authorizing them to use, propagate, modify -or convey a specific copy of the covered work, then the patent license -you grant is automatically extended to all recipients of the covered -work and works based on it. - - A patent license is "discriminatory" if it does not include within -the scope of its coverage, prohibits the exercise of, or is -conditioned on the non-exercise of one or more of the rights that are -specifically granted under this License. You may not convey a covered -work if you are a party to an arrangement with a third party that is -in the business of distributing software, under which you make payment -to the third party based on the extent of your activity of conveying -the work, and under which the third party grants, to any of the -parties who would receive the covered work from you, a discriminatory -patent license (a) in connection with copies of the covered work -conveyed by you (or copies made from those copies), or (b) primarily -for and in connection with specific products or compilations that -contain the covered work, unless you entered into that arrangement, -or that patent license was granted, prior to 28 March 2007. - - Nothing in this License shall be construed as excluding or limiting -any implied license or other defenses to infringement that may -otherwise be available to you under applicable patent law. - - 12. No Surrender of Others' Freedom. - - If conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot convey a -covered work so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you may -not convey it at all. For example, if you agree to terms that obligate you -to collect a royalty for further conveying from those to whom you convey -the Program, the only way you could satisfy both those terms and this -License would be to refrain entirely from conveying the Program. - - 13. Use with the GNU Affero General Public License. - - Notwithstanding any other provision of this License, you have -permission to link or combine any covered work with a work licensed -under version 3 of the GNU Affero General Public License into a single -combined work, and to convey the resulting work. The terms of this -License will continue to apply to the part which is the covered work, -but the special requirements of the GNU Affero General Public License, -section 13, concerning interaction through a network will apply to the -combination as such. - - 14. Revised Versions of this License. - - The Free Software Foundation may publish revised and/or new versions of -the GNU General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - - Each version is given a distinguishing version number. If the -Program specifies that a certain numbered version of the GNU General -Public License "or any later version" applies to it, you have the -option of following the terms and conditions either of that numbered -version or of any later version published by the Free Software -Foundation. If the Program does not specify a version number of the -GNU General Public License, you may choose any version ever published -by the Free Software Foundation. - - If the Program specifies that a proxy can decide which future -versions of the GNU General Public License can be used, that proxy's -public statement of acceptance of a version permanently authorizes you -to choose that version for the Program. - - Later license versions may give you additional or different -permissions. However, no additional obligations are imposed on any -author or copyright holder as a result of your choosing to follow a -later version. - - 15. Disclaimer of Warranty. - - THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY -APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT -HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY -OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, -THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM -IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF -ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. Limitation of Liability. - - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE -USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF -DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD -PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), -EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF -SUCH DAMAGES. - - 17. Interpretation of Sections 15 and 16. - - If the disclaimer of warranty and limitation of liability provided -above cannot be given local legal effect according to their terms, -reviewing courts shall apply local law that most closely approximates -an absolute waiver of all civil liability in connection with the -Program, unless a warranty or assumption of liability accompanies a -copy of the Program in return for a fee. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -state the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - 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 3 of the License, 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, see . - -Also add information on how to contact you by electronic and paper mail. - - If the program does terminal interaction, make it output a short -notice like this when it starts in an interactive mode: - - Copyright (C) - This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, your program's commands -might be different; for a GUI interface, you would use an "about box". - - You should also get your employer (if you work as a programmer) or school, -if any, to sign a "copyright disclaimer" for the program, if necessary. -For more information on this, and how to apply and follow the GNU GPL, see -. - - The GNU General Public License does not permit incorporating your program -into proprietary programs. If your program is a subroutine library, you -may consider it more useful to permit linking proprietary applications with -the library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. But first, please read -. \ No newline at end of file diff --git a/source/liborbisNfs/LICENSE-LGPL-2.1.txt b/source/liborbisNfs/LICENSE-LGPL-2.1.txt deleted file mode 100644 index f166cc5..0000000 --- a/source/liborbisNfs/LICENSE-LGPL-2.1.txt +++ /dev/null @@ -1,502 +0,0 @@ - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - -[This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -Licenses are intended to guarantee your freedom to share and change -free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some -specially designated software packages--typically libraries--of the -Free Software Foundation and other authors who decide to use it. You -can use it too, but we suggest you first think carefully about whether -this license or the ordinary General Public License is the better -strategy to use in any particular case, based on the explanations below. - - When we speak of free software, we are referring to freedom of use, -not price. Our General Public Licenses are designed to make sure that -you have the freedom to distribute copies of free software (and charge -for this service if you wish); that you receive source code or can get -it if you want it; that you can change the software and use pieces of -it in new free programs; and that you are informed that you can do -these things. - - To protect your rights, we need to make restrictions that forbid -distributors to deny you these rights or to ask you to surrender these -rights. These restrictions translate to certain responsibilities for -you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis -or for a fee, you must give the recipients all the rights that we gave -you. You must make sure that they, too, receive or can get the source -code. If you link other code with the library, you must provide -complete object files to the recipients, so that they can relink them -with the library after making changes to the library and recompiling -it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the -library, and (2) we offer you this license, which gives you legal -permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that -there is no warranty for the free library. Also, if the library is -modified by someone else and passed on, the recipients should know -that what they have is not the original version, so that the original -author's reputation will not be affected by problems that might be -introduced by others. - - Finally, software patents pose a constant threat to the existence of -any free program. We wish to make sure that a company cannot -effectively restrict the users of a free program by obtaining a -restrictive license from a patent holder. Therefore, we insist that -any patent license obtained for a version of the library must be -consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the -ordinary GNU General Public License. This license, the GNU Lesser -General Public License, applies to certain designated libraries, and -is quite different from the ordinary General Public License. We use -this license for certain libraries in order to permit linking those -libraries into non-free programs. - - When a program is linked with a library, whether statically or using -a shared library, the combination of the two is legally speaking a -combined work, a derivative of the original library. The ordinary -General Public License therefore permits such linking only if the -entire combination fits its criteria of freedom. The Lesser General -Public License permits more lax criteria for linking other code with -the library. - - We call this license the "Lesser" General Public License because it -does Less to protect the user's freedom than the ordinary General -Public License. It also provides other free software developers Less -of an advantage over competing non-free programs. These disadvantages -are the reason we use the ordinary General Public License for many -libraries. However, the Lesser license provides advantages in certain -special circumstances. - - For example, on rare occasions, there may be a special need to -encourage the widest possible use of a certain library, so that it becomes -a de-facto standard. To achieve this, non-free programs must be -allowed to use the library. A more frequent case is that a free -library does the same job as widely used non-free libraries. In this -case, there is little to gain by limiting the free library to free -software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free -programs enables a greater number of people to use a large body of -free software. For example, permission to use the GNU C Library in -non-free programs enables many more people to use the whole GNU -operating system, as well as its variant, the GNU/Linux operating -system. - - Although the Lesser General Public License is Less protective of the -users' freedom, it does ensure that the user of a program that is -linked with the Library has the freedom and the wherewithal to run -that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and -modification follow. Pay close attention to the difference between a -"work based on the library" and a "work that uses the library". The -former contains code derived from the library, whereas the latter must -be combined with the library in order to run. - - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other -program which contains a notice placed by the copyright holder or -other authorized party saying it may be distributed under the terms of -this Lesser General Public License (also called "this License"). -Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data -prepared so as to be conveniently linked with application programs -(which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work -which has been distributed under these terms. A "work based on the -Library" means either the Library or any derivative work under -copyright law: that is to say, a work containing the Library or a -portion of it, either verbatim or with modifications and/or translated -straightforwardly into another language. (Hereinafter, translation is -included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for -making modifications to it. For a library, complete source code means -all the source code for all modules it contains, plus any associated -interface definition files, plus the scripts used to control compilation -and installation of the library. - - Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running a program using the Library is not restricted, and output from -such a program is covered only if its contents constitute a work based -on the Library (independent of the use of the Library in a tool for -writing it). Whether that is true depends on what the Library does -and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's -complete source code as you receive it, in any medium, provided that -you conspicuously and appropriately publish on each copy an -appropriate copyright notice and disclaimer of warranty; keep intact -all the notices that refer to this License and to the absence of any -warranty; and distribute a copy of this License along with the -Library. - - You may charge a fee for the physical act of transferring a copy, -and you may at your option offer warranty protection in exchange for a -fee. - - 2. You may modify your copy or copies of the Library or any portion -of it, thus forming a work based on the Library, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Library, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Library, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Library. - -In addition, mere aggregation of another work not based on the Library -with the Library (or with a work based on the Library) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public -License instead of this License to a given copy of the Library. To do -this, you must alter all the notices that refer to this License, so -that they refer to the ordinary GNU General Public License, version 2, -instead of to this License. (If a newer version than version 2 of the -ordinary GNU General Public License has appeared, then you can specify -that version instead if you wish.) Do not make any other change in -these notices. - - Once this change is made in a given copy, it is irreversible for -that copy, so the ordinary GNU General Public License applies to all -subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of -the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or -derivative of it, under Section 2) in object code or executable form -under the terms of Sections 1 and 2 above provided that you accompany -it with the complete corresponding machine-readable source code, which -must be distributed under the terms of Sections 1 and 2 above on a -medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy -from a designated place, then offering equivalent access to copy the -source code from the same place satisfies the requirement to -distribute the source code, even though third parties are not -compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the -Library, but is designed to work with the Library by being compiled or -linked with it, is called a "work that uses the Library". Such a -work, in isolation, is not a derivative work of the Library, and -therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library -creates an executable that is a derivative of the Library (because it -contains portions of the Library), rather than a "work that uses the -library". The executable is therefore covered by this License. -Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file -that is part of the Library, the object code for the work may be a -derivative work of the Library even though the source code is not. -Whether this is true is especially significant if the work can be -linked without the Library, or if the work is itself a library. The -threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data -structure layouts and accessors, and small macros and small inline -functions (ten lines or less in length), then the use of the object -file is unrestricted, regardless of whether it is legally a derivative -work. (Executables containing this object code plus portions of the -Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may -distribute the object code for the work under the terms of Section 6. -Any executables containing that work also fall under Section 6, -whether or not they are linked directly with the Library itself. - - 6. As an exception to the Sections above, you may also combine or -link a "work that uses the Library" with the Library to produce a -work containing portions of the Library, and distribute that work -under terms of your choice, provided that the terms permit -modification of the work for the customer's own use and reverse -engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the -Library is used in it and that the Library and its use are covered by -this License. You must supply a copy of this License. If the work -during execution displays copyright notices, you must include the -copyright notice for the Library among them, as well as a reference -directing the user to the copy of this License. Also, you must do one -of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at - least three years, to give the same user the materials - specified in Subsection 6a, above, for a charge no more - than the cost of performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the -Library" must include any data and utility programs needed for -reproducing the executable from it. However, as a special exception, -the materials to be distributed need not include anything that is -normally distributed (in either source or binary form) with the major -components (compiler, kernel, and so on) of the operating system on -which the executable runs, unless that component itself accompanies -the executable. - - It may happen that this requirement contradicts the license -restrictions of other proprietary libraries that do not normally -accompany the operating system. Such a contradiction means you cannot -use both them and the Library together in an executable that you -distribute. - - 7. You may place library facilities that are a work based on the -Library side-by-side in a single library together with other library -facilities not covered by this License, and distribute such a combined -library, provided that the separate distribution of the work based on -the Library and of the other library facilities is otherwise -permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute -the Library except as expressly provided under this License. Any -attempt otherwise to copy, modify, sublicense, link with, or -distribute the Library is void, and will automatically terminate your -rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses -terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Library or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Library (or any work based on the -Library), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the -Library), the recipient automatically receives a license from the -original licensor to copy, distribute, link with or modify the Library -subject to these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties with -this License. - - 11. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Library at all. For example, if a patent -license would not permit royalty-free redistribution of the Library by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Library. - -If any portion of this section is held invalid or unenforceable under any -particular circumstance, the balance of the section is intended to apply, -and the section as a whole is intended to apply in other circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Library under this License may add -an explicit geographical distribution limitation excluding those countries, -so that distribution is permitted only in or among countries not thus -excluded. In such case, this License incorporates the limitation as if -written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new -versions of the Lesser General Public License from time to time. -Such new versions will be similar in spirit to the present version, -but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Library -specifies a version number of this License which applies to it and -"any later version", you have the option of following the terms and -conditions either of that version or of any later version published by -the Free Software Foundation. If the Library does not specify a -license version number, you may choose any version ever published by -the Free Software Foundation. - - 14. If you wish to incorporate parts of the Library into other free -programs whose distribution conditions are incompatible with these, -write to the author to ask for permission. For software which is -copyrighted by the Free Software Foundation, write to the Free -Software Foundation; we sometimes make exceptions for this. Our -decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing -and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO -WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR -OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY -KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE -LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY -AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU -FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest -possible use to the public, we recommend making it free software that -everyone can redistribute and change. You can do so by permitting -redistribution under these terms (or, alternatively, under the terms of the -ordinary General Public License). - - To apply these terms, attach the following notices to the library. It is -safest to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least the -"copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - -Also add information on how to contact you by electronic and paper mail. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the library, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James Random Hacker. - - , 1 April 1990 - Ty Coon, President of Vice - -That's all there is to it! \ No newline at end of file diff --git a/source/liborbisNfs/init.c b/source/liborbisNfs/init.c deleted file mode 100644 index ed356ad..0000000 --- a/source/liborbisNfs/init.c +++ /dev/null @@ -1,428 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifndef _GNU_SOURCE -#define _GNU_SOURCE -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#ifdef HAVE_STRINGS_H -#include -#endif - -#include -#include -#include -#include -#include -#include -#include "slist.h" -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" - -uint64_t rpc_current_time(void) -{ -#ifdef HAVE_CLOCK_GETTIME - struct timespec tp; - - clock_gettime(CLOCK_MONOTONIC_COARSE, &tp); - return (uint64_t)tp.tv_sec * 1000 + tp.tv_nsec / 1000000; -#else - return (uint64_t)time(NULL) * 1000; -#endif -} - -struct rpc_context *rpc_init_context(void) -{ - struct rpc_context *rpc; - static uint32_t salt = 0; - unsigned int i; - - rpc = malloc(sizeof(struct rpc_context)); - if (rpc == NULL) { - return NULL; - } - memset(rpc, 0, sizeof(struct rpc_context)); - - rpc->magic = RPC_CONTEXT_MAGIC; - - rpc->auth = authunix_create_default(); - if (rpc->auth == NULL) { - free(rpc); - return NULL; - } - // Add PID to rpc->xid for easier debugging, making sure to cast - // pid to 32-bit type to avoid invalid left-shifts. - rpc->xid = salt + (uint32_t)rpc_current_time() + ((uint32_t)getpid() << 16); - salt += 0x01000000; - rpc->fd = -1; - rpc->tcp_syncnt = RPC_PARAM_UNDEFINED; - rpc->pagecache_ttl = NFS_PAGECACHE_DEFAULT_TTL; -#if defined(WIN32) || defined(ANDROID) - rpc->uid = 65534; - rpc->gid = 65534; -#else - rpc->uid = getuid(); - rpc->gid = getgid(); -#endif - rpc_reset_queue(&rpc->outqueue); - for (i = 0; i < HASHES; i++) - rpc_reset_queue(&rpc->waitpdu[i]); - - /* Default is no timeout */ - rpc->timeout = -1; - - return rpc; -} - -struct rpc_context *rpc_init_server_context(int s) -{ - struct rpc_context *rpc; - - rpc = malloc(sizeof(struct rpc_context)); - if (rpc == NULL) { - return NULL; - } - memset(rpc, 0, sizeof(struct rpc_context)); - - rpc->magic = RPC_CONTEXT_MAGIC; - - rpc->is_server_context = 1; - rpc->fd = s; - rpc->is_connected = 1; - rpc->is_udp = rpc_is_udp_socket(rpc); - rpc_reset_queue(&rpc->outqueue); - - return rpc; -} - -static uint32_t round_to_power_of_two(uint32_t x) { - uint32_t power = 1; - while (power < x) { - power <<= 1; - } - return power; -} - -void rpc_set_pagecache(struct rpc_context *rpc, uint32_t v) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - v = MAX(rpc->pagecache, round_to_power_of_two(v)); - RPC_LOG(rpc, 2, "pagecache set to %d pages of size %d", v, NFS_BLKSIZE); - rpc->pagecache = v; -} - -void rpc_set_pagecache_ttl(struct rpc_context *rpc, uint32_t v) { - if (v) { - RPC_LOG(rpc, 2, "set pagecache ttl to %d seconds\n", v); - } else { - RPC_LOG(rpc, 2, "set pagecache ttl to infinite"); - } - rpc->pagecache_ttl = v; -} - -void rpc_set_readahead(struct rpc_context *rpc, uint32_t v) -{ - uint32_t min_pagecache; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - if (v) { - v = MAX(NFS_BLKSIZE, round_to_power_of_two(v)); - } - RPC_LOG(rpc, 2, "readahead set to %d byte", v); - rpc->readahead = v; - min_pagecache = (2 * v) / NFS_BLKSIZE; - if (rpc->pagecache < min_pagecache) { - /* current pagecache implementation needs a pagecache bigger - * than the readahead size to avoid collisions */ - rpc_set_pagecache(rpc, min_pagecache); - } -} - -#ifdef HAVE_SO_BINDTODEVICE -void rpc_set_interface(struct rpc_context *rpc, const char *ifname) -{ - /* - * This only copies the interface information into the RPC - * structure. It doesn't stop whatever interface is being used. The - * connection needs to be restarted for that happen. In other words, - * set this before you connect. - */ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (ifname) { - /* - * Allow at one-less character just-in-case IFNAMSIZ for - * the defined platform does not include the NUL-terminator. - */ - strncpy(rpc->ifname, ifname, sizeof(rpc->ifname) - 1); - } -} -#endif - -void rpc_set_debug(struct rpc_context *rpc, int level) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - rpc->debug = level; -} - -struct rpc_context *rpc_init_udp_context(void) -{ - struct rpc_context *rpc; - - rpc = rpc_init_context(); - if (rpc != NULL) { - rpc->is_udp = 1; - } - - return rpc; -} - -void rpc_set_auth(struct rpc_context *rpc, struct AUTH *auth) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->auth != NULL) { - auth_destroy(rpc->auth); - } - rpc->auth = auth; -} - -static void rpc_set_uid_gid(struct rpc_context *rpc, int uid, int gid) { - if (uid != rpc->uid || gid != rpc->gid) { - struct AUTH *auth = libnfs_authunix_create("libnfs", uid, gid, 0, NULL); - if (auth != NULL) { - rpc_set_auth(rpc, auth); - rpc->uid = uid; - rpc->gid = gid; - } - } -} - -void rpc_set_uid(struct rpc_context *rpc, int uid) { - rpc_set_uid_gid(rpc, uid, rpc->gid); -} - -void rpc_set_gid(struct rpc_context *rpc, int gid) { - rpc_set_uid_gid(rpc, rpc->uid, gid); -} - -void rpc_set_error(struct rpc_context *rpc, const char *error_string, ...) -{ - va_list ap; - char *old_error_string = rpc->error_string; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - va_start(ap, error_string); - rpc->error_string = malloc(1024); - vsnprintf(rpc->error_string, 1024, error_string, ap); - va_end(ap); - - RPC_LOG(rpc, 1, "error: %s", rpc->error_string); - debugNetPrintf(2,"[LIBNFS] %s error %s\n",__FUNCTION__, rpc->error_string); - - if (old_error_string != NULL) { - free(old_error_string); - } -} - -char *rpc_get_error(struct rpc_context *rpc) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - return rpc->error_string ? rpc->error_string : ""; -} - -static void rpc_purge_all_pdus(struct rpc_context *rpc, int status, const char *error) -{ - struct rpc_queue outqueue; - struct rpc_pdu *pdu; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Remove all entries from each queue before cancellation to prevent - * the callbacks manipulating entries that are about to be removed. - * - * This code assumes that the callbacks will not enqueue any new - * pdus when called. - */ - - outqueue = rpc->outqueue; - - rpc_reset_queue(&rpc->outqueue); - while ((pdu = outqueue.head) != NULL) { - outqueue.head = pdu->next; - pdu->next = NULL; - pdu->cb(rpc, status, (void *) error, pdu->private_data); - rpc_free_pdu(rpc, pdu); - } - - for (i = 0; i < HASHES; i++) { - struct rpc_queue waitqueue = rpc->waitpdu[i]; - - rpc_reset_queue(&rpc->waitpdu[i]); - while((pdu = waitqueue.head) != NULL) { - waitqueue.head = pdu->next; - pdu->next = NULL; - pdu->cb(rpc, status, (void *) error, pdu->private_data); - rpc_free_pdu(rpc, pdu); - } - } - - assert(!rpc->outqueue.head); - for (i = 0; i < HASHES; i++) - assert(!rpc->waitpdu[i].head); -} - -void rpc_error_all_pdus(struct rpc_context *rpc, const char *error) -{ - rpc_purge_all_pdus(rpc, RPC_STATUS_ERROR, error); -} - -static void rpc_free_fragment(struct rpc_fragment *fragment) -{ - if (fragment->data != NULL) { - free(fragment->data); - } - free(fragment); -} - -void rpc_free_all_fragments(struct rpc_context *rpc) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - while (rpc->fragments != NULL) { - struct rpc_fragment *fragment = rpc->fragments; - - rpc->fragments = fragment->next; - rpc_free_fragment(fragment); - } -} - -int rpc_add_fragment(struct rpc_context *rpc, char *data, uint32_t size) -{ - struct rpc_fragment *fragment; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - fragment = malloc(sizeof(struct rpc_fragment)); - if (fragment == NULL) { - return -1; - } - - fragment->size = size; - fragment->data = malloc(fragment->size); - if(fragment->data == NULL) { - free(fragment); - return -1; - } - - memcpy(fragment->data, data, fragment->size); - LIBNFS_LIST_ADD_END(&rpc->fragments, fragment); - return 0; -} - -void rpc_destroy_context(struct rpc_context *rpc) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - rpc_purge_all_pdus(rpc, RPC_STATUS_CANCEL, NULL); - - rpc_free_all_fragments(rpc); - - if (rpc->auth) { - auth_destroy(rpc->auth); - rpc->auth =NULL; - } - - if (rpc->fd != -1) { - close(rpc->fd); - } - - if (rpc->error_string != NULL) { - free(rpc->error_string); - rpc->error_string = NULL; - } - - free(rpc->inbuf); - rpc->inbuf = NULL; - - rpc->magic = 0; - free(rpc); -} - -void rpc_set_timeout(struct rpc_context *rpc, int timeout) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - rpc->timeout = timeout; -} - -int rpc_get_timeout(struct rpc_context *rpc) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - return rpc->timeout; -} - -int rpc_register_service(struct rpc_context *rpc, int program, int version, - struct service_proc *procs, int num_procs) -{ - struct rpc_endpoint *endpoint; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (!rpc->is_server_context) { - rpc_set_error(rpc, "Not a server context."); - return -1; - } - - endpoint = malloc(sizeof(*endpoint)); - if (endpoint == NULL) { - rpc_set_error(rpc, "Out of memory: Failed to allocate endpoint " - "structure"); - return -1; - } - - endpoint->program = program; - endpoint->version = version; - endpoint->procs = procs; - endpoint->num_procs = num_procs; - endpoint->next = rpc->endpoints; - rpc->endpoints = endpoint; - - return 0; -} diff --git a/source/liborbisNfs/libnfs-raw-mount.c b/source/liborbisNfs/libnfs-raw-mount.c deleted file mode 100644 index 10e9621..0000000 --- a/source/liborbisNfs/libnfs-raw-mount.c +++ /dev/null @@ -1,193 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-mount.h" - -uint32_t -zdr_fhandle3 (ZDR *zdrs, fhandle3 *objp) -{ - if (!zdr_bytes (zdrs, (char **)&objp->fhandle3_val, (u_int *) &objp->fhandle3_len, FHSIZE3)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_dirpath (ZDR *zdrs, dirpath *objp) -{ - if (!zdr_string (zdrs, objp, MNTPATHLEN)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_name (ZDR *zdrs, name *objp) -{ - if (!zdr_string (zdrs, objp, MNTNAMLEN)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountstat3 (ZDR *zdrs, mountstat3 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountlist (ZDR *zdrs, mountlist *objp) -{ - if (!zdr_pointer (zdrs, (char **)objp, sizeof (struct mountbody), (zdrproc_t) zdr_mountbody)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountbody (ZDR *zdrs, mountbody *objp) -{ - if (!zdr_name (zdrs, &objp->ml_hostname)) - return FALSE; - if (!zdr_dirpath (zdrs, &objp->ml_directory)) - return FALSE; - if (!zdr_mountlist (zdrs, &objp->ml_next)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_groups (ZDR *zdrs, groups *objp) -{ - if (!zdr_pointer (zdrs, (char **)objp, sizeof (struct groupnode), (zdrproc_t) zdr_groupnode)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_groupnode (ZDR *zdrs, groupnode *objp) -{ - if (!zdr_name (zdrs, &objp->gr_name)) - return FALSE; - if (!zdr_groups (zdrs, &objp->gr_next)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_exports (ZDR *zdrs, exports *objp) -{ - if (!zdr_pointer (zdrs, (char **)objp, sizeof (struct exportnode), (zdrproc_t) zdr_exportnode)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_exportnode (ZDR *zdrs, exportnode *objp) -{ - if (!zdr_dirpath (zdrs, &objp->ex_dir)) - return FALSE; - if (!zdr_groups (zdrs, &objp->ex_groups)) - return FALSE; - if (!zdr_exports (zdrs, &objp->ex_next)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountres3_ok (ZDR *zdrs, mountres3_ok *objp) -{ - if (!zdr_fhandle3 (zdrs, &objp->fhandle)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->auth_flavors.auth_flavors_val, (u_int *) &objp->auth_flavors.auth_flavors_len, ~0, - sizeof (int), (zdrproc_t) zdr_int)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountres3 (ZDR *zdrs, mountres3 *objp) -{ - if (!zdr_mountstat3 (zdrs, &objp->fhs_status)) - return FALSE; - switch (objp->fhs_status) { - case MNT3_OK: - if (!zdr_mountres3_ok (zdrs, &objp->mountres3_u.mountinfo)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_mountstat1 (ZDR *zdrs, mountstat1 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fhandle1 (ZDR *zdrs, fhandle1 objp) -{ - if (!zdr_opaque (zdrs, objp, FHSIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountres1_ok (ZDR *zdrs, mountres1_ok *objp) -{ - if (!zdr_fhandle1 (zdrs, objp->fhandle)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mountres1 (ZDR *zdrs, mountres1 *objp) -{ - if (!zdr_mountstat1 (zdrs, &objp->fhs_status)) - return FALSE; - switch (objp->fhs_status) { - case MNT1_OK: - if (!zdr_mountres1_ok (zdrs, &objp->mountres1_u.mountinfo)) - return FALSE; - break; - default: - break; - } - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-raw-nfs.c b/source/liborbisNfs/libnfs-raw-nfs.c deleted file mode 100644 index dadcd79..0000000 --- a/source/liborbisNfs/libnfs-raw-nfs.c +++ /dev/null @@ -1,2658 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-nfs.h" - -uint32_t -zdr_cookieverf3 (ZDR *zdrs, cookieverf3 objp) -{ - if (!zdr_opaque (zdrs, objp, NFS3_COOKIEVERFSIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_cookie3 (ZDR *zdrs, cookie3 *objp) -{ - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_fh3 (ZDR *zdrs, nfs_fh3 *objp) -{ - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, NFS3_FHSIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_filename3 (ZDR *zdrs, filename3 *objp) -{ - if (!zdr_string (zdrs, objp, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_diropargs3 (ZDR *zdrs, diropargs3 *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->dir)) - return FALSE; - if (!zdr_filename3 (zdrs, &objp->name)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ftype3 (ZDR *zdrs, ftype3 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mode3 (ZDR *zdrs, mode3 *objp) -{ - if (!zdr_u_int (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_uid3 (ZDR *zdrs, uid3 *objp) -{ - if (!zdr_u_int (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_gid3 (ZDR *zdrs, gid3 *objp) -{ - if (!zdr_u_int (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_size3 (ZDR *zdrs, size3 *objp) -{ - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fileid3 (ZDR *zdrs, fileid3 *objp) -{ - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_specdata3 (ZDR *zdrs, specdata3 *objp) -{ - if (!zdr_u_int (zdrs, &objp->specdata1)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->specdata2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfstime3 (ZDR *zdrs, nfstime3 *objp) -{ - if (!zdr_u_int (zdrs, &objp->seconds)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->nseconds)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr3 (ZDR *zdrs, fattr3 *objp) -{ - if (!zdr_ftype3 (zdrs, &objp->type)) - return FALSE; - if (!zdr_mode3 (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->nlink)) - return FALSE; - if (!zdr_uid3 (zdrs, &objp->uid)) - return FALSE; - if (!zdr_gid3 (zdrs, &objp->gid)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->size)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->used)) - return FALSE; - if (!zdr_specdata3 (zdrs, &objp->rdev)) - return FALSE; - if (!zdr_uint64_t (zdrs, &objp->fsid)) - return FALSE; - if (!zdr_fileid3 (zdrs, &objp->fileid)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->ctime)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_post_op_attr (ZDR *zdrs, post_op_attr *objp) -{ - if (!zdr_bool (zdrs, &objp->attributes_follow)) - return FALSE; - switch (objp->attributes_follow) { - case TRUE: - if (!zdr_fattr3 (zdrs, &objp->post_op_attr_u.attributes)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_nfsstat3 (ZDR *zdrs, nfsstat3 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_stable_how (ZDR *zdrs, stable_how *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_offset3 (ZDR *zdrs, offset3 *objp) -{ - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_count3 (ZDR *zdrs, count3 *objp) -{ - if (!zdr_u_int (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_wcc_attr (ZDR *zdrs, wcc_attr *objp) -{ - if (!zdr_size3 (zdrs, &objp->size)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->ctime)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pre_op_attr (ZDR *zdrs, pre_op_attr *objp) -{ - if (!zdr_bool (zdrs, &objp->attributes_follow)) - return FALSE; - switch (objp->attributes_follow) { - case TRUE: - if (!zdr_wcc_attr (zdrs, &objp->pre_op_attr_u.attributes)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_wcc_data (ZDR *zdrs, wcc_data *objp) -{ - if (!zdr_pre_op_attr (zdrs, &objp->before)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->after)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE3args (ZDR *zdrs, WRITE3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->file)) - return FALSE; - if (!zdr_offset3 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->count)) - return FALSE; - if (!zdr_stable_how (zdrs, &objp->stable)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_writeverf3 (ZDR *zdrs, writeverf3 objp) -{ - if (!zdr_opaque (zdrs, objp, NFS3_WRITEVERFSIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE3resok (ZDR *zdrs, WRITE3resok *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->file_wcc)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->count)) - return FALSE; - if (!zdr_stable_how (zdrs, &objp->committed)) - return FALSE; - if (!zdr_writeverf3 (zdrs, objp->verf)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE3resfail (ZDR *zdrs, WRITE3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->file_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE3res (ZDR *zdrs, WRITE3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_WRITE3resok (zdrs, &objp->WRITE3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_WRITE3resfail (zdrs, &objp->WRITE3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_LOOKUP3args (ZDR *zdrs, LOOKUP3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->what)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUP3resok (ZDR *zdrs, LOOKUP3resok *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->object)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUP3resfail (ZDR *zdrs, LOOKUP3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUP3res (ZDR *zdrs, LOOKUP3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_LOOKUP3resok (zdrs, &objp->LOOKUP3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_LOOKUP3resfail (zdrs, &objp->LOOKUP3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_COMMIT3args (ZDR *zdrs, COMMIT3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->file)) - return FALSE; - if (!zdr_offset3 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->count)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_COMMIT3resok (ZDR *zdrs, COMMIT3resok *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->file_wcc)) - return FALSE; - if (!zdr_writeverf3 (zdrs, objp->verf)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_COMMIT3resfail (ZDR *zdrs, COMMIT3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->file_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_COMMIT3res (ZDR *zdrs, COMMIT3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_COMMIT3resok (zdrs, &objp->COMMIT3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_COMMIT3resfail (zdrs, &objp->COMMIT3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_ACCESS3args (ZDR *zdrs, ACCESS3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->object)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->access)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ACCESS3resok (ZDR *zdrs, ACCESS3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->access)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ACCESS3resfail (ZDR *zdrs, ACCESS3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ACCESS3res (ZDR *zdrs, ACCESS3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_ACCESS3resok (zdrs, &objp->ACCESS3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_ACCESS3resfail (zdrs, &objp->ACCESS3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_GETATTR3args (ZDR *zdrs, GETATTR3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->object)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR3resok (ZDR *zdrs, GETATTR3resok *objp) -{ - if (!zdr_fattr3 (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR3res (ZDR *zdrs, GETATTR3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_GETATTR3resok (zdrs, &objp->GETATTR3res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_time_how (ZDR *zdrs, time_how *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_set_mode3 (ZDR *zdrs, set_mode3 *objp) -{ - if (!zdr_bool (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!zdr_mode3 (zdrs, &objp->set_mode3_u.mode)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_set_uid3 (ZDR *zdrs, set_uid3 *objp) -{ - if (!zdr_bool (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!zdr_uid3 (zdrs, &objp->set_uid3_u.uid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_set_gid3 (ZDR *zdrs, set_gid3 *objp) -{ - if (!zdr_bool (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!zdr_gid3 (zdrs, &objp->set_gid3_u.gid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_set_size3 (ZDR *zdrs, set_size3 *objp) -{ - if (!zdr_bool (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!zdr_size3 (zdrs, &objp->set_size3_u.size)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_set_atime (ZDR *zdrs, set_atime *objp) -{ - if (!zdr_time_how (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME: - if (!zdr_nfstime3 (zdrs, &objp->set_atime_u.atime)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_set_mtime (ZDR *zdrs, set_mtime *objp) -{ - if (!zdr_time_how (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME: - if (!zdr_nfstime3 (zdrs, &objp->set_mtime_u.mtime)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_sattr3 (ZDR *zdrs, sattr3 *objp) -{ - if (!zdr_set_mode3 (zdrs, &objp->mode)) - return FALSE; - if (!zdr_set_uid3 (zdrs, &objp->uid)) - return FALSE; - if (!zdr_set_gid3 (zdrs, &objp->gid)) - return FALSE; - if (!zdr_set_size3 (zdrs, &objp->size)) - return FALSE; - if (!zdr_set_atime (zdrs, &objp->atime)) - return FALSE; - if (!zdr_set_mtime (zdrs, &objp->mtime)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_createmode3 (ZDR *zdrs, createmode3 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_createverf3 (ZDR *zdrs, createverf3 objp) -{ - if (!zdr_opaque (zdrs, objp, NFS3_CREATEVERFSIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_createhow3 (ZDR *zdrs, createhow3 *objp) -{ - if (!zdr_createmode3 (zdrs, &objp->mode)) - return FALSE; - switch (objp->mode) { - case UNCHECKED: - if (!zdr_sattr3 (zdrs, &objp->createhow3_u.obj_attributes)) - return FALSE; - break; - case GUARDED: - if (!zdr_sattr3 (zdrs, &objp->createhow3_u.g_obj_attributes)) - return FALSE; - break; - case EXCLUSIVE: - if (!zdr_createverf3 (zdrs, objp->createhow3_u.verf)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_CREATE3args (ZDR *zdrs, CREATE3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->where)) - return FALSE; - if (!zdr_createhow3 (zdrs, &objp->how)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_post_op_fh3 (ZDR *zdrs, post_op_fh3 *objp) -{ - if (!zdr_bool (zdrs, &objp->handle_follows)) - return FALSE; - switch (objp->handle_follows) { - case TRUE: - if (!zdr_nfs_fh3 (zdrs, &objp->post_op_fh3_u.handle)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_CREATE3resok (ZDR *zdrs, CREATE3resok *objp) -{ - if (!zdr_post_op_fh3 (zdrs, &objp->obj)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CREATE3resfail (ZDR *zdrs, CREATE3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CREATE3res (ZDR *zdrs, CREATE3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_CREATE3resok (zdrs, &objp->CREATE3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_CREATE3resfail (zdrs, &objp->CREATE3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_REMOVE3args (ZDR *zdrs, REMOVE3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->object)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_REMOVE3resok (ZDR *zdrs, REMOVE3resok *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_REMOVE3resfail (ZDR *zdrs, REMOVE3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_REMOVE3res (ZDR *zdrs, REMOVE3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_REMOVE3resok (zdrs, &objp->REMOVE3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_REMOVE3resfail (zdrs, &objp->REMOVE3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_READ3args (ZDR *zdrs, READ3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->file)) - return FALSE; - if (!zdr_offset3 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->count)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ3resok (ZDR *zdrs, READ3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->file_attributes)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->count)) - return FALSE; - if (!zdr_bool (zdrs, &objp->eof)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ3resfail (ZDR *zdrs, READ3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->file_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ3res (ZDR *zdrs, READ3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READ3resok (zdrs, &objp->READ3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_READ3resfail (zdrs, &objp->READ3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_FSINFO3args (ZDR *zdrs, FSINFO3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->fsroot)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_FSINFO3resok (ZDR *zdrs, FSINFO3resok *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - buf = ZDR_INLINE (zdrs, 7 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->rtmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtpref)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtmult)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtpref)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtmult)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->dtpref)) - return FALSE; - - } else { - IZDR_PUT_U_LONG(buf, objp->rtmax); - IZDR_PUT_U_LONG(buf, objp->rtpref); - IZDR_PUT_U_LONG(buf, objp->rtmult); - IZDR_PUT_U_LONG(buf, objp->wtmax); - IZDR_PUT_U_LONG(buf, objp->wtpref); - IZDR_PUT_U_LONG(buf, objp->wtmult); - IZDR_PUT_U_LONG(buf, objp->dtpref); - } - if (!zdr_size3 (zdrs, &objp->maxfilesize)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->time_delta)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->properties)) - return FALSE; - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - buf = ZDR_INLINE (zdrs, 7 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->rtmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtpref)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtmult)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtpref)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtmult)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->dtpref)) - return FALSE; - - } else { - objp->rtmax = IZDR_GET_U_LONG(buf); - objp->rtpref = IZDR_GET_U_LONG(buf); - objp->rtmult = IZDR_GET_U_LONG(buf); - objp->wtmax = IZDR_GET_U_LONG(buf); - objp->wtpref = IZDR_GET_U_LONG(buf); - objp->wtmult = IZDR_GET_U_LONG(buf); - objp->dtpref = IZDR_GET_U_LONG(buf); - } - if (!zdr_size3 (zdrs, &objp->maxfilesize)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->time_delta)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->properties)) - return FALSE; - return TRUE; - } - - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtpref)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rtmult)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtpref)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->wtmult)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->dtpref)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->maxfilesize)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->time_delta)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->properties)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_FSINFO3resfail (ZDR *zdrs, FSINFO3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_FSINFO3res (ZDR *zdrs, FSINFO3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_FSINFO3resok (zdrs, &objp->FSINFO3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_FSINFO3resfail (zdrs, &objp->FSINFO3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_FSSTAT3args (ZDR *zdrs, FSSTAT3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->fsroot)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_FSSTAT3resok (ZDR *zdrs, FSSTAT3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->tbytes)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->fbytes)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->abytes)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->tfiles)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->ffiles)) - return FALSE; - if (!zdr_size3 (zdrs, &objp->afiles)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->invarsec)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_FSSTAT3resfail (ZDR *zdrs, FSSTAT3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_FSSTAT3res (ZDR *zdrs, FSSTAT3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_FSSTAT3resok (zdrs, &objp->FSSTAT3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_FSSTAT3resfail (zdrs, &objp->FSSTAT3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_PATHCONF3args (ZDR *zdrs, PATHCONF3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->object)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PATHCONF3resok (ZDR *zdrs, PATHCONF3resok *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - buf = ZDR_INLINE (zdrs, 6 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->linkmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->name_max)) - return FALSE; - if (!zdr_bool (zdrs, &objp->no_trunc)) - return FALSE; - if (!zdr_bool (zdrs, &objp->chown_restricted)) - return FALSE; - if (!zdr_bool (zdrs, &objp->case_insensitive)) - return FALSE; - if (!zdr_bool (zdrs, &objp->case_preserving)) - return FALSE; - } else { - IZDR_PUT_U_LONG(buf, objp->linkmax); - IZDR_PUT_U_LONG(buf, objp->name_max); - IZDR_PUT_BOOL(buf, objp->no_trunc); - IZDR_PUT_BOOL(buf, objp->chown_restricted); - IZDR_PUT_BOOL(buf, objp->case_insensitive); - IZDR_PUT_BOOL(buf, objp->case_preserving); - } - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - buf = ZDR_INLINE (zdrs, 6 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->linkmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->name_max)) - return FALSE; - if (!zdr_bool (zdrs, &objp->no_trunc)) - return FALSE; - if (!zdr_bool (zdrs, &objp->chown_restricted)) - return FALSE; - if (!zdr_bool (zdrs, &objp->case_insensitive)) - return FALSE; - if (!zdr_bool (zdrs, &objp->case_preserving)) - return FALSE; - } else { - objp->linkmax = IZDR_GET_U_LONG(buf); - objp->name_max = IZDR_GET_U_LONG(buf); - objp->no_trunc = IZDR_GET_BOOL(buf); - objp->chown_restricted = IZDR_GET_BOOL(buf); - objp->case_insensitive = IZDR_GET_BOOL(buf); - objp->case_preserving = IZDR_GET_BOOL(buf); - } - return TRUE; - } - - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->linkmax)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->name_max)) - return FALSE; - if (!zdr_bool (zdrs, &objp->no_trunc)) - return FALSE; - if (!zdr_bool (zdrs, &objp->chown_restricted)) - return FALSE; - if (!zdr_bool (zdrs, &objp->case_insensitive)) - return FALSE; - if (!zdr_bool (zdrs, &objp->case_preserving)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PATHCONF3resfail (ZDR *zdrs, PATHCONF3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PATHCONF3res (ZDR *zdrs, PATHCONF3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_PATHCONF3resok (zdrs, &objp->PATHCONF3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_PATHCONF3resfail (zdrs, &objp->PATHCONF3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_nfspath3 (ZDR *zdrs, nfspath3 *objp) -{ - if (!zdr_string (zdrs, objp, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_symlinkdata3 (ZDR *zdrs, symlinkdata3 *objp) -{ - if (!zdr_sattr3 (zdrs, &objp->symlink_attributes)) - return FALSE; - if (!zdr_nfspath3 (zdrs, &objp->symlink_data)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SYMLINK3args (ZDR *zdrs, SYMLINK3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->where)) - return FALSE; - if (!zdr_symlinkdata3 (zdrs, &objp->symlink)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SYMLINK3resok (ZDR *zdrs, SYMLINK3resok *objp) -{ - if (!zdr_post_op_fh3 (zdrs, &objp->obj)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SYMLINK3resfail (ZDR *zdrs, SYMLINK3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SYMLINK3res (ZDR *zdrs, SYMLINK3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_SYMLINK3resok (zdrs, &objp->SYMLINK3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_SYMLINK3resfail (zdrs, &objp->SYMLINK3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_READLINK3args (ZDR *zdrs, READLINK3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->symlink)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READLINK3resok (ZDR *zdrs, READLINK3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->symlink_attributes)) - return FALSE; - if (!zdr_nfspath3 (zdrs, &objp->data)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READLINK3resfail (ZDR *zdrs, READLINK3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->symlink_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READLINK3res (ZDR *zdrs, READLINK3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READLINK3resok (zdrs, &objp->READLINK3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_READLINK3resfail (zdrs, &objp->READLINK3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_devicedata3 (ZDR *zdrs, devicedata3 *objp) -{ - if (!zdr_sattr3 (zdrs, &objp->dev_attributes)) - return FALSE; - if (!zdr_specdata3 (zdrs, &objp->spec)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mknoddata3 (ZDR *zdrs, mknoddata3 *objp) -{ - if (!zdr_ftype3 (zdrs, &objp->type)) - return FALSE; - switch (objp->type) { - case NF3CHR: - if (!zdr_devicedata3 (zdrs, &objp->mknoddata3_u.chr_device)) - return FALSE; - break; - case NF3BLK: - if (!zdr_devicedata3 (zdrs, &objp->mknoddata3_u.blk_device)) - return FALSE; - break; - case NF3SOCK: - if (!zdr_sattr3 (zdrs, &objp->mknoddata3_u.sock_attributes)) - return FALSE; - break; - case NF3FIFO: - if (!zdr_sattr3 (zdrs, &objp->mknoddata3_u.pipe_attributes)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_MKNOD3args (ZDR *zdrs, MKNOD3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->where)) - return FALSE; - if (!zdr_mknoddata3 (zdrs, &objp->what)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKNOD3resok (ZDR *zdrs, MKNOD3resok *objp) -{ - if (!zdr_post_op_fh3 (zdrs, &objp->obj)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKNOD3resfail (ZDR *zdrs, MKNOD3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKNOD3res (ZDR *zdrs, MKNOD3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_MKNOD3resok (zdrs, &objp->MKNOD3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_MKNOD3resfail (zdrs, &objp->MKNOD3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_MKDIR3args (ZDR *zdrs, MKDIR3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->where)) - return FALSE; - if (!zdr_sattr3 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKDIR3resok (ZDR *zdrs, MKDIR3resok *objp) -{ - if (!zdr_post_op_fh3 (zdrs, &objp->obj)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->obj_attributes)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKDIR3resfail (ZDR *zdrs, MKDIR3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKDIR3res (ZDR *zdrs, MKDIR3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_MKDIR3resok (zdrs, &objp->MKDIR3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_MKDIR3resfail (zdrs, &objp->MKDIR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_RMDIR3args (ZDR *zdrs, RMDIR3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->object)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RMDIR3resok (ZDR *zdrs, RMDIR3resok *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RMDIR3resfail (ZDR *zdrs, RMDIR3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RMDIR3res (ZDR *zdrs, RMDIR3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_RMDIR3resok (zdrs, &objp->RMDIR3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_RMDIR3resfail (zdrs, &objp->RMDIR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_RENAME3args (ZDR *zdrs, RENAME3args *objp) -{ - if (!zdr_diropargs3 (zdrs, &objp->from)) - return FALSE; - if (!zdr_diropargs3 (zdrs, &objp->to)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME3resok (ZDR *zdrs, RENAME3resok *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->fromdir_wcc)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->todir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME3resfail (ZDR *zdrs, RENAME3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->fromdir_wcc)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->todir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME3res (ZDR *zdrs, RENAME3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_RENAME3resok (zdrs, &objp->RENAME3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_RENAME3resfail (zdrs, &objp->RENAME3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_READDIRPLUS3args (ZDR *zdrs, READDIRPLUS3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->dir)) - return FALSE; - if (!zdr_cookie3 (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_cookieverf3 (zdrs, objp->cookieverf)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->dircount)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->maxcount)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_entryplus3 (ZDR *zdrs, entryplus3 *objp) -{ - if (!zdr_fileid3 (zdrs, &objp->fileid)) - return FALSE; - if (!zdr_filename3 (zdrs, &objp->name)) - return FALSE; - if (!zdr_cookie3 (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_post_op_attr (zdrs, &objp->name_attributes)) - return FALSE; - if (!zdr_post_op_fh3 (zdrs, &objp->name_handle)) - return FALSE; - if (!zdr_pointer (zdrs, (char **)&objp->nextentry, sizeof (entryplus3), (zdrproc_t) zdr_entryplus3)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_dirlistplus3 (ZDR *zdrs, dirlistplus3 *objp) -{ - if (!zdr_pointer (zdrs, (char **)&objp->entries, sizeof (entryplus3), (zdrproc_t) zdr_entryplus3)) - return FALSE; - if (!zdr_bool (zdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIRPLUS3resok (ZDR *zdrs, READDIRPLUS3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->dir_attributes)) - return FALSE; - if (!zdr_cookieverf3 (zdrs, objp->cookieverf)) - return FALSE; - if (!zdr_dirlistplus3 (zdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIRPLUS3resfail (ZDR *zdrs, READDIRPLUS3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIRPLUS3res (ZDR *zdrs, READDIRPLUS3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READDIRPLUS3resok (zdrs, &objp->READDIRPLUS3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_READDIRPLUS3resfail (zdrs, &objp->READDIRPLUS3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_READDIR3args (ZDR *zdrs, READDIR3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->dir)) - return FALSE; - if (!zdr_cookie3 (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_cookieverf3 (zdrs, objp->cookieverf)) - return FALSE; - if (!zdr_count3 (zdrs, &objp->count)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_entry3 (ZDR *zdrs, entry3 *objp) -{ - if (!zdr_fileid3 (zdrs, &objp->fileid)) - return FALSE; - if (!zdr_filename3 (zdrs, &objp->name)) - return FALSE; - if (!zdr_cookie3 (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_pointer (zdrs, (char **)&objp->nextentry, sizeof (entry3), (zdrproc_t) zdr_entry3)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_dirlist3 (ZDR *zdrs, dirlist3 *objp) -{ - if (!zdr_pointer (zdrs, (char **)&objp->entries, sizeof (entry3), (zdrproc_t) zdr_entry3)) - return FALSE; - if (!zdr_bool (zdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR3resok (ZDR *zdrs, READDIR3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->dir_attributes)) - return FALSE; - if (!zdr_cookieverf3 (zdrs, objp->cookieverf)) - return FALSE; - if (!zdr_dirlist3 (zdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR3resfail (ZDR *zdrs, READDIR3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR3res (ZDR *zdrs, READDIR3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READDIR3resok (zdrs, &objp->READDIR3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_READDIR3resfail (zdrs, &objp->READDIR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_LINK3args (ZDR *zdrs, LINK3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->file)) - return FALSE; - if (!zdr_diropargs3 (zdrs, &objp->link)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK3resok (ZDR *zdrs, LINK3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->file_attributes)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->linkdir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK3resfail (ZDR *zdrs, LINK3resfail *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->file_attributes)) - return FALSE; - if (!zdr_wcc_data (zdrs, &objp->linkdir_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK3res (ZDR *zdrs, LINK3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_LINK3resok (zdrs, &objp->LINK3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_LINK3resfail (zdrs, &objp->LINK3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_sattrguard3 (ZDR *zdrs, sattrguard3 *objp) -{ - if (!zdr_bool (zdrs, &objp->check)) - return FALSE; - switch (objp->check) { - case TRUE: - if (!zdr_nfstime3 (zdrs, &objp->sattrguard3_u.obj_ctime)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_SETATTR3args (ZDR *zdrs, SETATTR3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->object)) - return FALSE; - if (!zdr_sattr3 (zdrs, &objp->new_attributes)) - return FALSE; - if (!zdr_sattrguard3 (zdrs, &objp->guard)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR3resok (ZDR *zdrs, SETATTR3resok *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->obj_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR3resfail (ZDR *zdrs, SETATTR3resfail *objp) -{ - if (!zdr_wcc_data (zdrs, &objp->obj_wcc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR3res (ZDR *zdrs, SETATTR3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_SETATTR3resok (zdrs, &objp->SETATTR3res_u.resok)) - return FALSE; - break; - default: - if (!zdr_SETATTR3resfail (zdrs, &objp->SETATTR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -uint32_t -zdr_fhandle2 (ZDR *zdrs, fhandle2 objp) -{ - if (!zdr_opaque (zdrs, objp, FHSIZE2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ftype2 (ZDR *zdrs, ftype2 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr2 (ZDR *zdrs, fattr2 *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - if (!zdr_ftype2 (zdrs, &objp->type)) - return FALSE; - buf = ZDR_INLINE (zdrs, 10 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->nlink)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->uid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->gid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->size)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocksize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rdev)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocks)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->fsid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->fileid)) - return FALSE; - - } else { - IZDR_PUT_U_LONG(buf, objp->mode); - IZDR_PUT_U_LONG(buf, objp->nlink); - IZDR_PUT_U_LONG(buf, objp->uid); - IZDR_PUT_U_LONG(buf, objp->gid); - IZDR_PUT_U_LONG(buf, objp->size); - IZDR_PUT_U_LONG(buf, objp->blocksize); - IZDR_PUT_U_LONG(buf, objp->rdev); - IZDR_PUT_U_LONG(buf, objp->blocks); - IZDR_PUT_U_LONG(buf, objp->fsid); - IZDR_PUT_U_LONG(buf, objp->fileid); - } - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->ctime)) - return FALSE; - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - if (!zdr_ftype2 (zdrs, &objp->type)) - return FALSE; - buf = ZDR_INLINE (zdrs, 10 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->nlink)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->uid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->gid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->size)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocksize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rdev)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocks)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->fsid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->fileid)) - return FALSE; - - } else { - objp->mode = IZDR_GET_U_LONG(buf); - objp->nlink = IZDR_GET_U_LONG(buf); - objp->uid = IZDR_GET_U_LONG(buf); - objp->gid = IZDR_GET_U_LONG(buf); - objp->size = IZDR_GET_U_LONG(buf); - objp->blocksize = IZDR_GET_U_LONG(buf); - objp->rdev = IZDR_GET_U_LONG(buf); - objp->blocks = IZDR_GET_U_LONG(buf); - objp->fsid = IZDR_GET_U_LONG(buf); - objp->fileid = IZDR_GET_U_LONG(buf); - } - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->ctime)) - return FALSE; - return TRUE; - } - - if (!zdr_ftype2 (zdrs, &objp->type)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->nlink)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->uid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->gid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->size)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocksize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->rdev)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocks)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->fsid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->fileid)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->ctime)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_sattr2 (ZDR *zdrs, sattr2 *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - buf = ZDR_INLINE (zdrs, 4 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->uid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->gid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->size)) - return FALSE; - - } else { - IZDR_PUT_U_LONG(buf, objp->mode); - IZDR_PUT_U_LONG(buf, objp->uid); - IZDR_PUT_U_LONG(buf, objp->gid); - IZDR_PUT_U_LONG(buf, objp->size); - } - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - buf = ZDR_INLINE (zdrs, 4 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->uid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->gid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->size)) - return FALSE; - - } else { - objp->mode = IZDR_GET_U_LONG(buf); - objp->uid = IZDR_GET_U_LONG(buf); - objp->gid = IZDR_GET_U_LONG(buf); - objp->size = IZDR_GET_U_LONG(buf); - } - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - return TRUE; - } - - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->uid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->gid)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->size)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->atime)) - return FALSE; - if (!zdr_nfstime3 (zdrs, &objp->mtime)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_filename2 (ZDR *zdrs, filename2 *objp) -{ - if (!zdr_string (zdrs, objp, MAXNAMLEN2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_path2 (ZDR *zdrs, path2 *objp) -{ - if (!zdr_string (zdrs, objp, MAXPATHLEN2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfsdata2 (ZDR *zdrs, nfsdata2 *objp) -{ - if (!zdr_bytes (zdrs, (char **)&objp->nfsdata2_val, (u_int *) &objp->nfsdata2_len, NFSMAXDATA2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfscookie2 (ZDR *zdrs, nfscookie2 objp) -{ - if (!zdr_opaque (zdrs, objp, NFSCOOKIESIZE2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_entry2 (ZDR *zdrs, entry2 *objp) -{ - if (!zdr_u_int (zdrs, &objp->fileid)) - return FALSE; - if (!zdr_filename2 (zdrs, &objp->name)) - return FALSE; - if (!zdr_nfscookie2 (zdrs, objp->cookie)) - return FALSE; - if (!zdr_pointer (zdrs, (char **)&objp->nextentry, sizeof (entry2), (zdrproc_t) zdr_entry2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_diropargs2 (ZDR *zdrs, diropargs2 *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->dir)) - return FALSE; - if (!zdr_filename2 (zdrs, &objp->name)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR2args (ZDR *zdrs, GETATTR2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->fhandle)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR2resok (ZDR *zdrs, GETATTR2resok *objp) -{ - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR2res (ZDR *zdrs, GETATTR2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_GETATTR2resok (zdrs, &objp->GETATTR2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_SETATTR2args (ZDR *zdrs, SETATTR2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->fhandle)) - return FALSE; - if (!zdr_sattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR2resok (ZDR *zdrs, SETATTR2resok *objp) -{ - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR2res (ZDR *zdrs, SETATTR2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_SETATTR2resok (zdrs, &objp->SETATTR2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_LOOKUP2args (ZDR *zdrs, LOOKUP2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->what)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUP2resok (ZDR *zdrs, LOOKUP2resok *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUP2res (ZDR *zdrs, LOOKUP2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_LOOKUP2resok (zdrs, &objp->LOOKUP2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_READLINK2args (ZDR *zdrs, READLINK2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READLINK2resok (ZDR *zdrs, READLINK2resok *objp) -{ - if (!zdr_path2 (zdrs, &objp->data)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READLINK2res (ZDR *zdrs, READLINK2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READLINK2resok (zdrs, &objp->READLINK2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_READ2args (ZDR *zdrs, READ2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->offset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->count)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->totalcount)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ2resok (ZDR *zdrs, READ2resok *objp) -{ - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - if (!zdr_nfsdata2 (zdrs, &objp->data)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ2res (ZDR *zdrs, READ2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READ2resok (zdrs, &objp->READ2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_WRITE2args (ZDR *zdrs, WRITE2args *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - buf = ZDR_INLINE (zdrs, 3 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->beginoffset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->offset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->totalcount)) - return FALSE; - - } else { - IZDR_PUT_U_LONG(buf, objp->beginoffset); - IZDR_PUT_U_LONG(buf, objp->offset); - IZDR_PUT_U_LONG(buf, objp->totalcount); - } - if (!zdr_nfsdata2 (zdrs, &objp->data)) - return FALSE; - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - buf = ZDR_INLINE (zdrs, 3 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->beginoffset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->offset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->totalcount)) - return FALSE; - - } else { - objp->beginoffset = IZDR_GET_U_LONG(buf); - objp->offset = IZDR_GET_U_LONG(buf); - objp->totalcount = IZDR_GET_U_LONG(buf); - } - if (!zdr_nfsdata2 (zdrs, &objp->data)) - return FALSE; - return TRUE; - } - - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->beginoffset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->offset)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->totalcount)) - return FALSE; - if (!zdr_nfsdata2 (zdrs, &objp->data)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE2resok (ZDR *zdrs, WRITE2resok *objp) -{ - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE2res (ZDR *zdrs, WRITE2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_WRITE2resok (zdrs, &objp->WRITE2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_CREATE2args (ZDR *zdrs, CREATE2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->where)) - return FALSE; - if (!zdr_sattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CREATE2resok (ZDR *zdrs, CREATE2resok *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CREATE2res (ZDR *zdrs, CREATE2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_CREATE2resok (zdrs, &objp->CREATE2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_REMOVE2args (ZDR *zdrs, REMOVE2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->what)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_REMOVE2res (ZDR *zdrs, REMOVE2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME2args (ZDR *zdrs, RENAME2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->from)) - return FALSE; - if (!zdr_diropargs2 (zdrs, &objp->to)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME2res (ZDR *zdrs, RENAME2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK2args (ZDR *zdrs, LINK2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->from)) - return FALSE; - if (!zdr_diropargs2 (zdrs, &objp->to)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK2res (ZDR *zdrs, LINK2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SYMLINK2args (ZDR *zdrs, SYMLINK2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->from)) - return FALSE; - if (!zdr_path2 (zdrs, &objp->to)) - return FALSE; - if (!zdr_sattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SYMLINK2res (ZDR *zdrs, SYMLINK2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKDIR2args (ZDR *zdrs, MKDIR2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->where)) - return FALSE; - if (!zdr_sattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKDIR2resok (ZDR *zdrs, MKDIR2resok *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->file)) - return FALSE; - if (!zdr_fattr2 (zdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_MKDIR2res (ZDR *zdrs, MKDIR2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_MKDIR2resok (zdrs, &objp->MKDIR2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_RMDIR2args (ZDR *zdrs, RMDIR2args *objp) -{ - if (!zdr_diropargs2 (zdrs, &objp->what)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RMDIR2res (ZDR *zdrs, RMDIR2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR2args (ZDR *zdrs, READDIR2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->dir)) - return FALSE; - if (!zdr_nfscookie2 (zdrs, objp->cookie)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->count)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR2resok (ZDR *zdrs, READDIR2resok *objp) -{ - if (!zdr_pointer (zdrs, (char **)&objp->entries, sizeof (entry2), (zdrproc_t) zdr_entry2)) - return FALSE; - if (!zdr_bool (zdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR2res (ZDR *zdrs, READDIR2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_READDIR2resok (zdrs, &objp->READDIR2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_STATFS2args (ZDR *zdrs, STATFS2args *objp) -{ - if (!zdr_fhandle2 (zdrs, objp->dir)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_STATFS2resok (ZDR *zdrs, STATFS2resok *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - buf = ZDR_INLINE (zdrs, 5 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->tsize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bsize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocks)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bfree)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bavail)) - return FALSE; - } else { - IZDR_PUT_U_LONG(buf, objp->tsize); - IZDR_PUT_U_LONG(buf, objp->bsize); - IZDR_PUT_U_LONG(buf, objp->blocks); - IZDR_PUT_U_LONG(buf, objp->bfree); - IZDR_PUT_U_LONG(buf, objp->bavail); - } - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - buf = ZDR_INLINE (zdrs, 5 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->tsize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bsize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocks)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bfree)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bavail)) - return FALSE; - } else { - objp->tsize = IZDR_GET_U_LONG(buf); - objp->bsize = IZDR_GET_U_LONG(buf); - objp->blocks = IZDR_GET_U_LONG(buf); - objp->bfree = IZDR_GET_U_LONG(buf); - objp->bavail = IZDR_GET_U_LONG(buf); - } - return TRUE; - } - - if (!zdr_u_int (zdrs, &objp->tsize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bsize)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->blocks)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bfree)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->bavail)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_STATFS2res (ZDR *zdrs, STATFS2res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_STATFS2resok (zdrs, &objp->STATFS2res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_nfsacl_type (ZDR *zdrs, nfsacl_type *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfsacl_ace (ZDR *zdrs, nfsacl_ace *objp) -{ - if (!zdr_nfsacl_type (zdrs, &objp->type)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->id)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->perm)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETACL3args (ZDR *zdrs, GETACL3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->dir)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->mask)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETACL3resok (ZDR *zdrs, GETACL3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->attr)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->mask)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->ace_count)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->ace.ace_val, (u_int *) &objp->ace.ace_len, ~0, - sizeof (nfsacl_ace), (zdrproc_t) zdr_nfsacl_ace)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->default_ace_count)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->default_ace.default_ace_val, (u_int *) &objp->default_ace.default_ace_len, ~0, - sizeof (nfsacl_ace), (zdrproc_t) zdr_nfsacl_ace)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETACL3res (ZDR *zdrs, GETACL3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_GETACL3resok (zdrs, &objp->GETACL3res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_SETACL3args (ZDR *zdrs, SETACL3args *objp) -{ - if (!zdr_nfs_fh3 (zdrs, &objp->dir)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->mask)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->ace_count)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->ace.ace_val, (u_int *) &objp->ace.ace_len, ~0, - sizeof (nfsacl_ace), (zdrproc_t) zdr_nfsacl_ace)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->default_ace_count)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->default_ace.default_ace_val, (u_int *) &objp->default_ace.default_ace_len, ~0, - sizeof (nfsacl_ace), (zdrproc_t) zdr_nfsacl_ace)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETACL3resok (ZDR *zdrs, SETACL3resok *objp) -{ - if (!zdr_post_op_attr (zdrs, &objp->attr)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETACL3res (ZDR *zdrs, SETACL3res *objp) -{ - if (!zdr_nfsstat3 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!zdr_SETACL3resok (zdrs, &objp->SETACL3res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-raw-nfs4.c b/source/liborbisNfs/libnfs-raw-nfs4.c deleted file mode 100644 index 84f00da..0000000 --- a/source/liborbisNfs/libnfs-raw-nfs4.c +++ /dev/null @@ -1,3052 +0,0 @@ -/* This is based on RFC3530 which contains the following copyright statement: - - - Copyright (C) The Internet Society (2003). All Rights Reserved. - - This document and translations of it may be copied and furnished to - others, and derivative works that comment on or otherwise explain it - or assist in its implementation may be prepared, copied, published - and distributed, in whole or in part, without restriction of any - kind, provided that the above copyright notice and this paragraph are - included on all such copies and derivative works. However, this - document itself may not be modified in any way, such as by removing - the copyright notice or references to the Internet Society or other - Internet organizations, except as needed for the purpose of - developing Internet standards in which case the procedures for - copyrights defined in the Internet Standards process must be - followed, or as required to translate it into languages other than - English. - - The limited permissions granted above are perpetual and will not be - revoked by the Internet Society or its successors or assigns. - - This document and the information contained herein is provided on an - "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING - TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING - BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION - HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF - MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. -*/ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-nfs4.h" - -uint32_t -zdr_nfs_ftype4 (ZDR *zdrs, nfs_ftype4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfsstat4 (ZDR *zdrs, nfsstat4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_bitmap4 (ZDR *zdrs, bitmap4 *objp) -{ - - - if (!zdr_array (zdrs, (char **)&objp->bitmap4_val, (u_int *) &objp->bitmap4_len, ~0, - sizeof (uint32_t), (zdrproc_t) zdr_uint32_t)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_offset4 (ZDR *zdrs, offset4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_count4 (ZDR *zdrs, count4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_length4 (ZDR *zdrs, length4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_clientid4 (ZDR *zdrs, clientid4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_seqid4 (ZDR *zdrs, seqid4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_utf8string (ZDR *zdrs, utf8string *objp) -{ - - - if (!zdr_bytes (zdrs, (char **)&objp->utf8string_val, (u_int *) &objp->utf8string_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_utf8str_cis (ZDR *zdrs, utf8str_cis *objp) -{ - - - if (!zdr_utf8string (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_utf8str_cs (ZDR *zdrs, utf8str_cs *objp) -{ - - - if (!zdr_utf8string (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_utf8str_mixed (ZDR *zdrs, utf8str_mixed *objp) -{ - - - if (!zdr_utf8string (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_component4 (ZDR *zdrs, component4 *objp) -{ - - - if (!zdr_utf8str_cs (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pathname4 (ZDR *zdrs, pathname4 *objp) -{ - - - if (!zdr_array (zdrs, (char **)&objp->pathname4_val, (u_int *) &objp->pathname4_len, ~0, - sizeof (component4), (zdrproc_t) zdr_component4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_lockid4 (ZDR *zdrs, nfs_lockid4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_cookie4 (ZDR *zdrs, nfs_cookie4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_linktext4 (ZDR *zdrs, linktext4 *objp) -{ - - - if (!zdr_utf8str_cs (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_sec_oid4 (ZDR *zdrs, sec_oid4 *objp) -{ - - - if (!zdr_bytes (zdrs, (char **)&objp->sec_oid4_val, (u_int *) &objp->sec_oid4_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_qop4 (ZDR *zdrs, qop4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_mode4 (ZDR *zdrs, mode4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_changeid4 (ZDR *zdrs, changeid4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_verifier4 (ZDR *zdrs, verifier4 objp) -{ - - - if (!zdr_opaque (zdrs, objp, NFS4_VERIFIER_SIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfstime4 (ZDR *zdrs, nfstime4 *objp) -{ - - - if (!zdr_int64_t (zdrs, &objp->seconds)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->nseconds)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_time_how4 (ZDR *zdrs, time_how4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_settime4 (ZDR *zdrs, settime4 *objp) -{ - - - if (!zdr_time_how4 (zdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME4: - if (!zdr_nfstime4 (zdrs, &objp->settime4_u.time)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_nfs_fh4 (ZDR *zdrs, nfs_fh4 *objp) -{ - - - if (!zdr_bytes (zdrs, (char **)&objp->nfs_fh4_val, (u_int *) &objp->nfs_fh4_len, NFS4_FHSIZE)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fsid4 (ZDR *zdrs, fsid4 *objp) -{ - - - if (!zdr_uint64_t (zdrs, &objp->major)) - return FALSE; - if (!zdr_uint64_t (zdrs, &objp->minor)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fs_location4 (ZDR *zdrs, fs_location4 *objp) -{ - - - if (!zdr_array (zdrs, (char **)&objp->server.server_val, (u_int *) &objp->server.server_len, ~0, - sizeof (utf8str_cis), (zdrproc_t) zdr_utf8str_cis)) - return FALSE; - if (!zdr_pathname4 (zdrs, &objp->rootpath)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fs_locations4 (ZDR *zdrs, fs_locations4 *objp) -{ - - - if (!zdr_pathname4 (zdrs, &objp->fs_root)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->locations.locations_val, (u_int *) &objp->locations.locations_len, ~0, - sizeof (fs_location4), (zdrproc_t) zdr_fs_location4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_acetype4 (ZDR *zdrs, acetype4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_aceflag4 (ZDR *zdrs, aceflag4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_acemask4 (ZDR *zdrs, acemask4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfsace4 (ZDR *zdrs, nfsace4 *objp) -{ - - - if (!zdr_acetype4 (zdrs, &objp->type)) - return FALSE; - if (!zdr_aceflag4 (zdrs, &objp->flag)) - return FALSE; - if (!zdr_acemask4 (zdrs, &objp->access_mask)) - return FALSE; - if (!zdr_utf8str_mixed (zdrs, &objp->who)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_specdata4 (ZDR *zdrs, specdata4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, &objp->specdata1)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->specdata2)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_supported_attrs (ZDR *zdrs, fattr4_supported_attrs *objp) -{ - - - if (!zdr_bitmap4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_type (ZDR *zdrs, fattr4_type *objp) -{ - - - if (!zdr_nfs_ftype4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_fh_expire_type (ZDR *zdrs, fattr4_fh_expire_type *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_change (ZDR *zdrs, fattr4_change *objp) -{ - - - if (!zdr_changeid4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_size (ZDR *zdrs, fattr4_size *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_link_support (ZDR *zdrs, fattr4_link_support *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_symlink_support (ZDR *zdrs, fattr4_symlink_support *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_named_attr (ZDR *zdrs, fattr4_named_attr *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_fsid (ZDR *zdrs, fattr4_fsid *objp) -{ - - - if (!zdr_fsid4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_unique_handles (ZDR *zdrs, fattr4_unique_handles *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_lease_time (ZDR *zdrs, fattr4_lease_time *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_rdattr_error (ZDR *zdrs, fattr4_rdattr_error *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_acl (ZDR *zdrs, fattr4_acl *objp) -{ - - - if (!zdr_array (zdrs, (char **)&objp->fattr4_acl_val, (u_int *) &objp->fattr4_acl_len, ~0, - sizeof (nfsace4), (zdrproc_t) zdr_nfsace4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_aclsupport (ZDR *zdrs, fattr4_aclsupport *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_archive (ZDR *zdrs, fattr4_archive *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_cansettime (ZDR *zdrs, fattr4_cansettime *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_case_insensitive (ZDR *zdrs, fattr4_case_insensitive *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_case_preserving (ZDR *zdrs, fattr4_case_preserving *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_chown_restricted (ZDR *zdrs, fattr4_chown_restricted *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_fileid (ZDR *zdrs, fattr4_fileid *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_files_avail (ZDR *zdrs, fattr4_files_avail *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_filehandle (ZDR *zdrs, fattr4_filehandle *objp) -{ - - - if (!zdr_nfs_fh4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_files_free (ZDR *zdrs, fattr4_files_free *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_files_total (ZDR *zdrs, fattr4_files_total *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_fs_locations (ZDR *zdrs, fattr4_fs_locations *objp) -{ - - - if (!zdr_fs_locations4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_hidden (ZDR *zdrs, fattr4_hidden *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_homogeneous (ZDR *zdrs, fattr4_homogeneous *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_maxfilesize (ZDR *zdrs, fattr4_maxfilesize *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_maxlink (ZDR *zdrs, fattr4_maxlink *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_maxname (ZDR *zdrs, fattr4_maxname *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_maxread (ZDR *zdrs, fattr4_maxread *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_maxwrite (ZDR *zdrs, fattr4_maxwrite *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_mimetype (ZDR *zdrs, fattr4_mimetype *objp) -{ - - - if (!zdr_utf8str_cs (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_mode (ZDR *zdrs, fattr4_mode *objp) -{ - - - if (!zdr_mode4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_mounted_on_fileid (ZDR *zdrs, fattr4_mounted_on_fileid *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_no_trunc (ZDR *zdrs, fattr4_no_trunc *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_numlinks (ZDR *zdrs, fattr4_numlinks *objp) -{ - - - if (!zdr_uint32_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_owner (ZDR *zdrs, fattr4_owner *objp) -{ - - - if (!zdr_utf8str_mixed (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_owner_group (ZDR *zdrs, fattr4_owner_group *objp) -{ - - - if (!zdr_utf8str_mixed (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_quota_avail_hard (ZDR *zdrs, fattr4_quota_avail_hard *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_quota_avail_soft (ZDR *zdrs, fattr4_quota_avail_soft *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_quota_used (ZDR *zdrs, fattr4_quota_used *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_rawdev (ZDR *zdrs, fattr4_rawdev *objp) -{ - - - if (!zdr_specdata4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_space_avail (ZDR *zdrs, fattr4_space_avail *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_space_free (ZDR *zdrs, fattr4_space_free *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_space_total (ZDR *zdrs, fattr4_space_total *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_space_used (ZDR *zdrs, fattr4_space_used *objp) -{ - - - if (!zdr_uint64_t (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_system (ZDR *zdrs, fattr4_system *objp) -{ - - - if (!zdr_bool (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_access (ZDR *zdrs, fattr4_time_access *objp) -{ - - - if (!zdr_nfstime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_access_set (ZDR *zdrs, fattr4_time_access_set *objp) -{ - - - if (!zdr_settime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_backup (ZDR *zdrs, fattr4_time_backup *objp) -{ - - - if (!zdr_nfstime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_create (ZDR *zdrs, fattr4_time_create *objp) -{ - - - if (!zdr_nfstime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_delta (ZDR *zdrs, fattr4_time_delta *objp) -{ - - - if (!zdr_nfstime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_metadata (ZDR *zdrs, fattr4_time_metadata *objp) -{ - - - if (!zdr_nfstime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_modify (ZDR *zdrs, fattr4_time_modify *objp) -{ - - - if (!zdr_nfstime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4_time_modify_set (ZDR *zdrs, fattr4_time_modify_set *objp) -{ - - - if (!zdr_settime4 (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_attrlist4 (ZDR *zdrs, attrlist4 *objp) -{ - - - if (!zdr_bytes (zdrs, (char **)&objp->attrlist4_val, (u_int *) &objp->attrlist4_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_fattr4 (ZDR *zdrs, fattr4 *objp) -{ - - - if (!zdr_bitmap4 (zdrs, &objp->attrmask)) - return FALSE; - if (!zdr_attrlist4 (zdrs, &objp->attr_vals)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_change_info4 (ZDR *zdrs, change_info4 *objp) -{ - - - if (!zdr_bool (zdrs, &objp->atomic)) - return FALSE; - if (!zdr_changeid4 (zdrs, &objp->before)) - return FALSE; - if (!zdr_changeid4 (zdrs, &objp->after)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_clientaddr4 (ZDR *zdrs, clientaddr4 *objp) -{ - - - if (!zdr_string (zdrs, &objp->r_netid, ~0)) - return FALSE; - if (!zdr_string (zdrs, &objp->r_addr, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_cb_client4 (ZDR *zdrs, cb_client4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, &objp->cb_program)) - return FALSE; - if (!zdr_clientaddr4 (zdrs, &objp->cb_location)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_stateid4 (ZDR *zdrs, stateid4 *objp) -{ - - - - if (!zdr_uint32_t (zdrs, &objp->seqid)) - return FALSE; - if (!zdr_opaque (zdrs, objp->other, 12)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_client_id4 (ZDR *zdrs, nfs_client_id4 *objp) -{ - - - if (!zdr_verifier4 (zdrs, objp->verifier)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->id.id_val, (u_int *) &objp->id.id_len, NFS4_OPAQUE_LIMIT)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_owner4 (ZDR *zdrs, open_owner4 *objp) -{ - - - if (!zdr_clientid4 (zdrs, &objp->clientid)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->owner.owner_val, (u_int *) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_lock_owner4 (ZDR *zdrs, lock_owner4 *objp) -{ - - - if (!zdr_clientid4 (zdrs, &objp->clientid)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->owner.owner_val, (u_int *) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_lock_type4 (ZDR *zdrs, nfs_lock_type4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ACCESS4args (ZDR *zdrs, ACCESS4args *objp) -{ - - - if (!zdr_uint32_t (zdrs, &objp->access)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ACCESS4resok (ZDR *zdrs, ACCESS4resok *objp) -{ - - - if (!zdr_uint32_t (zdrs, &objp->supported)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->access)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ACCESS4res (ZDR *zdrs, ACCESS4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_ACCESS4resok (zdrs, &objp->ACCESS4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_CLOSE4args (ZDR *zdrs, CLOSE4args *objp) -{ - - - if (!zdr_seqid4 (zdrs, &objp->seqid)) - return FALSE; - if (!zdr_stateid4 (zdrs, &objp->open_stateid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CLOSE4res (ZDR *zdrs, CLOSE4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_stateid4 (zdrs, &objp->CLOSE4res_u.open_stateid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_COMMIT4args (ZDR *zdrs, COMMIT4args *objp) -{ - - - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_count4 (zdrs, &objp->count)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_COMMIT4resok (ZDR *zdrs, COMMIT4resok *objp) -{ - - - if (!zdr_verifier4 (zdrs, objp->writeverf)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_COMMIT4res (ZDR *zdrs, COMMIT4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_COMMIT4resok (zdrs, &objp->COMMIT4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_createtype4 (ZDR *zdrs, createtype4 *objp) -{ - - - if (!zdr_nfs_ftype4 (zdrs, &objp->type)) - return FALSE; - switch (objp->type) { - case NF4LNK: - if (!zdr_linktext4 (zdrs, &objp->createtype4_u.linkdata)) - return FALSE; - break; - case NF4BLK: - case NF4CHR: - if (!zdr_specdata4 (zdrs, &objp->createtype4_u.devdata)) - return FALSE; - break; - case NF4SOCK: - case NF4FIFO: - case NF4DIR: - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_CREATE4args (ZDR *zdrs, CREATE4args *objp) -{ - - - if (!zdr_createtype4 (zdrs, &objp->objtype)) - return FALSE; - if (!zdr_component4 (zdrs, &objp->objname)) - return FALSE; - if (!zdr_fattr4 (zdrs, &objp->createattrs)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CREATE4resok (ZDR *zdrs, CREATE4resok *objp) -{ - - - if (!zdr_change_info4 (zdrs, &objp->cinfo)) - return FALSE; - if (!zdr_bitmap4 (zdrs, &objp->attrset)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CREATE4res (ZDR *zdrs, CREATE4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_CREATE4resok (zdrs, &objp->CREATE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_DELEGPURGE4args (ZDR *zdrs, DELEGPURGE4args *objp) -{ - - - if (!zdr_clientid4 (zdrs, &objp->clientid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_DELEGPURGE4res (ZDR *zdrs, DELEGPURGE4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_DELEGRETURN4args (ZDR *zdrs, DELEGRETURN4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->deleg_stateid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_DELEGRETURN4res (ZDR *zdrs, DELEGRETURN4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR4args (ZDR *zdrs, GETATTR4args *objp) -{ - - - if (!zdr_bitmap4 (zdrs, &objp->attr_request)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR4resok (ZDR *zdrs, GETATTR4resok *objp) -{ - - - if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETATTR4res (ZDR *zdrs, GETATTR4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_GETATTR4resok (zdrs, &objp->GETATTR4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_GETFH4resok (ZDR *zdrs, GETFH4resok *objp) -{ - - - if (!zdr_nfs_fh4 (zdrs, &objp->object)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETFH4res (ZDR *zdrs, GETFH4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_GETFH4resok (zdrs, &objp->GETFH4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_LINK4args (ZDR *zdrs, LINK4args *objp) -{ - - - if (!zdr_component4 (zdrs, &objp->newname)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK4resok (ZDR *zdrs, LINK4resok *objp) -{ - - - if (!zdr_change_info4 (zdrs, &objp->cinfo)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LINK4res (ZDR *zdrs, LINK4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_LINK4resok (zdrs, &objp->LINK4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_open_to_lock_owner4 (ZDR *zdrs, open_to_lock_owner4 *objp) -{ - - - if (!zdr_seqid4 (zdrs, &objp->open_seqid)) - return FALSE; - if (!zdr_stateid4 (zdrs, &objp->open_stateid)) - return FALSE; - if (!zdr_seqid4 (zdrs, &objp->lock_seqid)) - return FALSE; - if (!zdr_lock_owner4 (zdrs, &objp->lock_owner)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_exist_lock_owner4 (ZDR *zdrs, exist_lock_owner4 *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->lock_stateid)) - return FALSE; - if (!zdr_seqid4 (zdrs, &objp->lock_seqid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_locker4 (ZDR *zdrs, locker4 *objp) -{ - - - if (!zdr_bool (zdrs, &objp->new_lock_owner)) - return FALSE; - switch (objp->new_lock_owner) { - case TRUE: - if (!zdr_open_to_lock_owner4 (zdrs, &objp->locker4_u.open_owner)) - return FALSE; - break; - case FALSE: - if (!zdr_exist_lock_owner4 (zdrs, &objp->locker4_u.lock_owner)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_LOCK4args (ZDR *zdrs, LOCK4args *objp) -{ - - - if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) - return FALSE; - if (!zdr_bool (zdrs, &objp->reclaim)) - return FALSE; - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_length4 (zdrs, &objp->length)) - return FALSE; - if (!zdr_locker4 (zdrs, &objp->locker)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOCK4denied (ZDR *zdrs, LOCK4denied *objp) -{ - - - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_length4 (zdrs, &objp->length)) - return FALSE; - if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) - return FALSE; - if (!zdr_lock_owner4 (zdrs, &objp->owner)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOCK4resok (ZDR *zdrs, LOCK4resok *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->lock_stateid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOCK4res (ZDR *zdrs, LOCK4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_LOCK4resok (zdrs, &objp->LOCK4res_u.resok4)) - return FALSE; - break; - case NFS4ERR_DENIED: - if (!zdr_LOCK4denied (zdrs, &objp->LOCK4res_u.denied)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_LOCKT4args (ZDR *zdrs, LOCKT4args *objp) -{ - - - if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) - return FALSE; - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_length4 (zdrs, &objp->length)) - return FALSE; - if (!zdr_lock_owner4 (zdrs, &objp->owner)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOCKT4res (ZDR *zdrs, LOCKT4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4ERR_DENIED: - if (!zdr_LOCK4denied (zdrs, &objp->LOCKT4res_u.denied)) - return FALSE; - break; - case NFS4_OK: - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_LOCKU4args (ZDR *zdrs, LOCKU4args *objp) -{ - - - if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) - return FALSE; - if (!zdr_seqid4 (zdrs, &objp->seqid)) - return FALSE; - if (!zdr_stateid4 (zdrs, &objp->lock_stateid)) - return FALSE; - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_length4 (zdrs, &objp->length)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOCKU4res (ZDR *zdrs, LOCKU4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_stateid4 (zdrs, &objp->LOCKU4res_u.lock_stateid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_LOOKUP4args (ZDR *zdrs, LOOKUP4args *objp) -{ - - - if (!zdr_component4 (zdrs, &objp->objname)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUP4res (ZDR *zdrs, LOOKUP4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_LOOKUPP4res (ZDR *zdrs, LOOKUPP4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NVERIFY4args (ZDR *zdrs, NVERIFY4args *objp) -{ - - - if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NVERIFY4res (ZDR *zdrs, NVERIFY4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_createmode4 (ZDR *zdrs, createmode4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_createhow4 (ZDR *zdrs, createhow4 *objp) -{ - - - if (!zdr_createmode4 (zdrs, &objp->mode)) - return FALSE; - switch (objp->mode) { - case UNCHECKED4: - case GUARDED4: - if (!zdr_fattr4 (zdrs, &objp->createhow4_u.createattrs)) - return FALSE; - break; - case EXCLUSIVE4: - if (!zdr_verifier4 (zdrs, objp->createhow4_u.createverf)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_opentype4 (ZDR *zdrs, opentype4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_openflag4 (ZDR *zdrs, openflag4 *objp) -{ - - - if (!zdr_opentype4 (zdrs, &objp->opentype)) - return FALSE; - switch (objp->opentype) { - case OPEN4_CREATE: - if (!zdr_createhow4 (zdrs, &objp->openflag4_u.how)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_limit_by4 (ZDR *zdrs, limit_by4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_modified_limit4 (ZDR *zdrs, nfs_modified_limit4 *objp) -{ - - - if (!zdr_uint32_t (zdrs, &objp->num_blocks)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->bytes_per_block)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_space_limit4 (ZDR *zdrs, nfs_space_limit4 *objp) -{ - - - if (!zdr_limit_by4 (zdrs, &objp->limitby)) - return FALSE; - switch (objp->limitby) { - case NFS_LIMIT_SIZE: - if (!zdr_uint64_t (zdrs, &objp->nfs_space_limit4_u.filesize)) - return FALSE; - break; - case NFS_LIMIT_BLOCKS: - if (!zdr_nfs_modified_limit4 (zdrs, &objp->nfs_space_limit4_u.mod_blocks)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_open_delegation_type4 (ZDR *zdrs, open_delegation_type4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_claim_type4 (ZDR *zdrs, open_claim_type4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_claim_delegate_cur4 (ZDR *zdrs, open_claim_delegate_cur4 *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->delegate_stateid)) - return FALSE; - if (!zdr_component4 (zdrs, &objp->file)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_claim4 (ZDR *zdrs, open_claim4 *objp) -{ - - - if (!zdr_open_claim_type4 (zdrs, &objp->claim)) - return FALSE; - switch (objp->claim) { - case CLAIM_NULL: - if (!zdr_component4 (zdrs, &objp->open_claim4_u.file)) - return FALSE; - break; - case CLAIM_PREVIOUS: - if (!zdr_open_delegation_type4 (zdrs, &objp->open_claim4_u.delegate_type)) - return FALSE; - break; - case CLAIM_DELEGATE_CUR: - if (!zdr_open_claim_delegate_cur4 (zdrs, &objp->open_claim4_u.delegate_cur_info)) - return FALSE; - break; - case CLAIM_DELEGATE_PREV: - if (!zdr_component4 (zdrs, &objp->open_claim4_u.file_delegate_prev)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_OPEN4args (ZDR *zdrs, OPEN4args *objp) -{ - - - if (!zdr_seqid4 (zdrs, &objp->seqid)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->share_access)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->share_deny)) - return FALSE; - if (!zdr_open_owner4 (zdrs, &objp->owner)) - return FALSE; - if (!zdr_openflag4 (zdrs, &objp->openhow)) - return FALSE; - if (!zdr_open_claim4 (zdrs, &objp->claim)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_read_delegation4 (ZDR *zdrs, open_read_delegation4 *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_bool (zdrs, &objp->recall)) - return FALSE; - if (!zdr_nfsace4 (zdrs, &objp->permissions)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_write_delegation4 (ZDR *zdrs, open_write_delegation4 *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_bool (zdrs, &objp->recall)) - return FALSE; - if (!zdr_nfs_space_limit4 (zdrs, &objp->space_limit)) - return FALSE; - if (!zdr_nfsace4 (zdrs, &objp->permissions)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_open_delegation4 (ZDR *zdrs, open_delegation4 *objp) -{ - - - if (!zdr_open_delegation_type4 (zdrs, &objp->delegation_type)) - return FALSE; - switch (objp->delegation_type) { - case OPEN_DELEGATE_NONE: - break; - case OPEN_DELEGATE_READ: - if (!zdr_open_read_delegation4 (zdrs, &objp->open_delegation4_u.read)) - return FALSE; - break; - case OPEN_DELEGATE_WRITE: - if (!zdr_open_write_delegation4 (zdrs, &objp->open_delegation4_u.write)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_OPEN4resok (ZDR *zdrs, OPEN4resok *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_change_info4 (zdrs, &objp->cinfo)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->rflags)) - return FALSE; - if (!zdr_bitmap4 (zdrs, &objp->attrset)) - return FALSE; - if (!zdr_open_delegation4 (zdrs, &objp->delegation)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPEN4res (ZDR *zdrs, OPEN4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_OPEN4resok (zdrs, &objp->OPEN4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_OPENATTR4args (ZDR *zdrs, OPENATTR4args *objp) -{ - - - if (!zdr_bool (zdrs, &objp->createdir)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPENATTR4res (ZDR *zdrs, OPENATTR4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPEN_CONFIRM4args (ZDR *zdrs, OPEN_CONFIRM4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->open_stateid)) - return FALSE; - if (!zdr_seqid4 (zdrs, &objp->seqid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPEN_CONFIRM4resok (ZDR *zdrs, OPEN_CONFIRM4resok *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->open_stateid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPEN_CONFIRM4res (ZDR *zdrs, OPEN_CONFIRM4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_OPEN_CONFIRM4resok (zdrs, &objp->OPEN_CONFIRM4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_OPEN_DOWNGRADE4args (ZDR *zdrs, OPEN_DOWNGRADE4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->open_stateid)) - return FALSE; - if (!zdr_seqid4 (zdrs, &objp->seqid)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->share_access)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->share_deny)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPEN_DOWNGRADE4resok (ZDR *zdrs, OPEN_DOWNGRADE4resok *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->open_stateid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_OPEN_DOWNGRADE4res (ZDR *zdrs, OPEN_DOWNGRADE4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_OPEN_DOWNGRADE4resok (zdrs, &objp->OPEN_DOWNGRADE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_PUTFH4args (ZDR *zdrs, PUTFH4args *objp) -{ - - - if (!zdr_nfs_fh4 (zdrs, &objp->object)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PUTFH4res (ZDR *zdrs, PUTFH4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PUTPUBFH4res (ZDR *zdrs, PUTPUBFH4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PUTROOTFH4res (ZDR *zdrs, PUTROOTFH4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ4args (ZDR *zdrs, READ4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_count4 (zdrs, &objp->count)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ4resok (ZDR *zdrs, READ4resok *objp) -{ - - - if (!zdr_bool (zdrs, &objp->eof)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READ4res (ZDR *zdrs, READ4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_READ4resok (zdrs, &objp->READ4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_READDIR4args (ZDR *zdrs, READDIR4args *objp) -{ - - - if (!zdr_nfs_cookie4 (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_verifier4 (zdrs, objp->cookieverf)) - return FALSE; - if (!zdr_count4 (zdrs, &objp->dircount)) - return FALSE; - if (!zdr_count4 (zdrs, &objp->maxcount)) - return FALSE; - if (!zdr_bitmap4 (zdrs, &objp->attr_request)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_entry4 (ZDR *zdrs, entry4 *objp) -{ - - - if (!zdr_nfs_cookie4 (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_component4 (zdrs, &objp->name)) - return FALSE; - if (!zdr_fattr4 (zdrs, &objp->attrs)) - return FALSE; - if (!zdr_pointer (zdrs, (char **)&objp->nextentry, sizeof (entry4), (zdrproc_t) zdr_entry4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_dirlist4 (ZDR *zdrs, dirlist4 *objp) -{ - - - if (!zdr_pointer (zdrs, (char **)&objp->entries, sizeof (entry4), (zdrproc_t) zdr_entry4)) - return FALSE; - if (!zdr_bool (zdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR4resok (ZDR *zdrs, READDIR4resok *objp) -{ - - - if (!zdr_verifier4 (zdrs, objp->cookieverf)) - return FALSE; - if (!zdr_dirlist4 (zdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READDIR4res (ZDR *zdrs, READDIR4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_READDIR4resok (zdrs, &objp->READDIR4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_READLINK4resok (ZDR *zdrs, READLINK4resok *objp) -{ - - - if (!zdr_linktext4 (zdrs, &objp->link)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_READLINK4res (ZDR *zdrs, READLINK4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_READLINK4resok (zdrs, &objp->READLINK4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_REMOVE4args (ZDR *zdrs, REMOVE4args *objp) -{ - - - if (!zdr_component4 (zdrs, &objp->target)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_REMOVE4resok (ZDR *zdrs, REMOVE4resok *objp) -{ - - - if (!zdr_change_info4 (zdrs, &objp->cinfo)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_REMOVE4res (ZDR *zdrs, REMOVE4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_REMOVE4resok (zdrs, &objp->REMOVE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_RENAME4args (ZDR *zdrs, RENAME4args *objp) -{ - - - if (!zdr_component4 (zdrs, &objp->oldname)) - return FALSE; - if (!zdr_component4 (zdrs, &objp->newname)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME4resok (ZDR *zdrs, RENAME4resok *objp) -{ - - - if (!zdr_change_info4 (zdrs, &objp->source_cinfo)) - return FALSE; - if (!zdr_change_info4 (zdrs, &objp->target_cinfo)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENAME4res (ZDR *zdrs, RENAME4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_RENAME4resok (zdrs, &objp->RENAME4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_RENEW4args (ZDR *zdrs, RENEW4args *objp) -{ - - - if (!zdr_clientid4 (zdrs, &objp->clientid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RENEW4res (ZDR *zdrs, RENEW4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RESTOREFH4res (ZDR *zdrs, RESTOREFH4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SAVEFH4res (ZDR *zdrs, SAVEFH4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR4args (ZDR *zdrs, SETATTR4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETATTR4res (ZDR *zdrs, SETATTR4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - if (!zdr_bitmap4 (zdrs, &objp->attrsset)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETCLIENTID4args (ZDR *zdrs, SETCLIENTID4args *objp) -{ - - - if (!zdr_nfs_client_id4 (zdrs, &objp->client)) - return FALSE; - if (!zdr_cb_client4 (zdrs, &objp->callback)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->callback_ident)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETCLIENTID4resok (ZDR *zdrs, SETCLIENTID4resok *objp) -{ - - - if (!zdr_clientid4 (zdrs, &objp->clientid)) - return FALSE; - if (!zdr_verifier4 (zdrs, objp->setclientid_confirm)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETCLIENTID4res (ZDR *zdrs, SETCLIENTID4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_SETCLIENTID4resok (zdrs, &objp->SETCLIENTID4res_u.resok4)) - return FALSE; - break; - case NFS4ERR_CLID_INUSE: - if (!zdr_clientaddr4 (zdrs, &objp->SETCLIENTID4res_u.client_using)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_SETCLIENTID_CONFIRM4args (ZDR *zdrs, SETCLIENTID_CONFIRM4args *objp) -{ - - - if (!zdr_clientid4 (zdrs, &objp->clientid)) - return FALSE; - if (!zdr_verifier4 (zdrs, objp->setclientid_confirm)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_SETCLIENTID_CONFIRM4res (ZDR *zdrs, SETCLIENTID_CONFIRM4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_VERIFY4args (ZDR *zdrs, VERIFY4args *objp) -{ - - - if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_VERIFY4res (ZDR *zdrs, VERIFY4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_stable_how4 (ZDR *zdrs, stable_how4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE4args (ZDR *zdrs, WRITE4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_offset4 (zdrs, &objp->offset)) - return FALSE; - if (!zdr_stable_how4 (zdrs, &objp->stable)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE4resok (ZDR *zdrs, WRITE4resok *objp) -{ - - - if (!zdr_count4 (zdrs, &objp->count)) - return FALSE; - if (!zdr_stable_how4 (zdrs, &objp->committed)) - return FALSE; - if (!zdr_verifier4 (zdrs, objp->writeverf)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_WRITE4res (ZDR *zdrs, WRITE4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_WRITE4resok (zdrs, &objp->WRITE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_RELEASE_LOCKOWNER4args (ZDR *zdrs, RELEASE_LOCKOWNER4args *objp) -{ - - - if (!zdr_lock_owner4 (zdrs, &objp->lock_owner)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_RELEASE_LOCKOWNER4res (ZDR *zdrs, RELEASE_LOCKOWNER4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_ILLEGAL4res (ZDR *zdrs, ILLEGAL4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_opnum4 (ZDR *zdrs, nfs_opnum4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_argop4 (ZDR *zdrs, nfs_argop4 *objp) -{ - - - if (!zdr_nfs_opnum4 (zdrs, &objp->argop)) - return FALSE; - switch (objp->argop) { - case OP_ACCESS: - if (!zdr_ACCESS4args (zdrs, &objp->nfs_argop4_u.opaccess)) - return FALSE; - break; - case OP_CLOSE: - if (!zdr_CLOSE4args (zdrs, &objp->nfs_argop4_u.opclose)) - return FALSE; - break; - case OP_COMMIT: - if (!zdr_COMMIT4args (zdrs, &objp->nfs_argop4_u.opcommit)) - return FALSE; - break; - case OP_CREATE: - if (!zdr_CREATE4args (zdrs, &objp->nfs_argop4_u.opcreate)) - return FALSE; - break; - case OP_DELEGPURGE: - if (!zdr_DELEGPURGE4args (zdrs, &objp->nfs_argop4_u.opdelegpurge)) - return FALSE; - break; - case OP_DELEGRETURN: - if (!zdr_DELEGRETURN4args (zdrs, &objp->nfs_argop4_u.opdelegreturn)) - return FALSE; - break; - case OP_GETATTR: - if (!zdr_GETATTR4args (zdrs, &objp->nfs_argop4_u.opgetattr)) - return FALSE; - break; - case OP_GETFH: - break; - case OP_LINK: - if (!zdr_LINK4args (zdrs, &objp->nfs_argop4_u.oplink)) - return FALSE; - break; - case OP_LOCK: - if (!zdr_LOCK4args (zdrs, &objp->nfs_argop4_u.oplock)) - return FALSE; - break; - case OP_LOCKT: - if (!zdr_LOCKT4args (zdrs, &objp->nfs_argop4_u.oplockt)) - return FALSE; - break; - case OP_LOCKU: - if (!zdr_LOCKU4args (zdrs, &objp->nfs_argop4_u.oplocku)) - return FALSE; - break; - case OP_LOOKUP: - if (!zdr_LOOKUP4args (zdrs, &objp->nfs_argop4_u.oplookup)) - return FALSE; - break; - case OP_LOOKUPP: - break; - case OP_NVERIFY: - if (!zdr_NVERIFY4args (zdrs, &objp->nfs_argop4_u.opnverify)) - return FALSE; - break; - case OP_OPEN: - if (!zdr_OPEN4args (zdrs, &objp->nfs_argop4_u.opopen)) - return FALSE; - break; - case OP_OPENATTR: - if (!zdr_OPENATTR4args (zdrs, &objp->nfs_argop4_u.opopenattr)) - return FALSE; - break; - case OP_OPEN_CONFIRM: - if (!zdr_OPEN_CONFIRM4args (zdrs, &objp->nfs_argop4_u.opopen_confirm)) - return FALSE; - break; - case OP_OPEN_DOWNGRADE: - if (!zdr_OPEN_DOWNGRADE4args (zdrs, &objp->nfs_argop4_u.opopen_downgrade)) - return FALSE; - break; - case OP_PUTFH: - if (!zdr_PUTFH4args (zdrs, &objp->nfs_argop4_u.opputfh)) - return FALSE; - break; - case OP_PUTPUBFH: - break; - case OP_PUTROOTFH: - break; - case OP_READ: - if (!zdr_READ4args (zdrs, &objp->nfs_argop4_u.opread)) - return FALSE; - break; - case OP_READDIR: - if (!zdr_READDIR4args (zdrs, &objp->nfs_argop4_u.opreaddir)) - return FALSE; - break; - case OP_READLINK: - break; - case OP_REMOVE: - if (!zdr_REMOVE4args (zdrs, &objp->nfs_argop4_u.opremove)) - return FALSE; - break; - case OP_RENAME: - if (!zdr_RENAME4args (zdrs, &objp->nfs_argop4_u.oprename)) - return FALSE; - break; - case OP_RENEW: - if (!zdr_RENEW4args (zdrs, &objp->nfs_argop4_u.oprenew)) - return FALSE; - break; - case OP_RESTOREFH: - break; - case OP_SAVEFH: - break; - case OP_SETATTR: - if (!zdr_SETATTR4args (zdrs, &objp->nfs_argop4_u.opsetattr)) - return FALSE; - break; - case OP_SETCLIENTID: - if (!zdr_SETCLIENTID4args (zdrs, &objp->nfs_argop4_u.opsetclientid)) - return FALSE; - break; - case OP_SETCLIENTID_CONFIRM: - if (!zdr_SETCLIENTID_CONFIRM4args (zdrs, &objp->nfs_argop4_u.opsetclientid_confirm)) - return FALSE; - break; - case OP_VERIFY: - if (!zdr_VERIFY4args (zdrs, &objp->nfs_argop4_u.opverify)) - return FALSE; - break; - case OP_WRITE: - if (!zdr_WRITE4args (zdrs, &objp->nfs_argop4_u.opwrite)) - return FALSE; - break; - case OP_RELEASE_LOCKOWNER: - if (!zdr_RELEASE_LOCKOWNER4args (zdrs, &objp->nfs_argop4_u.oprelease_lockowner)) - return FALSE; - break; - case OP_ILLEGAL: - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_nfs_resop4 (ZDR *zdrs, nfs_resop4 *objp) -{ - - - if (!zdr_nfs_opnum4 (zdrs, &objp->resop)) - return FALSE; - switch (objp->resop) { - case OP_ACCESS: - if (!zdr_ACCESS4res (zdrs, &objp->nfs_resop4_u.opaccess)) - return FALSE; - break; - case OP_CLOSE: - if (!zdr_CLOSE4res (zdrs, &objp->nfs_resop4_u.opclose)) - return FALSE; - break; - case OP_COMMIT: - if (!zdr_COMMIT4res (zdrs, &objp->nfs_resop4_u.opcommit)) - return FALSE; - break; - case OP_CREATE: - if (!zdr_CREATE4res (zdrs, &objp->nfs_resop4_u.opcreate)) - return FALSE; - break; - case OP_DELEGPURGE: - if (!zdr_DELEGPURGE4res (zdrs, &objp->nfs_resop4_u.opdelegpurge)) - return FALSE; - break; - case OP_DELEGRETURN: - if (!zdr_DELEGRETURN4res (zdrs, &objp->nfs_resop4_u.opdelegreturn)) - return FALSE; - break; - case OP_GETATTR: - if (!zdr_GETATTR4res (zdrs, &objp->nfs_resop4_u.opgetattr)) - return FALSE; - break; - case OP_GETFH: - if (!zdr_GETFH4res (zdrs, &objp->nfs_resop4_u.opgetfh)) - return FALSE; - break; - case OP_LINK: - if (!zdr_LINK4res (zdrs, &objp->nfs_resop4_u.oplink)) - return FALSE; - break; - case OP_LOCK: - if (!zdr_LOCK4res (zdrs, &objp->nfs_resop4_u.oplock)) - return FALSE; - break; - case OP_LOCKT: - if (!zdr_LOCKT4res (zdrs, &objp->nfs_resop4_u.oplockt)) - return FALSE; - break; - case OP_LOCKU: - if (!zdr_LOCKU4res (zdrs, &objp->nfs_resop4_u.oplocku)) - return FALSE; - break; - case OP_LOOKUP: - if (!zdr_LOOKUP4res (zdrs, &objp->nfs_resop4_u.oplookup)) - return FALSE; - break; - case OP_LOOKUPP: - if (!zdr_LOOKUPP4res (zdrs, &objp->nfs_resop4_u.oplookupp)) - return FALSE; - break; - case OP_NVERIFY: - if (!zdr_NVERIFY4res (zdrs, &objp->nfs_resop4_u.opnverify)) - return FALSE; - break; - case OP_OPEN: - if (!zdr_OPEN4res (zdrs, &objp->nfs_resop4_u.opopen)) - return FALSE; - break; - case OP_OPENATTR: - if (!zdr_OPENATTR4res (zdrs, &objp->nfs_resop4_u.opopenattr)) - return FALSE; - break; - case OP_OPEN_CONFIRM: - if (!zdr_OPEN_CONFIRM4res (zdrs, &objp->nfs_resop4_u.opopen_confirm)) - return FALSE; - break; - case OP_OPEN_DOWNGRADE: - if (!zdr_OPEN_DOWNGRADE4res (zdrs, &objp->nfs_resop4_u.opopen_downgrade)) - return FALSE; - break; - case OP_PUTFH: - if (!zdr_PUTFH4res (zdrs, &objp->nfs_resop4_u.opputfh)) - return FALSE; - break; - case OP_PUTPUBFH: - if (!zdr_PUTPUBFH4res (zdrs, &objp->nfs_resop4_u.opputpubfh)) - return FALSE; - break; - case OP_PUTROOTFH: - if (!zdr_PUTROOTFH4res (zdrs, &objp->nfs_resop4_u.opputrootfh)) - return FALSE; - break; - case OP_READ: - if (!zdr_READ4res (zdrs, &objp->nfs_resop4_u.opread)) - return FALSE; - break; - case OP_READDIR: - if (!zdr_READDIR4res (zdrs, &objp->nfs_resop4_u.opreaddir)) - return FALSE; - break; - case OP_READLINK: - if (!zdr_READLINK4res (zdrs, &objp->nfs_resop4_u.opreadlink)) - return FALSE; - break; - case OP_REMOVE: - if (!zdr_REMOVE4res (zdrs, &objp->nfs_resop4_u.opremove)) - return FALSE; - break; - case OP_RENAME: - if (!zdr_RENAME4res (zdrs, &objp->nfs_resop4_u.oprename)) - return FALSE; - break; - case OP_RENEW: - if (!zdr_RENEW4res (zdrs, &objp->nfs_resop4_u.oprenew)) - return FALSE; - break; - case OP_RESTOREFH: - if (!zdr_RESTOREFH4res (zdrs, &objp->nfs_resop4_u.oprestorefh)) - return FALSE; - break; - case OP_SAVEFH: - if (!zdr_SAVEFH4res (zdrs, &objp->nfs_resop4_u.opsavefh)) - return FALSE; - break; - case OP_SETATTR: - if (!zdr_SETATTR4res (zdrs, &objp->nfs_resop4_u.opsetattr)) - return FALSE; - break; - case OP_SETCLIENTID: - if (!zdr_SETCLIENTID4res (zdrs, &objp->nfs_resop4_u.opsetclientid)) - return FALSE; - break; - case OP_SETCLIENTID_CONFIRM: - if (!zdr_SETCLIENTID_CONFIRM4res (zdrs, &objp->nfs_resop4_u.opsetclientid_confirm)) - return FALSE; - break; - case OP_VERIFY: - if (!zdr_VERIFY4res (zdrs, &objp->nfs_resop4_u.opverify)) - return FALSE; - break; - case OP_WRITE: - if (!zdr_WRITE4res (zdrs, &objp->nfs_resop4_u.opwrite)) - return FALSE; - break; - case OP_RELEASE_LOCKOWNER: - if (!zdr_RELEASE_LOCKOWNER4res (zdrs, &objp->nfs_resop4_u.oprelease_lockowner)) - return FALSE; - break; - case OP_ILLEGAL: - if (!zdr_ILLEGAL4res (zdrs, &objp->nfs_resop4_u.opillegal)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_COMPOUND4args (ZDR *zdrs, COMPOUND4args *objp) -{ - - - if (!zdr_utf8str_cs (zdrs, &objp->tag)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->minorversion)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->argarray.argarray_val, (u_int *) &objp->argarray.argarray_len, ~0, - sizeof (nfs_argop4), (zdrproc_t) zdr_nfs_argop4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_COMPOUND4res (ZDR *zdrs, COMPOUND4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - if (!zdr_utf8str_cs (zdrs, &objp->tag)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->resarray.resarray_val, (u_int *) &objp->resarray.resarray_len, ~0, - sizeof (nfs_resop4), (zdrproc_t) zdr_nfs_resop4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CB_GETATTR4args (ZDR *zdrs, CB_GETATTR4args *objp) -{ - - - if (!zdr_nfs_fh4 (zdrs, &objp->fh)) - return FALSE; - if (!zdr_bitmap4 (zdrs, &objp->attr_request)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CB_GETATTR4resok (ZDR *zdrs, CB_GETATTR4resok *objp) -{ - - - if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CB_GETATTR4res (ZDR *zdrs, CB_GETATTR4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!zdr_CB_GETATTR4resok (zdrs, &objp->CB_GETATTR4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_CB_RECALL4args (ZDR *zdrs, CB_RECALL4args *objp) -{ - - - if (!zdr_stateid4 (zdrs, &objp->stateid)) - return FALSE; - if (!zdr_bool (zdrs, &objp->truncate)) - return FALSE; - if (!zdr_nfs_fh4 (zdrs, &objp->fh)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CB_RECALL4res (ZDR *zdrs, CB_RECALL4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CB_ILLEGAL4res (ZDR *zdrs, CB_ILLEGAL4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_cb_opnum4 (ZDR *zdrs, nfs_cb_opnum4 *objp) -{ - - - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nfs_cb_argop4 (ZDR *zdrs, nfs_cb_argop4 *objp) -{ - - - if (!zdr_u_int (zdrs, &objp->argop)) - return FALSE; - switch (objp->argop) { - case OP_CB_GETATTR: - if (!zdr_CB_GETATTR4args (zdrs, &objp->nfs_cb_argop4_u.opcbgetattr)) - return FALSE; - break; - case OP_CB_RECALL: - if (!zdr_CB_RECALL4args (zdrs, &objp->nfs_cb_argop4_u.opcbrecall)) - return FALSE; - break; - case OP_CB_ILLEGAL: - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_nfs_cb_resop4 (ZDR *zdrs, nfs_cb_resop4 *objp) -{ - - - if (!zdr_u_int (zdrs, &objp->resop)) - return FALSE; - switch (objp->resop) { - case OP_CB_GETATTR: - if (!zdr_CB_GETATTR4res (zdrs, &objp->nfs_cb_resop4_u.opcbgetattr)) - return FALSE; - break; - case OP_CB_RECALL: - if (!zdr_CB_RECALL4res (zdrs, &objp->nfs_cb_resop4_u.opcbrecall)) - return FALSE; - break; - case OP_CB_ILLEGAL: - if (!zdr_CB_ILLEGAL4res (zdrs, &objp->nfs_cb_resop4_u.opcbillegal)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -uint32_t -zdr_CB_COMPOUND4args (ZDR *zdrs, CB_COMPOUND4args *objp) -{ - - - if (!zdr_utf8str_cs (zdrs, &objp->tag)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->minorversion)) - return FALSE; - if (!zdr_uint32_t (zdrs, &objp->callback_ident)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->argarray.argarray_val, (u_int *) &objp->argarray.argarray_len, ~0, - sizeof (nfs_cb_argop4), (zdrproc_t) zdr_nfs_cb_argop4)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_CB_COMPOUND4res (ZDR *zdrs, CB_COMPOUND4res *objp) -{ - - - if (!zdr_nfsstat4 (zdrs, &objp->status)) - return FALSE; - if (!zdr_utf8str_cs (zdrs, &objp->tag)) - return FALSE; - if (!zdr_array (zdrs, (char **)&objp->resarray.resarray_val, (u_int *) &objp->resarray.resarray_len, ~0, - sizeof (nfs_cb_resop4), (zdrproc_t) zdr_nfs_cb_resop4)) - return FALSE; - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-raw-nlm.c b/source/liborbisNfs/libnfs-raw-nlm.c deleted file mode 100644 index 65fcd7c..0000000 --- a/source/liborbisNfs/libnfs-raw-nlm.c +++ /dev/null @@ -1,258 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-nlm.h" - -uint32_t -zdr_nlm_fh4 (ZDR *zdrs, nlm_fh4 *objp) -{ - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm4_oh (ZDR *zdrs, nlm4_oh *objp) -{ - if (!zdr_string (zdrs, objp, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm_cookie (ZDR *zdrs, nlm_cookie *objp) -{ - if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlmstat4 (ZDR *zdrs, nlmstat4 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm4_holder (ZDR *zdrs, nlm4_holder *objp) -{ - if (!zdr_bool (zdrs, &objp->exclusive)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->svid)) - return FALSE; - if (!zdr_nlm4_oh (zdrs, &objp->oh)) - return FALSE; - if (!zdr_uint64_t (zdrs, &objp->l_offset)) - return FALSE; - if (!zdr_uint64_t (zdrs, &objp->l_len)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm4_lock (ZDR *zdrs, nlm4_lock *objp) -{ - if (!zdr_string (zdrs, &objp->caller_name, NLM_MAXNAME)) - return FALSE; - if (!zdr_nlm_fh4 (zdrs, &objp->fh)) - return FALSE; - if (!zdr_nlm4_oh (zdrs, &objp->oh)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->svid)) - return FALSE; - if (!zdr_uint64_t (zdrs, &objp->l_offset)) - return FALSE; - if (!zdr_uint64_t (zdrs, &objp->l_len)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm4_share (ZDR *zdrs, nlm4_share *objp) -{ - if (!zdr_string (zdrs, &objp->caller_name, NLM_MAXNAME)) - return FALSE; - if (!zdr_nlm_fh4 (zdrs, &objp->fh)) - return FALSE; - if (!zdr_nlm4_oh (zdrs, &objp->oh)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->mode)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->access)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm4_testres_denied (ZDR *zdrs, nlm4_testres_denied *objp) -{ - if (!zdr_nlm4_holder (zdrs, &objp->holder)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nlm4_testreply (ZDR *zdrs, nlm4_testreply *objp) -{ - if (!zdr_nlmstat4 (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NLM4_DENIED: - if (!zdr_nlm4_testres_denied (zdrs, &objp->nlm4_testreply_u.lock)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -uint32_t -zdr_NLM4_TESTres (ZDR *zdrs, NLM4_TESTres *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_nlm4_testreply (zdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_TESTargs (ZDR *zdrs, NLM4_TESTargs *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_bool (zdrs, &objp->exclusive)) - return FALSE; - if (!zdr_nlm4_lock (zdrs, &objp->lock)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_CANCres (ZDR *zdrs, NLM4_CANCres *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_nlmstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_CANCargs (ZDR *zdrs, NLM4_CANCargs *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_bool (zdrs, &objp->block)) - return FALSE; - if (!zdr_bool (zdrs, &objp->exclusive)) - return FALSE; - if (!zdr_nlm4_lock (zdrs, &objp->lock)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_UNLOCKres (ZDR *zdrs, NLM4_UNLOCKres *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_nlmstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_UNLOCKargs (ZDR *zdrs, NLM4_UNLOCKargs *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_nlm4_lock (zdrs, &objp->lock)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_LOCKres (ZDR *zdrs, NLM4_LOCKres *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_nlmstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_LOCKargs (ZDR *zdrs, NLM4_LOCKargs *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_bool (zdrs, &objp->block)) - return FALSE; - if (!zdr_bool (zdrs, &objp->exclusive)) - return FALSE; - if (!zdr_nlm4_lock (zdrs, &objp->lock)) - return FALSE; - if (!zdr_bool (zdrs, &objp->reclaim)) - return FALSE; - if (!zdr_int (zdrs, &objp->state)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_GRANTEDargs (ZDR *zdrs, NLM4_GRANTEDargs *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_bool (zdrs, &objp->exclusive)) - return FALSE; - if (!zdr_nlm4_lock (zdrs, &objp->lock)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NLM4_GRANTEDres (ZDR *zdrs, NLM4_GRANTEDres *objp) -{ - if (!zdr_nlm_cookie (zdrs, &objp->cookie)) - return FALSE; - if (!zdr_nlmstat4 (zdrs, &objp->status)) - return FALSE; - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-raw-nsm.c b/source/liborbisNfs/libnfs-raw-nsm.c deleted file mode 100644 index 5c917d3..0000000 --- a/source/liborbisNfs/libnfs-raw-nsm.c +++ /dev/null @@ -1,148 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-nsm.h" - -uint32_t -zdr_nsmstat1 (ZDR *zdrs, nsmstat1 *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nsm_my_id (ZDR *zdrs, nsm_my_id *objp) -{ - if (!zdr_string (zdrs, &objp->my_name, NSM_MAXSTRLEN)) - return FALSE; - if (!zdr_int (zdrs, &objp->my_prog)) - return FALSE; - if (!zdr_int (zdrs, &objp->my_vers)) - return FALSE; - if (!zdr_int (zdrs, &objp->my_proc)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_nsm_mon_id (ZDR *zdrs, nsm_mon_id *objp) -{ - if (!zdr_string (zdrs, &objp->mon_name, NSM_MAXSTRLEN)) - return FALSE; - if (!zdr_nsm_my_id (zdrs, &objp->my_id)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_STATres (ZDR *zdrs, NSM1_STATres *objp) -{ - if (!zdr_nsmstat1 (zdrs, &objp->res)) - return FALSE; - if (!zdr_int (zdrs, &objp->state)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_STATargs (ZDR *zdrs, NSM1_STATargs *objp) -{ - if (!zdr_string (zdrs, &objp->mon_name, NSM_MAXSTRLEN)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_MONres (ZDR *zdrs, NSM1_MONres *objp) -{ - if (!zdr_nsmstat1 (zdrs, &objp->res)) - return FALSE; - if (!zdr_int (zdrs, &objp->state)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_MONargs (ZDR *zdrs, NSM1_MONargs *objp) -{ - if (!zdr_nsm_mon_id (zdrs, &objp->mon_id)) - return FALSE; - if (!zdr_opaque (zdrs, objp->priv, 16)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_UNMONres (ZDR *zdrs, NSM1_UNMONres *objp) -{ - if (!zdr_int (zdrs, &objp->state)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_UNMONargs (ZDR *zdrs, NSM1_UNMONargs *objp) -{ - if (!zdr_nsm_mon_id (zdrs, &objp->mon_id)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_UNMONALLres (ZDR *zdrs, NSM1_UNMONALLres *objp) -{ - if (!zdr_int (zdrs, &objp->state)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_UNMONALLargs (ZDR *zdrs, NSM1_UNMONALLargs *objp) -{ - if (!zdr_nsm_my_id (zdrs, &objp->my_id)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_NSM1_NOTIFYargs (ZDR *zdrs, NSM1_NOTIFYargs *objp) -{ - if (!zdr_string (zdrs, &objp->mon_name, NSM_MAXSTRLEN)) - return FALSE; - if (!zdr_int (zdrs, &objp->state)) - return FALSE; - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-raw-portmap.c b/source/liborbisNfs/libnfs-raw-portmap.c deleted file mode 100644 index 2486e91..0000000 --- a/source/liborbisNfs/libnfs-raw-portmap.c +++ /dev/null @@ -1,475 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-portmap.h" - -uint32_t -zdr_pmap2_mapping (ZDR *zdrs, pmap2_mapping *objp) -{ - - - - if (zdrs->x_op == ZDR_ENCODE) { - int32_t *buf; - buf = ZDR_INLINE (zdrs, 4 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->prot)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->port)) - return FALSE; - } else { - IZDR_PUT_U_LONG(buf, objp->prog); - IZDR_PUT_U_LONG(buf, objp->vers); - IZDR_PUT_U_LONG(buf, objp->prot); - IZDR_PUT_U_LONG(buf, objp->port); - } - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - int32_t *buf; - buf = ZDR_INLINE (zdrs, 4 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->prot)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->port)) - return FALSE; - } else { - objp->prog = IZDR_GET_U_LONG(buf); - objp->vers = IZDR_GET_U_LONG(buf); - objp->prot = IZDR_GET_U_LONG(buf); - objp->port = IZDR_GET_U_LONG(buf); - } - return TRUE; - } - - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->prot)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->port)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap2_call_args (ZDR *zdrs, pmap2_call_args *objp) -{ - - - - if (zdrs->x_op == ZDR_ENCODE) { - int32_t *buf; - buf = ZDR_INLINE (zdrs, 3 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->proc)) - return FALSE; - - } else { - IZDR_PUT_U_LONG(buf, objp->prog); - IZDR_PUT_U_LONG(buf, objp->vers); - IZDR_PUT_U_LONG(buf, objp->proc); - } - if (!zdr_bytes (zdrs, (char **)&objp->args.args_val, (u_int *) &objp->args.args_len, ~0)) - return FALSE; - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - int32_t *buf; - buf = ZDR_INLINE (zdrs, 3 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->proc)) - return FALSE; - - } else { - objp->prog = IZDR_GET_U_LONG(buf); - objp->vers = IZDR_GET_U_LONG(buf); - objp->proc = IZDR_GET_U_LONG(buf); - } - if (!zdr_bytes (zdrs, (char **)&objp->args.args_val, (u_int *) &objp->args.args_len, ~0)) - return FALSE; - return TRUE; - } - - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->proc)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->args.args_val, (u_int *) &objp->args.args_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap2_call_result (ZDR *zdrs, pmap2_call_result *objp) -{ - - - if (!zdr_u_int (zdrs, &objp->port)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->res.res_val, (u_int *) &objp->res.res_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap2_mapping_list (ZDR *zdrs, pmap2_mapping_list *objp) -{ - - - if (!zdr_pmap2_mapping (zdrs, &objp->map)) - return FALSE; - if (!zdr_pointer (zdrs, (char **)&objp->next, sizeof (pmap2_mapping_list), (zdrproc_t) zdr_pmap2_mapping_list)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap2_dump_result (ZDR *zdrs, pmap2_dump_result *objp) -{ - - - if (!zdr_pointer (zdrs, (char **)&objp->list, sizeof (pmap2_mapping_list), (zdrproc_t) zdr_pmap2_mapping_list)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_string_result (ZDR *zdrs, pmap3_string_result *objp) -{ - - - if (!zdr_string (zdrs, &objp->addr, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_mapping (ZDR *zdrs, pmap3_mapping *objp) -{ - - - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_string (zdrs, &objp->netid, ~0)) - return FALSE; - if (!zdr_string (zdrs, &objp->addr, ~0)) - return FALSE; - if (!zdr_string (zdrs, &objp->owner, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_mapping_list (ZDR *zdrs, pmap3_mapping_list *objp) -{ - - - if (!zdr_pmap3_mapping (zdrs, &objp->map)) - return FALSE; - if (!zdr_pointer (zdrs, (char **)&objp->next, sizeof (pmap3_mapping_list), (zdrproc_t) zdr_pmap3_mapping_list)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_dump_result (ZDR *zdrs, pmap3_dump_result *objp) -{ - - - if (!zdr_pointer (zdrs, (char **)&objp->list, sizeof (pmap3_mapping_list), (zdrproc_t) zdr_pmap3_mapping_list)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_call_args (ZDR *zdrs, pmap3_call_args *objp) -{ - - - - if (zdrs->x_op == ZDR_ENCODE) { - int32_t *buf; - buf = ZDR_INLINE (zdrs, 3 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->proc)) - return FALSE; - - } else { - IZDR_PUT_U_LONG(buf, objp->prog); - IZDR_PUT_U_LONG(buf, objp->vers); - IZDR_PUT_U_LONG(buf, objp->proc); - } - if (!zdr_bytes (zdrs, (char **)&objp->args.args_val, (u_int *) &objp->args.args_len, ~0)) - return FALSE; - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - int32_t *buf; - buf = ZDR_INLINE (zdrs, 3 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->proc)) - return FALSE; - - } else { - objp->prog = IZDR_GET_U_LONG(buf); - objp->vers = IZDR_GET_U_LONG(buf); - objp->proc = IZDR_GET_U_LONG(buf); - } - if (!zdr_bytes (zdrs, (char **)&objp->args.args_val, (u_int *) &objp->args.args_len, ~0)) - return FALSE; - return TRUE; - } - - if (!zdr_u_int (zdrs, &objp->prog)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->vers)) - return FALSE; - if (!zdr_u_int (zdrs, &objp->proc)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->args.args_val, (u_int *) &objp->args.args_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_call_result (ZDR *zdrs, pmap3_call_result *objp) -{ - - - if (!zdr_u_int (zdrs, &objp->port)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->res.res_val, (u_int *) &objp->res.res_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_pmap3_netbuf (ZDR *zdrs, pmap3_netbuf *objp) -{ - - - if (!zdr_u_int (zdrs, &objp->maxlen)) - return FALSE; - if (!zdr_bytes (zdrs, (char **)&objp->buf.buf_val, (u_int *) &objp->buf.buf_len, ~0)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP2SETargs (ZDR *zdrs, PMAP2SETargs *objp) -{ - - - if (!zdr_pmap2_mapping (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP2UNSETargs (ZDR *zdrs, PMAP2UNSETargs *objp) -{ - - - if (!zdr_pmap2_mapping (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP2GETPORTargs (ZDR *zdrs, PMAP2GETPORTargs *objp) -{ - - - if (!zdr_pmap2_mapping (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP2CALLITargs (ZDR *zdrs, PMAP2CALLITargs *objp) -{ - - - if (!zdr_pmap2_call_args (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP2CALLITres (ZDR *zdrs, PMAP2CALLITres *objp) -{ - - - if (!zdr_pmap2_call_result (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP2DUMPres (ZDR *zdrs, PMAP2DUMPres *objp) -{ - - - if (!zdr_pmap2_dump_result (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3SETargs (ZDR *zdrs, PMAP3SETargs *objp) -{ - - - if (!zdr_pmap3_mapping (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3UNSETargs (ZDR *zdrs, PMAP3UNSETargs *objp) -{ - - - if (!zdr_pmap3_mapping (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3GETADDRargs (ZDR *zdrs, PMAP3GETADDRargs *objp) -{ - - - if (!zdr_pmap3_mapping (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3GETADDRres (ZDR *zdrs, PMAP3GETADDRres *objp) -{ - - - if (!zdr_pmap3_string_result (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3DUMPres (ZDR *zdrs, PMAP3DUMPres *objp) -{ - - - if (!zdr_pmap3_dump_result (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3CALLITargs (ZDR *zdrs, PMAP3CALLITargs *objp) -{ - - - if (!zdr_pmap3_call_result (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3CALLITres (ZDR *zdrs, PMAP3CALLITres *objp) -{ - - - if (!zdr_pmap3_call_result (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3UADDR2TADDRres (ZDR *zdrs, PMAP3UADDR2TADDRres *objp) -{ - - - if (!zdr_pmap3_netbuf (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3TADDR2UADDRargs (ZDR *zdrs, PMAP3TADDR2UADDRargs *objp) -{ - - - if (!zdr_pmap3_netbuf (zdrs, objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_PMAP3TADDR2UADDRres (ZDR *zdrs, PMAP3TADDR2UADDRres *objp) -{ - - - if (!zdr_pmap3_string_result (zdrs, objp)) - return FALSE; - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-raw-rquota.c b/source/liborbisNfs/libnfs-raw-rquota.c deleted file mode 100644 index 0fea51b..0000000 --- a/source/liborbisNfs/libnfs-raw-rquota.c +++ /dev/null @@ -1,201 +0,0 @@ -/* -Copyright (c) 2014, Ronnie Sahlberg -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -The views and conclusions contained in the software and documentation are those -of the authors and should not be interpreted as representing official policies, -either expressed or implied, of the FreeBSD Project. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "libnfs-zdr.h" -#include "libnfs-raw-rquota.h" - -uint32_t -zdr_rquotastat (ZDR *zdrs, rquotastat *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_exportpath (ZDR *zdrs, exportpath *objp) -{ - if (!zdr_string (zdrs, objp, RQUOTAPATHLEN)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETQUOTA1args (ZDR *zdrs, GETQUOTA1args *objp) -{ - if (!zdr_exportpath (zdrs, &objp->export)) - return FALSE; - if (!zdr_int (zdrs, &objp->uid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_quotatype (ZDR *zdrs, quotatype *objp) -{ - if (!zdr_enum (zdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETQUOTA2args (ZDR *zdrs, GETQUOTA2args *objp) -{ - if (!zdr_exportpath (zdrs, &objp->export)) - return FALSE; - if (!zdr_quotatype (zdrs, &objp->type)) - return FALSE; - if (!zdr_int (zdrs, &objp->uid)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETQUOTA1res_ok (ZDR *zdrs, GETQUOTA1res_ok *objp) -{ - register int32_t *buf; - buf = NULL; - - if (zdrs->x_op == ZDR_ENCODE) { - buf = ZDR_INLINE (zdrs, 10 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_int (zdrs, &objp->bsize)) - return FALSE; - if (!zdr_int (zdrs, &objp->active)) - return FALSE; - if (!zdr_int (zdrs, &objp->bhardlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->bsoftlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->curblocks)) - return FALSE; - if (!zdr_int (zdrs, &objp->fhardlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->fsoftlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->curfiles)) - return FALSE; - if (!zdr_int (zdrs, &objp->btimeleft)) - return FALSE; - if (!zdr_int (zdrs, &objp->ftimeleft)) - return FALSE; - } else { - IZDR_PUT_LONG(buf, objp->bsize); - IZDR_PUT_LONG(buf, objp->active); - IZDR_PUT_LONG(buf, objp->bhardlimit); - IZDR_PUT_LONG(buf, objp->bsoftlimit); - IZDR_PUT_LONG(buf, objp->curblocks); - IZDR_PUT_LONG(buf, objp->fhardlimit); - IZDR_PUT_LONG(buf, objp->fsoftlimit); - IZDR_PUT_LONG(buf, objp->curfiles); - IZDR_PUT_LONG(buf, objp->btimeleft); - IZDR_PUT_LONG(buf, objp->ftimeleft); - } - return TRUE; - } else if (zdrs->x_op == ZDR_DECODE) { - buf = ZDR_INLINE (zdrs, 10 * BYTES_PER_ZDR_UNIT); - if (buf == NULL) { - if (!zdr_int (zdrs, &objp->bsize)) - return FALSE; - if (!zdr_int (zdrs, &objp->active)) - return FALSE; - if (!zdr_int (zdrs, &objp->bhardlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->bsoftlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->curblocks)) - return FALSE; - if (!zdr_int (zdrs, &objp->fhardlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->fsoftlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->curfiles)) - return FALSE; - if (!zdr_int (zdrs, &objp->btimeleft)) - return FALSE; - if (!zdr_int (zdrs, &objp->ftimeleft)) - return FALSE; - } else { - objp->bsize = IZDR_GET_LONG(buf); - objp->active = IZDR_GET_LONG(buf); - objp->bhardlimit = IZDR_GET_LONG(buf); - objp->bsoftlimit = IZDR_GET_LONG(buf); - objp->curblocks = IZDR_GET_LONG(buf); - objp->fhardlimit = IZDR_GET_LONG(buf); - objp->fsoftlimit = IZDR_GET_LONG(buf); - objp->curfiles = IZDR_GET_LONG(buf); - objp->btimeleft = IZDR_GET_LONG(buf); - objp->ftimeleft = IZDR_GET_LONG(buf); - } - return TRUE; - } - - if (!zdr_int (zdrs, &objp->bsize)) - return FALSE; - if (!zdr_int (zdrs, &objp->active)) - return FALSE; - if (!zdr_int (zdrs, &objp->bhardlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->bsoftlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->curblocks)) - return FALSE; - if (!zdr_int (zdrs, &objp->fhardlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->fsoftlimit)) - return FALSE; - if (!zdr_int (zdrs, &objp->curfiles)) - return FALSE; - if (!zdr_int (zdrs, &objp->btimeleft)) - return FALSE; - if (!zdr_int (zdrs, &objp->ftimeleft)) - return FALSE; - return TRUE; -} - -uint32_t -zdr_GETQUOTA1res (ZDR *zdrs, GETQUOTA1res *objp) -{ - if (!zdr_rquotastat (zdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case RQUOTA_OK: - if (!zdr_GETQUOTA1res_ok (zdrs, &objp->GETQUOTA1res_u.quota)) - return FALSE; - break; - default: - break; - } - return TRUE; -} diff --git a/source/liborbisNfs/libnfs-sync.c b/source/liborbisNfs/libnfs-sync.c deleted file mode 100644 index be05344..0000000 --- a/source/liborbisNfs/libnfs-sync.c +++ /dev/null @@ -1,2265 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * High level api to nfs filesystems - */ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef HAVE_SYS_SOCKET_H -#include -#endif - -#ifdef HAVE_NET_IF_H -#include -#endif - -#ifdef HAVE_SYS_VFS_H -#include -#endif - -#ifdef HAVE_SYS_STATVFS_H -#include -#endif - -#if defined(__ANDROID__) && !defined(HAVE_SYS_STATVFS_H) -#define statvfs statfs -#endif - -#ifdef HAVE_SYS_IOCTL_H -#include -#endif - -#ifdef HAVE_POLL_H -#include -#endif - -#ifdef HAVE_NETDB_H -#include -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#ifdef HAVE_NETINET_IN_H -#include -#endif - -#ifdef HAVE_STRINGS_H -#include -#endif - -#include -#include -#include -#include -#include -#include -#include -#include - -#ifdef HAVE_SYS_SOCKIO_H -#include -#endif - -#ifdef HAVE_SYS_TIME_H -#include -#endif - -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-raw-mount.h" -#include "libnfs-raw-nfs.h" -#include "libnfs-private.h" - -struct sync_cb_data { - int is_finished; - int status; - uint64_t offset; - void *return_data; - int return_int; - const char *call; -}; - - -static void -wait_for_reply(struct rpc_context *rpc, struct sync_cb_data *cb_data) -{ - struct pollfd pfd; - int revents; - int ret; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - while (!cb_data->is_finished) { - - pfd.fd = rpc_get_fd(rpc); - pfd.events = rpc_which_events(rpc); - pfd.revents = 0; - - ret = poll(&pfd, 1, 100); - if (ret < 0) { - rpc_set_error(rpc, "Poll failed"); - revents = -1; - } else { - revents = pfd.revents; - } - - if (rpc_service(rpc, revents) < 0) { - if (revents != -1) - rpc_set_error(rpc, "rpc_service failed"); - cb_data->status = -EIO; - break; - } - - if (rpc_get_fd(rpc) == -1) { - rpc_set_error(rpc, "Socket closed"); - break; - } - } -} - -static void -wait_for_nfs_reply(struct nfs_context *nfs, struct sync_cb_data *cb_data) -{ - struct pollfd pfd; - int revents; - int ret; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - while (!cb_data->is_finished) { - - pfd.fd = nfs_get_fd(nfs); - pfd.events = nfs_which_events(nfs); - pfd.revents = 0; - - ret = poll(&pfd, 1, 100); - if (ret < 0) { - nfs_set_error(nfs, "Poll failed"); - revents = -1; - } else { - revents = pfd.revents; - } - - if (nfs_service(nfs, revents) < 0) { - if (revents != -1) - nfs_set_error(nfs, "nfs_service failed"); - cb_data->status = -EIO; - break; - } - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - -} - - - -/* - * connect to the server and mount the export - */ -static void -mount_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "%s: %s", - __FUNCTION__, nfs_get_error(nfs)); - return; - } -} - -int -nfs_mount(struct nfs_context *nfs, const char *server, const char *export) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - struct sync_cb_data cb_data; - struct rpc_context *rpc = nfs_get_rpc_context(nfs); - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - cb_data.is_finished = 0; - - if (nfs_mount_async(nfs, server, export, mount_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_mount_async failed. %s", - nfs_get_error(nfs)); - debugNetPrintf(2,"[LIBNFS] %s %s\n",__FUNCTION__,nfs_get_error(nfs)); - - return -1; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s waiting\n",__FUNCTION__); - - wait_for_nfs_reply(nfs, &cb_data); - - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end waiting\n",__FUNCTION__); - - /* Dont want any more callbacks even if the socket is closed */ - rpc->connect_cb = NULL; - - /* Ensure that no RPCs are pending. In error case (e.g. timeout in - * wait_for_nfs_reply()) we can disconnect; in success case all RPCs - * are completed by definition. - */ - if (cb_data.status) { - rpc_disconnect(rpc, "failed mount"); - } - - return cb_data.status; -} - - -/* - * unregister the mount - */ -static void -umount_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "%s: %s", - __FUNCTION__, nfs_get_error(nfs)); - return; - } -} - -int -nfs_umount(struct nfs_context *nfs) -{ - struct sync_cb_data cb_data; - struct rpc_context *rpc = nfs_get_rpc_context(nfs); - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - cb_data.is_finished = 0; - - if (nfs_umount_async(nfs, umount_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_umount_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - /* Dont want any more callbacks even if the socket is closed */ - rpc->connect_cb = NULL; - - /* Ensure that no RPCs are pending. In error case (e.g. timeout in - * wait_for_nfs_reply()) we can disconnect; in success case all RPCs - * are completed by definition. - */ - if (cb_data.status) { - rpc_disconnect(rpc, "failed mount"); - } - - return cb_data.status; -} - - -/* - * stat() - */ -static void -stat_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "stat call failed with \"%s\"", - (char *)data); - return; - } -#ifdef WIN32 - memcpy(cb_data->return_data, data, sizeof(struct __stat64)); -#else - memcpy(cb_data->return_data, data, sizeof(struct stat)); -#endif -} - -int -#ifdef WIN32 -nfs_stat(struct nfs_context *nfs, const char *path, struct __stat64 *st) -#else -nfs_stat(struct nfs_context *nfs, const char *path, struct stat *st) -#endif -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = st; - - if (nfs_stat_async(nfs, path, stat_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_stat_async failed"); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -static void -stat64_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "stat call failed with \"%s\"", - (char *)data); - return; - } - memcpy(cb_data->return_data, data, sizeof(struct nfs_stat_64)); -} - -int -nfs_stat64(struct nfs_context *nfs, const char *path, struct nfs_stat_64 *st) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = st; - - if (nfs_stat64_async(nfs, path, stat64_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_stat64_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -int -nfs_lstat64(struct nfs_context *nfs, const char *path, struct nfs_stat_64 *st) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = st; - - if (nfs_lstat64_async(nfs, path, stat64_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_lstat64_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * open() - */ -static void -open_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - struct nfsfh *fh, **nfsfh; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "open call failed with \"%s\"", - (char *)data); - return; - } - - fh = data; - nfsfh = cb_data->return_data; - *nfsfh = fh; -} - -int -nfs_open(struct nfs_context *nfs, const char *path, int flags, - struct nfsfh **nfsfh) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = nfsfh; - - if (nfs_open_async(nfs, path, flags, open_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_open_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -int -nfs_open2(struct nfs_context *nfs, const char *path, int flags, - int mode, struct nfsfh **nfsfh) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = nfsfh; - - if (nfs_open2_async(nfs, path, flags, mode, open_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_open2_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * chdir() - */ -static void -chdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "chdir call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_chdir(struct nfs_context *nfs, const char *path) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_chdir_async(nfs, path, chdir_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_chdir_async failed with %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * pread() - */ -static void -pread_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - char *buffer; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "%s call failed with \"%s\"", cb_data->call, - (char *)data); - return; - } - - buffer = cb_data->return_data; - memcpy(buffer, (char *)data, status); -} - -int -nfs_pread(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, - uint64_t count, void *buffer) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = buffer; - cb_data.call = "pread"; - - if (nfs_pread_async(nfs, nfsfh, offset, count, pread_cb, - &cb_data) != 0) { - nfs_set_error(nfs, "nfs_pread_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * read() - */ -int -nfs_read(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, - void *buffer) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = buffer; - cb_data.call = "read"; - - if (nfs_read_async(nfs, nfsfh, count, pread_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_read_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * close() - */ -static void -close_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "close call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_close(struct nfs_context *nfs, struct nfsfh *nfsfh) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_close_async(nfs, nfsfh, close_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_close_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * fstat() - */ -int -#ifdef WIN32 -nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, struct __stat64 *st) -#else -nfs_fstat(struct nfs_context *nfs, struct nfsfh *nfsfh, struct stat *st) -#endif -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = st; - - if (nfs_fstat_async(nfs, nfsfh, stat_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_fstat_async failed"); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * fstat64() - */ -int -nfs_fstat64(struct nfs_context *nfs, struct nfsfh *nfsfh, - struct nfs_stat_64 *st) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = st; - - if (nfs_fstat64_async(nfs, nfsfh, stat64_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_fstat64_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * pwrite() - */ -static void -pwrite_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) - nfs_set_error(nfs, "%s call failed with \"%s\"", - cb_data->call, (char *)data); -} - -int -nfs_pwrite(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, - uint64_t count, const void *buf) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.call = "pwrite"; - - if (nfs_pwrite_async(nfs, nfsfh, offset, count, buf, pwrite_cb, - &cb_data) != 0) { - nfs_set_error(nfs, "nfs_pwrite_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * write() - */ -int -nfs_write(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, - const void *buf) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.call = "write"; - - if (nfs_write_async(nfs, nfsfh, count, buf, pwrite_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_write_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * fsync() - */ -static void -fsync_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "fsync call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_fsync(struct nfs_context *nfs, struct nfsfh *nfsfh) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_fsync_async(nfs, nfsfh, fsync_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_fsync_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * ftruncate() - */ -static void -ftruncate_cb(int status, struct nfs_context *nfs, void *data, - void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "ftruncate call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_ftruncate(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t length) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_ftruncate_async(nfs, nfsfh, length, ftruncate_cb, - &cb_data) != 0) { - nfs_set_error(nfs, "nfs_ftruncate_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * truncate() - */ -static void -truncate_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "truncate call failed with \"%s\"", - (char *)data); - return; - } -} - -int nfs_truncate(struct nfs_context *nfs, const char *path, uint64_t length) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_truncate_async(nfs, path, length, truncate_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_ftruncate_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * mkdir() - */ -static void -mkdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "mkdir call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_mkdir(struct nfs_context *nfs, const char *path) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_mkdir_async(nfs, path, mkdir_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_mkdir_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -int -nfs_mkdir2(struct nfs_context *nfs, const char *path, int mode) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_mkdir2_async(nfs, path, mode, mkdir_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_mkdir2_async failed"); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - - -/* - * rmdir() - */ -static void -rmdir_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "rmdir call failed with \"%s\"", - (char *)data); - return; - } -} - -int nfs_rmdir(struct nfs_context *nfs, const char *path) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_rmdir_async(nfs, path, rmdir_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_rmdir_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * creat() - */ -static void -creat_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - struct nfsfh *fh, **nfsfh; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "creat call failed with \"%s\"", - (char *)data); - return; - } - - fh = data; - nfsfh = cb_data->return_data; - *nfsfh = fh; -} - -int -nfs_create(struct nfs_context *nfs, const char *path, int flags, int mode, - struct nfsfh **nfsfh) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = nfsfh; - - if (nfs_create_async(nfs, path, flags, mode, creat_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_create_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -int -nfs_creat(struct nfs_context *nfs, const char *path, int mode, - struct nfsfh **nfsfh) -{ - return nfs_create(nfs, path, 0, mode, nfsfh); -} - -/* - * mknod() - */ -static void -mknod_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "mknod call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_mknod(struct nfs_context *nfs, const char *path, int mode, int dev) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_mknod_async(nfs, path, mode, dev, mknod_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_creat_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * unlink() - */ -static void -unlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "unlink call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_unlink(struct nfs_context *nfs, const char *path) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_unlink_async(nfs, path, unlink_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_unlink_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * opendir() - */ -static void -opendir_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - struct nfsdir *dir, **nfsdir; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "opendir call failed with \"%s\"", - (char *)data); - return; - } - - dir = data; - nfsdir = cb_data->return_data; - *nfsdir = dir; -} - -int -nfs_opendir(struct nfs_context *nfs, const char *path, struct nfsdir **nfsdir) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = nfsdir; - - if (nfs_opendir_async(nfs, path, opendir_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_opendir_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * lseek() - */ -static void -lseek_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "lseek call failed with \"%s\"", - nfs_get_error(nfs)); - return; - } - - if (cb_data->return_data != NULL) { - memcpy(cb_data->return_data, data, sizeof(uint64_t)); - } -} - -int -nfs_lseek(struct nfs_context *nfs, struct nfsfh *nfsfh, int64_t offset, int whence, uint64_t *current_offset) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = current_offset; - - if (nfs_lseek_async(nfs, nfsfh, offset, whence, lseek_cb, - &cb_data) != 0) { - nfs_set_error(nfs, "nfs_lseek_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * lockf() - */ -static void -lockf_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "lockf call failed with \"%s\"", - nfs_get_error(nfs)); - return; - } -} - -int -nfs_lockf(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_lock_op cmd, uint64_t count) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_lockf_async(nfs, nfsfh, cmd, count, - lockf_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_lockf_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * fcntl() - */ -static void -fcntl_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "fcntl call failed with \"%s\"", - nfs_get_error(nfs)); - return; - } -} - -int -nfs_fcntl(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_fcntl_op cmd, void *arg) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_fcntl_async(nfs, nfsfh, cmd, arg, - fcntl_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_fcntl_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * statvfs() - */ -static void -statvfs_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "statvfs call failed with \"%s\"", - (char *)data); - return; - } - - memcpy(cb_data->return_data, data, sizeof(struct statvfs)); -} - -int -nfs_statvfs(struct nfs_context *nfs, const char *path, struct statvfs *svfs) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = svfs; - - if (nfs_statvfs_async(nfs, path, statvfs_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_statvfs_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * statvfs64() - */ -static void -statvfs64_cb(int status, struct nfs_context *nfs, void *data, - void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "statvfs64 call failed with \"%s\"", - (char *)data); - return; - } - - memcpy(cb_data->return_data, data, sizeof(struct nfs_statvfs_64)); -} - -int -nfs_statvfs64(struct nfs_context *nfs, const char *path, - struct nfs_statvfs_64 *svfs) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = svfs; - - if (nfs_statvfs64_async(nfs, path, statvfs64_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_statvfs64_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * readlink() - */ -static void -readlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "readlink call failed with \"%s\"", - (char *)data); - return; - } - - if (strlen(data) > (size_t)cb_data->return_int) { - nfs_set_error(nfs, "Too small buffer for readlink"); - cb_data->status = -ENAMETOOLONG; - return; - } - - memcpy(cb_data->return_data, data, strlen(data)+1); -} - -int -nfs_readlink(struct nfs_context *nfs, const char *path, char *buf, int bufsize) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - cb_data.return_data = buf; - cb_data.return_int = bufsize; - - if (nfs_readlink_async(nfs, path, readlink_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_readlink_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -static void -readlink2_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - char **bufptr; - char *buf; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "readlink call failed with \"%s\"", - (char *)data); - return; - } - - buf = strdup(data); - if (buf == NULL) { - cb_data->status = errno ? -errno : -ENOMEM; - return; - } - - bufptr = cb_data->return_data; - if (bufptr) - *bufptr = buf; -} - -int -nfs_readlink2(struct nfs_context *nfs, const char *path, char **bufptr) -{ - struct sync_cb_data cb_data; - - *bufptr = NULL; - cb_data.is_finished = 0; - cb_data.return_data = bufptr; - - if (nfs_readlink_async(nfs, path, readlink2_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_readlink_async failed"); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * chmod() - */ -static void -chmod_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "chmod call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_chmod(struct nfs_context *nfs, const char *path, int mode) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_chmod_async(nfs, path, mode, chmod_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_chmod_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -int -nfs_lchmod(struct nfs_context *nfs, const char *path, int mode) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_lchmod_async(nfs, path, mode, chmod_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_lchmod_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - - -/* - * fchmod() - */ -static void -fchmod_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "fchmod call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_fchmod(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_fchmod_async(nfs, nfsfh, mode, fchmod_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_fchmod_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - - -/* - * chown() - */ -static void -chown_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "chown call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_chown(struct nfs_context *nfs, const char *path, int uid, int gid) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_chown_async(nfs, path, uid, gid, chown_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_chown_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * lchown() - */ -int -nfs_lchown(struct nfs_context *nfs, const char *path, int uid, int gid) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_lchown_async(nfs, path, uid, gid, chown_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_lchown_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -/* - * fchown() - */ -static void -fchown_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "fchown call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_fchown(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, int gid) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_fchown_async(nfs, nfsfh, uid, gid, fchown_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_fchown_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * utimes() - */ -static void -utimes_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "utimes call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_utimes(struct nfs_context *nfs, const char *path, struct timeval *times) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_utimes_async(nfs, path, times, utimes_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_utimes_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -int -nfs_lutimes(struct nfs_context *nfs, const char *path, struct timeval *times) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_lutimes_async(nfs, path, times, utimes_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_lutimes_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * utime() - */ -static void -utime_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "utime call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_utime(struct nfs_context *nfs, const char *path, struct utimbuf *times) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_utime_async(nfs, path, times, utime_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_utimes_async failed"); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * access() - */ -static void -access_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "access call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_access(struct nfs_context *nfs, const char *path, int mode) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_access_async(nfs, path, mode, access_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_access_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * access2() - */ -static void -access2_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "access2 call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_access2(struct nfs_context *nfs, const char *path) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_access2_async(nfs, path, access2_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_access2_async failed. %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * symlink() - */ -static void -symlink_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "symlink call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_symlink(struct nfs_context *nfs, const char *target, const char *linkname) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_symlink_async(nfs, target, linkname, symlink_cb, - &cb_data) != 0) { - nfs_set_error(nfs, "nfs_symlink_async failed: %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - -/* - * rename() - */ -static void -rename_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "rename call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_rename(struct nfs_context *nfs, const char *oldpath, const char *newpath) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_rename_async(nfs, oldpath, newpath, rename_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_rename_async failed: %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - - - -/* - * link() - */ -static void -link_cb(int status, struct nfs_context *nfs, void *data, void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - - cb_data->is_finished = 1; - cb_data->status = status; - - if (status < 0) { - nfs_set_error(nfs, "link call failed with \"%s\"", - (char *)data); - return; - } -} - -int -nfs_link(struct nfs_context *nfs, const char *oldpath, const char *newpath) -{ - struct sync_cb_data cb_data; - - cb_data.is_finished = 0; - - if (nfs_link_async(nfs, oldpath, newpath, link_cb, &cb_data) != 0) { - nfs_set_error(nfs, "nfs_link_async failed: %s", - nfs_get_error(nfs)); - return -1; - } - - wait_for_nfs_reply(nfs, &cb_data); - - return cb_data.status; -} - -void -mount_getexports_cb(struct rpc_context *mount_context, int status, void *data, - void *private_data) -{ - struct sync_cb_data *cb_data = private_data; - exports export; - - assert(mount_context->magic == RPC_CONTEXT_MAGIC); - - cb_data->is_finished = 1; - cb_data->status = status; - cb_data->return_data = NULL; - - if (status != 0) { - rpc_set_error(mount_context, "mount/export call failed with " - "\"%s\"", (char *)data); - return; - } - - export = *(exports *)data; - while (export != NULL) { - exports new_export; - - new_export = malloc(sizeof(*new_export)); - memset(new_export, 0, sizeof(*new_export)); - new_export->ex_dir = strdup(export->ex_dir); - new_export->ex_next = cb_data->return_data; - - cb_data->return_data = new_export; - - export = export->ex_next; - } -} - -struct exportnode * -mount_getexports(const char *server) -{ - struct sync_cb_data cb_data; - struct rpc_context *rpc; - - - cb_data.is_finished = 0; - cb_data.return_data = NULL; - - rpc = rpc_init_context(); - if (mount_getexports_async(rpc, server, mount_getexports_cb, - &cb_data) != 0) { - rpc_destroy_context(rpc); - return NULL; - } - - wait_for_reply(rpc, &cb_data); - rpc_destroy_context(rpc); - - return cb_data.return_data; -} - -void -mount_free_export_list(struct exportnode *exp) -{ - struct exportnode *tmp; - - while ((tmp = exp)) { - exp = exp->ex_next; - free(tmp->ex_dir); - free(tmp); - } -} - - - -void -free_nfs_srvr_list(struct nfs_server_list *srv) -{ - while (srv != NULL) { - struct nfs_server_list *next = srv->next; - - free(srv->addr); - free(srv); - srv = next; - } -} - -struct nfs_list_data { - int status; - struct nfs_server_list *srvrs; -}; - -void -callit_cb(struct rpc_context *rpc, int status, void *data _U_ ,void *private_data) -{ - struct nfs_list_data *srv_data = private_data; - struct sockaddr *sin; - char hostdd[16]; - struct nfs_server_list *srvr; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status == RPC_STATUS_CANCEL) { - return; - } - if (status != 0) { - srv_data->status = -1; - return; - } - - sin = rpc_get_recv_sockaddr(rpc); - if (sin == NULL) { - rpc_set_error(rpc, "failed to get sockaddr in CALLIT callback"); - srv_data->status = -1; - return; - } - - //if (getnameinfo(sin, sizeof(struct sockaddr_in), &hostdd[0], - // sizeof(hostdd), NULL, 0, NI_NUMERICHOST) < 0) { - // rpc_set_error(rpc, "getnameinfo failed in CALLIT callback"); - // srv_data->status = -1; - // return; - //} - - /* check for dupes */ - for (srvr = srv_data->srvrs; srvr; srvr = srvr->next) { - if (!strcmp(hostdd, srvr->addr)) { - return; - } - } - - srvr = malloc(sizeof(struct nfs_server_list)); - if (srvr == NULL) { - rpc_set_error(rpc, "Malloc failed when allocating server " - "structure"); - srv_data->status = -1; - return; - } - - srvr->addr = strdup(hostdd); - if (srvr->addr == NULL) { - rpc_set_error(rpc, "Strdup failed when allocating server " - "structure"); - free(srvr); - srv_data->status = -1; - return; - } - - srvr->next = srv_data->srvrs; - srv_data->srvrs = srvr; -} - -#ifdef WIN32 - -static int -send_nfsd_probes(struct rpc_context *rpc, INTERFACE_INFO *InterfaceList, - int numIfs, struct nfs_list_data *data) -{ - int i=0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - for(i = 0; i < numIfs; i++) - { - SOCKADDR *pAddress; - char bcdd[16]; - unsigned long nFlags = 0; - - pAddress = (SOCKADDR *) & (InterfaceList[i].iiBroadcastAddress); - - if(pAddress->sa_family != AF_INET) - continue; - - nFlags = InterfaceList[i].iiFlags; - - if (!(nFlags & IFF_UP)) - { - continue; - } - - if (nFlags & IFF_LOOPBACK) - { - continue; - } - - if (!(nFlags & IFF_BROADCAST)) - { - continue; - } - - //if (getnameinfo(pAddress, sizeof(struct sockaddr_in), &bcdd[0], sizeof(bcdd), NULL, 0, NI_NUMERICHOST) < 0) - //{ - // continue; - //} - - if (rpc_set_udp_destination(rpc, bcdd, 111, 1) < 0) - { - return -1; - } - - if (rpc_pmap2_callit_async(rpc, MOUNT_PROGRAM, 2, 0, NULL, 0, callit_cb, data) < 0) - { - return -1; - } - } - return 0; -} - -struct nfs_server_list * -nfs_find_local_servers(void) -{ - struct rpc_context *rpc; - struct nfs_list_data data = {0, NULL}; - struct timeval tv_start, tv_current; - int loop; - struct pollfd pfd; - INTERFACE_INFO InterfaceList[20]; - unsigned long nBytesReturned; - int nNumInterfaces = 0; - - rpc = rpc_init_udp_context(); - if (rpc == NULL) - { - return NULL; - } - - if (rpc_bind_udp(rpc, "0.0.0.0", 0) < 0) - { - rpc_destroy_context(rpc); - return NULL; - } - - if (WSAIoctl(rpc_get_fd(rpc), SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList, sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR) - { - return NULL; - } - - nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO); - - for (loop=0; loop<3; loop++) - { - if (send_nfsd_probes(rpc, InterfaceList, nNumInterfaces, &data) != 0) - { - rpc_destroy_context(rpc); - return NULL; - } - - win32_gettimeofday(&tv_start, NULL); - for(;;) - { - int mpt; - - pfd.fd = rpc_get_fd(rpc); - pfd.events = rpc_which_events(rpc); - - win32_gettimeofday(&tv_current, NULL); - mpt = 1000 - - (tv_current.tv_sec *1000 + tv_current.tv_usec / 1000) - + (tv_start.tv_sec *1000 + tv_start.tv_usec / 1000); - - if (poll(&pfd, 1, mpt) < 0) - { - free_nfs_srvr_list(data.srvrs); - rpc_destroy_context(rpc); - return NULL; - } - if (pfd.revents == 0) - { - break; - } - - if (rpc_service(rpc, pfd.revents) < 0) - { - break; - } - } - } - - rpc_destroy_context(rpc); - - if (data.status != 0) - { - free_nfs_srvr_list(data.srvrs); - return NULL; - } - return data.srvrs; -} -#else - -static int -send_nfsd_probes(struct rpc_context *rpc, struct ifconf *ifc, - struct nfs_list_data *data) -{ - char *ptr; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - for (ptr =(char *)(ifc->ifc_buf); - ptr < (char *)(ifc->ifc_buf) + ifc->ifc_len; - ) { - struct ifreq ifr; - char bcdd[16]; - - memcpy(&ifr, ptr, sizeof(struct ifreq)); -#ifdef HAVE_SOCKADDR_LEN - if (ifr.ifr_addr.sa_len > sizeof(struct sockaddr)) { - ptr += sizeof(ifr.ifr_name) + ifr.ifr_addr.sa_len; - } else { - ptr += sizeof(ifr.ifr_name) + sizeof(struct sockaddr); - } -#else - ptr += sizeof(struct ifreq); -#endif - - if (ifr.ifr_addr.sa_family != AF_INET) { - continue; - } - if (ioctl(rpc_get_fd(rpc), SIOCGIFFLAGS, &ifr) < 0) { - return -1; - } - if (!(ifr.ifr_flags & IFF_UP)) { - continue; - } - if (ifr.ifr_flags & IFF_LOOPBACK) { - continue; - } - if (!(ifr.ifr_flags & IFF_BROADCAST)) { - continue; - } - if (ioctl(rpc_get_fd(rpc), SIOCGIFBRDADDR, &ifr) < 0) { - continue; - } - //if (getnameinfo(&ifr.ifr_broadaddr, sizeof(struct sockaddr_in), - // &bcdd[0], sizeof(bcdd), NULL, 0, - // NI_NUMERICHOST) < 0) { - // continue; - //} - if (rpc_set_udp_destination(rpc, bcdd, 111, 1) < 0) { - return -1; - } - - if (rpc_pmap2_callit_async(rpc, MOUNT_PROGRAM, 2, 0, NULL, 0, - callit_cb, data) < 0) { - return -1; - } - } - - return 0; -} - -struct nfs_server_list * -nfs_find_local_servers(void) -{ - struct rpc_context *rpc; - struct nfs_list_data data = {0, NULL}; - struct timeval tv_start, tv_current; - struct ifconf ifc; - int size, loop; - struct pollfd pfd; - - rpc = rpc_init_udp_context(); - if (rpc == NULL) { - return NULL; - } - - if (rpc_bind_udp(rpc, "0.0.0.0", 0) < 0) { - rpc_destroy_context(rpc); - return NULL; - } - - - /* get list of all interfaces */ - size = sizeof(struct ifreq); - ifc.ifc_buf = NULL; - ifc.ifc_len = size; - - while(ifc.ifc_len > (size - sizeof(struct ifreq))) { - size *= 2; - - free(ifc.ifc_buf); - ifc.ifc_len = size; - ifc.ifc_buf = malloc(size); - memset(ifc.ifc_buf, 0, size); - if (ioctl(rpc_get_fd(rpc), SIOCGIFCONF, (caddr_t)&ifc) < 0) { - rpc_destroy_context(rpc); - free(ifc.ifc_buf); - return NULL; - } - } - - for (loop=0; loop<3; loop++) { - if (send_nfsd_probes(rpc, &ifc, &data) != 0) { - rpc_destroy_context(rpc); - free(ifc.ifc_buf); - return NULL; - } - - gettimeofday(&tv_start, NULL); - for(;;) { - int mpt; - - pfd.fd = rpc_get_fd(rpc); - pfd.events = rpc_which_events(rpc); - - gettimeofday(&tv_current, NULL); - mpt = 1000 - - (tv_current.tv_sec *1000 + tv_current.tv_usec / 1000) - + (tv_start.tv_sec *1000 + tv_start.tv_usec / 1000); - - if (poll(&pfd, 1, mpt) < 0) { - free_nfs_srvr_list(data.srvrs); - rpc_destroy_context(rpc); - return NULL; - } - if (pfd.revents == 0) { - break; - } - - if (rpc_service(rpc, pfd.revents) < 0) { - break; - } - } - } - - free(ifc.ifc_buf); - rpc_destroy_context(rpc); - - if (data.status != 0) { - free_nfs_srvr_list(data.srvrs); - return NULL; - } - return data.srvrs; -} -#endif//WIN32 diff --git a/source/liborbisNfs/libnfs-zdr.c b/source/liborbisNfs/libnfs-zdr.c deleted file mode 100644 index 51e7794..0000000 --- a/source/liborbisNfs/libnfs-zdr.c +++ /dev/null @@ -1,631 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2012 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * This file contains definitions for the built in ZDR implementation. - * This is a very limited ZDR subset that can only marshal to/from a momory buffer, - * i.e. zdrmem_create() buffers. - * It aims to be compatible with normal rpcgen generated functions. - */ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef HAVE_ARPA_INET_H -#include -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#include -#include -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" - -struct zdr_mem { - struct zdr_mem *next; - uint32_t size; - char buf[1]; -}; - -struct opaque_auth _null_auth; - -bool_t libnfs_zdr_setpos(ZDR *zdrs, uint32_t pos) -{ - zdrs->pos = pos; - - return TRUE; -} - -uint32_t libnfs_zdr_getpos(ZDR *zdrs) -{ - return zdrs->pos; -} - -void libnfs_zdrmem_create(ZDR *zdrs, const caddr_t addr, uint32_t size, enum zdr_op xop) -{ - zdrs->x_op = xop; - zdrs->buf = addr; - zdrs->size = size; - zdrs->pos = 0; - zdrs->mem = NULL; -} - -void *zdr_malloc(ZDR *zdrs, uint32_t size) -{ - struct zdr_mem *mem; - int mem_size; - - mem_size = offsetof(struct zdr_mem, buf) + size; - mem = malloc(mem_size); - - mem->next = zdrs->mem; - mem->size = size; - - zdrs->mem = mem; - - return &mem->buf[0]; -} - -void libnfs_zdr_destroy(ZDR *zdrs) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - if(zdrs) - { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s in \n",__FUNCTION__); - - while (zdrs->mem != NULL) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s in while \n",__FUNCTION__); - - struct zdr_mem *mem = zdrs->mem->next; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s in while after next\n",__FUNCTION__); - - //free(zdrs->mem); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s in while after free\n",__FUNCTION__); - - zdrs->mem = mem; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s in while after mem \n",__FUNCTION__); - - } - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - -} - -bool_t libnfs_zdr_u_int(ZDR *zdrs, uint32_t *u) -{ - if (zdrs->pos + 4 > zdrs->size) { - return FALSE; - } - - switch (zdrs->x_op) { - case ZDR_ENCODE: - *(uint32_t *)(void *)&zdrs->buf[zdrs->pos] = htonl(*u); - zdrs->pos += 4; - return TRUE; - case ZDR_DECODE: - *u = ntohl(*(uint32_t *)(void *)&zdrs->buf[zdrs->pos]); - zdrs->pos += 4; - return TRUE; - } - - return FALSE; -} - -bool_t libnfs_zdr_int(ZDR *zdrs, int32_t *i) -{ - return libnfs_zdr_u_int(zdrs, (uint32_t *)i); -} - -bool_t libnfs_zdr_uint64_t(ZDR *zdrs, uint64_t *u) -{ - if (zdrs->pos + 8 > zdrs->size) { - return FALSE; - } - - switch (zdrs->x_op) { - case ZDR_ENCODE: - *(uint32_t *)(void *)&zdrs->buf[zdrs->pos] = htonl((*u >> 32)); - zdrs->pos += 4; - *(uint32_t *)(void *)&zdrs->buf[zdrs->pos] = htonl((*u & 0xffffffff)); - zdrs->pos += 4; - return TRUE; - case ZDR_DECODE: - *u = ntohl(*(uint32_t *)(void *)&zdrs->buf[zdrs->pos]); - zdrs->pos += 4; - *u <<= 32; - *u |= (uint32_t)ntohl(*(uint32_t *)(void *)&zdrs->buf[zdrs->pos]); - zdrs->pos += 4; - return TRUE; - } - - return FALSE; -} - -bool_t libnfs_zdr_int64_t(ZDR *zdrs, int64_t *i) -{ - return libnfs_zdr_uint64_t(zdrs, (uint64_t *)i); -} - -bool_t libnfs_zdr_bytes(ZDR *zdrs, char **bufp, uint32_t *size, uint32_t maxsize) -{ - uint32_t zero = 0; - int pad; - - if (!libnfs_zdr_u_int(zdrs, size)) { - return FALSE; - } - - if (zdrs->pos + (int)*size > zdrs->size) { - return FALSE; - } - - switch (zdrs->x_op) { - case ZDR_ENCODE: - memcpy(&zdrs->buf[zdrs->pos], *bufp, *size); - zdrs->pos += *size; - - pad = (4 - (zdrs->pos & 0x03)) & 0x03; - if (pad) { - /* Make valgrind happy again */ - memcpy(&zdrs->buf[zdrs->pos], &zero, pad); - zdrs->pos += pad; - } - return TRUE; - case ZDR_DECODE: - if (*bufp != NULL) { - memcpy(*bufp, &zdrs->buf[zdrs->pos], *size); - } else { - *bufp = &zdrs->buf[zdrs->pos]; - } - zdrs->pos += *size; - zdrs->pos = (zdrs->pos + 3) & ~3; - return TRUE; - } - - return FALSE; -} - - -bool_t libnfs_zdr_enum(ZDR *zdrs, enum_t *e) -{ - bool_t ret; - int32_t i = *e; - - ret = libnfs_zdr_u_int(zdrs, (uint32_t *)&i); - *e = i; - - return ret; -} - -bool_t libnfs_zdr_bool(ZDR *zdrs, bool_t *b) -{ - return libnfs_zdr_u_int(zdrs, (uint32_t *)b); -} - -bool_t libnfs_zdr_void(ZDR *zdrs, void *v) -{ - return TRUE; -} - -bool_t libnfs_zdr_pointer(ZDR *zdrs, char **objp, uint32_t size, zdrproc_t proc) -{ - bool_t more_data; - - more_data = (*objp != NULL); - - if (!libnfs_zdr_bool(zdrs, &more_data)) { - return FALSE; - } - if (more_data == 0) { - *objp = NULL; - return TRUE; - } - - if (zdrs->x_op == ZDR_DECODE) { - *objp = zdr_malloc(zdrs, size); - if (*objp == NULL) { - return FALSE; - } - memset(*objp, 0, size); - } - return proc(zdrs, *objp); -} - -bool_t libnfs_zdr_opaque(ZDR *zdrs, char *objp, uint32_t size) -{ - switch (zdrs->x_op) { - case ZDR_ENCODE: - memcpy(&zdrs->buf[zdrs->pos], objp, size); - zdrs->pos += size; - if (zdrs->pos & 3) { - memset(&zdrs->buf[zdrs->pos], 0x00, 4 - (zdrs->pos & 3)); - } - zdrs->pos = (zdrs->pos + 3) & ~3; - return TRUE; - case ZDR_DECODE: - memcpy(objp, &zdrs->buf[zdrs->pos], size); - zdrs->pos += size; - zdrs->pos = (zdrs->pos + 3) & ~3; - return TRUE; - } - - return FALSE; -} - -bool_t libnfs_zdr_string(ZDR *zdrs, char **strp, uint32_t maxsize) -{ - uint32_t size; - - if (zdrs->x_op == ZDR_ENCODE) { - size = strlen(*strp); - } - - if (!libnfs_zdr_u_int(zdrs, &size)) { - return FALSE; - } - - if (zdrs->pos + (int)size > zdrs->size) { - return FALSE; - } - - switch (zdrs->x_op) { - case ZDR_ENCODE: - return libnfs_zdr_opaque(zdrs, *strp, size); - case ZDR_DECODE: - /* If the we string is null terminated we can just return it - * in place. - */ - if (zdrs->size > zdrs->pos + (int)size && zdrs->buf[zdrs->pos + size] == 0) { - if (*strp == NULL) { - *strp = &zdrs->buf[zdrs->pos]; - (*strp)[size] = 0; - zdrs->pos += size; - zdrs->pos = (zdrs->pos + 3) & ~3; - return TRUE; - } - (*strp)[size] = 0; - return libnfs_zdr_opaque(zdrs, *strp, size); - } - - /* Crap. The string is not null terminated in the rx buffer. - * we have to allocate a buffer so we can add the null byte. - */ - *strp = zdr_malloc(zdrs, size + 1); - if (*strp == NULL) { - return FALSE; - } - (*strp)[size] = 0; - return libnfs_zdr_opaque(zdrs, *strp, size); - } - - return FALSE; -} - -bool_t libnfs_zdr_array(ZDR *zdrs, char **arrp, uint32_t *size, uint32_t maxsize, uint32_t elsize, zdrproc_t proc) -{ - int i; - uint32_t s; - - if (*size > UINT32_MAX/elsize) { - return FALSE; - } - s = *size * elsize; - - if (!libnfs_zdr_u_int(zdrs, size)) { - return FALSE; - } - - if (zdrs->x_op == ZDR_DECODE) { - *arrp = zdr_malloc(zdrs, s); - if (*arrp == NULL) { - return FALSE; - } - memset(*arrp, 0, s); - } - - for (i = 0; i < (int)*size; i++) { - if (!proc(zdrs, *arrp + i * elsize)) { - return FALSE; - } - } - return TRUE; -} - -void libnfs_zdr_free(zdrproc_t proc, char *objp) -{ -} - -static bool_t libnfs_opaque_auth(ZDR *zdrs, struct opaque_auth *auth) -{ - if (!libnfs_zdr_u_int(zdrs, &auth->oa_flavor)) { - return FALSE; - } - - if (!libnfs_zdr_bytes(zdrs, &auth->oa_base, &auth->oa_length, auth->oa_length)) { - return FALSE; - } - - return TRUE; -} - -static bool_t libnfs_rpc_call_body(struct rpc_context *rpc, ZDR *zdrs, struct call_body *cmb) -{ - if (!libnfs_zdr_u_int(zdrs, &cmb->rpcvers)) { - rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode " - "RPCVERS"); - return FALSE; - } - - if (!libnfs_zdr_u_int(zdrs, &cmb->prog)) { - rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode " - "PROG"); - return FALSE; - } - - if (!libnfs_zdr_u_int(zdrs, &cmb->vers)) { - rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode " - "VERS"); - return FALSE; - } - - if (!libnfs_zdr_u_int(zdrs, &cmb->proc)) { - rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode " - "PROC"); - return FALSE; - } - - if (!libnfs_opaque_auth(zdrs, &cmb->cred)) { - rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode " - "CRED"); - return FALSE; - } - - if (!libnfs_opaque_auth(zdrs, &cmb->verf)) { - rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode " - "VERF"); - return FALSE; - } - - return TRUE; -} - -static bool_t libnfs_accepted_reply(ZDR *zdrs, struct accepted_reply *ar) -{ - if (!libnfs_opaque_auth(zdrs, &ar->verf)) { - return FALSE; - } - - if (!libnfs_zdr_u_int(zdrs, &ar->stat)) { - return FALSE; - } - - switch (ar->stat) { - case SUCCESS: - if (!ar->reply_data.results.proc(zdrs, ar->reply_data.results.where)) { - return FALSE; - } - return TRUE; - case PROG_MISMATCH: - if (!libnfs_zdr_u_int(zdrs, &ar->reply_data.mismatch_info.low)) { - return FALSE; - } - if (!libnfs_zdr_u_int(zdrs, &ar->reply_data.mismatch_info.high)) { - return FALSE; - } - return TRUE; - default: - return TRUE; - } - - return FALSE; -} - -static bool_t libnfs_rejected_reply(ZDR *zdrs, struct rejected_reply *rr) -{ - if (!libnfs_zdr_u_int(zdrs, (uint32_t *)&rr->stat)) { - return FALSE; - } - - switch (rr->stat) { - case RPC_MISMATCH: - if (!libnfs_zdr_u_int(zdrs, &rr->reject_data.mismatch_info.low)) { - return FALSE; - } - if (!libnfs_zdr_u_int(zdrs, &rr->reject_data.mismatch_info.high)) { - return FALSE; - } - return TRUE; - case AUTH_ERROR: - if (!libnfs_zdr_u_int(zdrs, (uint32_t *)&rr->reject_data.stat)) { - return FALSE; - } - return TRUE; - default: - return TRUE; - } - - return FALSE; -} - -static bool_t libnfs_rpc_reply_body(struct rpc_context *rpc, ZDR *zdrs, struct reply_body *rmb) -{ - if (!libnfs_zdr_u_int(zdrs, &rmb->stat)) { - rpc_set_error(rpc, "libnfs_rpc_reply_body failed to decode " - "STAT"); - return FALSE; - } - - switch (rmb->stat) { - case MSG_ACCEPTED: - if (!libnfs_accepted_reply(zdrs, &rmb->reply.areply)) { - rpc_set_error(rpc, "libnfs_rpc_reply_body failed to " - "decode ACCEPTED"); - return FALSE; - } - return TRUE; - case MSG_DENIED: - if (!libnfs_rejected_reply(zdrs, &rmb->reply.rreply)) { - rpc_set_error(rpc, "libnfs_rpc_reply_body failed to " - "decode DENIED"); - return FALSE; - } - return TRUE; - } - - rpc_set_error(rpc, "libnfs_rpc_reply_body failed to " - "decode. Neither ACCEPTED nor DENIED"); - return FALSE; -} - -static bool_t libnfs_rpc_msg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg) -{ - int ret; - - if (!libnfs_zdr_u_int(zdrs, &msg->xid)) { - rpc_set_error(rpc, "libnfs_rpc_msg failed to decode XID"); - return FALSE; - } - - if (!libnfs_zdr_u_int(zdrs, &msg->direction)) { - rpc_set_error(rpc, "libnfs_rpc_msg failed to decode DIRECTION"); - return FALSE; - } - - switch (msg->direction) { - case CALL: - ret = libnfs_rpc_call_body(rpc, zdrs, &msg->body.cbody); - if (!ret) { - rpc_set_error(rpc, "libnfs_rpc_msg failed to encode " - "CALL, ret=%d: %s", ret, rpc_get_error(rpc)); - } - return ret; - case REPLY: - ret = libnfs_rpc_reply_body(rpc, zdrs, &msg->body.rbody); - if (!ret) { - rpc_set_error(rpc, "libnfs_rpc_msg failed to decode " - "REPLY, ret=%d: %s", ret, rpc_get_error(rpc)); - } - return ret; - default: - rpc_set_error(rpc, "libnfs_rpc_msg failed to decode. " - "Neither CALL not REPLY"); - return FALSE; - } -} - -bool_t libnfs_zdr_callmsg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg) -{ - return libnfs_rpc_msg(rpc, zdrs, msg); -} - -bool_t libnfs_zdr_replymsg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg) -{ - return libnfs_rpc_msg(rpc, zdrs, msg); -} - -struct AUTH *authnone_create(void) -{ - struct AUTH *auth; - - auth = malloc(sizeof(struct AUTH)); - - auth->ah_cred.oa_flavor = AUTH_NONE; - auth->ah_cred.oa_length = 0; - auth->ah_cred.oa_base = NULL; - - auth->ah_verf.oa_flavor = AUTH_NONE; - auth->ah_verf.oa_length = 0; - auth->ah_verf.oa_base = NULL; - - auth->ah_private = NULL; - - return auth; -} - -struct AUTH *libnfs_authunix_create(const char *host, uint32_t uid, uint32_t gid, uint32_t len, uint32_t *groups) -{ - struct AUTH *auth; - int size; - uint32_t *buf; - int idx; - - size = 4 + 4 + ((strlen(host) + 3) & ~3) + 4 + 4 + 4 + len * 4; - auth = malloc(sizeof(struct AUTH)); - memset(auth, 0x00, sizeof(struct AUTH)); - auth->ah_cred.oa_flavor = AUTH_UNIX; - auth->ah_cred.oa_length = size; - auth->ah_cred.oa_base = malloc(size); - - memset(auth->ah_cred.oa_base, 0x00, size); - buf = (uint32_t *)(void *)auth->ah_cred.oa_base; - idx = 0; - buf[idx++] = htonl((uint32_t)rpc_current_time()); - buf[idx++] = htonl(strlen(host)); - memcpy(&buf[2], host, strlen(host)); - - idx += (strlen(host) + 3) >> 2; - buf[idx++] = htonl(uid); - buf[idx++] = htonl(gid); - buf[idx++] = htonl(len); - while (len-- > 0) { - buf[idx++] = htonl(*groups++); - } - - auth->ah_verf.oa_flavor = AUTH_NONE; - auth->ah_verf.oa_length = 0; - auth->ah_verf.oa_base = NULL; - - auth->ah_private = NULL; - - return auth; -} - -struct AUTH *libnfs_authunix_create_default(void) -{ -#ifdef WIN32 - return libnfs_authunix_create("libnfs", 65534, 65534, 0, NULL); -#else - return libnfs_authunix_create("libnfs", getuid(), getgid(), 0, NULL); -#endif -} - -void libnfs_auth_destroy(struct AUTH *auth) -{ - if (auth->ah_cred.oa_base) { - free(auth->ah_cred.oa_base); - } - if (auth->ah_verf.oa_base) { - free(auth->ah_verf.oa_base); - } - free(auth); -} - diff --git a/source/liborbisNfs/libnfs.c b/source/liborbisNfs/libnfs.c deleted file mode 100755 index c9586ac..0000000 --- a/source/liborbisNfs/libnfs.c +++ /dev/null @@ -1,2074 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * High level api to nfs filesystems - */ -#ifndef _GNU_SOURCE -#define _GNU_SOURCE -#endif - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef HAVE_UTIME_H -#include -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#ifdef HAVE_SYS_VFS_H -#include -#endif - -#ifdef HAVE_SYS_STATVFS_H -#include -#endif - -#if defined(__ANDROID__) && !defined(HAVE_SYS_STATVFS_H) -#define statvfs statfs -#endif - -#ifdef HAVE_NETINET_IN_H -#include -#endif - -#ifdef HAVE_STRINGS_H -#include -#endif - -#ifdef HAVE_SYS_SYSMACROS_H -#include -#endif - -#ifdef HAVE_SYS_TIME_H -#include -#endif - -#include -#include -#include -#include -#include -#include "slist.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-raw-mount.h" -#include "libnfs-raw-portmap.h" -#include "libnfs-private.h" - -void -nfs_free_nfsdir(struct nfsdir *nfsdir) -{ - while (nfsdir->entries) { - struct nfsdirent *dirent = nfsdir->entries->next; - if (nfsdir->entries->name != NULL) { - free(nfsdir->entries->name); - } - free(nfsdir->entries); - nfsdir->entries = dirent; - } - free(nfsdir->fh.val); - free(nfsdir); -} - -void -nfs_dircache_add(struct nfs_context *nfs, struct nfsdir *nfsdir) -{ - int i = 0; - LIBNFS_LIST_ADD(&nfs->dircache, nfsdir); - - for (nfsdir = nfs->dircache; nfsdir; nfsdir = nfsdir->next, i++) { - if (i > MAX_DIR_CACHE) { - LIBNFS_LIST_REMOVE(&nfs->dircache, nfsdir); - nfs_free_nfsdir(nfsdir); - break; - } - } -} - -struct nfsdir * -nfs_dircache_find(struct nfs_context *nfs, struct nfs_fh *fh) -{ - struct nfsdir *nfsdir; - - for (nfsdir = nfs->dircache; nfsdir; nfsdir = nfsdir->next) { - if (nfsdir->fh.len == fh->len && - !memcmp(nfsdir->fh.val, fh->val, fh->len)) { - LIBNFS_LIST_REMOVE(&nfs->dircache, nfsdir); - return nfsdir; - } - } - - return NULL; -} - -void -nfs_dircache_drop(struct nfs_context *nfs, struct nfs_fh *fh) -{ - struct nfsdir *cached; - - cached = nfs_dircache_find(nfs, fh); - if (cached) { - nfs_free_nfsdir(cached); - } -} - -static uint32_t -nfs_pagecache_hash(struct nfs_pagecache *pagecache, uint64_t offset) { - return (2654435761UL * (1 + ((uint32_t)(offset) / NFS_BLKSIZE))) & - (pagecache->num_entries - 1); -} - -void -nfs_pagecache_invalidate(struct nfs_context *nfs, struct nfsfh *nfsfh) { - if (nfsfh->pagecache.entries) { - RPC_LOG(nfs->rpc, 2, "invalidating pagecache"); - memset(nfsfh->pagecache.entries, 0x00, - sizeof(struct nfs_pagecache_entry) * - nfsfh->pagecache.num_entries); - } -} - -void -nfs_pagecache_put(struct nfs_pagecache *pagecache, uint64_t offset, - const char *buf, size_t len) -{ - time_t ts = pagecache->ttl ? (time_t)(rpc_current_time() / 1000) : 1; - if (!pagecache->num_entries) return; - while (len > 0) { - uint64_t page_offset = offset & ~(NFS_BLKSIZE - 1); - uint32_t entry = nfs_pagecache_hash(pagecache, page_offset); - struct nfs_pagecache_entry *e = &pagecache->entries[entry]; - size_t n = MIN(NFS_BLKSIZE - offset % NFS_BLKSIZE, len); - - /* we can only write to the cache if we add a full page or - * partially update a page that is still valid */ - if (n == NFS_BLKSIZE || - (e->ts && e->offset == page_offset && - (!pagecache->ttl || ts - e->ts <= pagecache->ttl))) { - e->ts = ts; - e->offset = page_offset; - memcpy(e->buf + offset % NFS_BLKSIZE, buf, n); - } - buf += n; - offset += n; - len -= n; - } -} - -char * -nfs_pagecache_get(struct nfs_pagecache *pagecache, uint64_t offset) -{ - uint32_t entry; - struct nfs_pagecache_entry *e; - - entry = nfs_pagecache_hash(pagecache, offset); - e = &pagecache->entries[entry]; - - if (offset != e->offset) { - return NULL; - } - if (!e->ts) { - return NULL; - } - if (pagecache->ttl && (time_t)(rpc_current_time() / 1000) - e->ts > pagecache->ttl) { - return NULL; - } - - return e->buf; -} - -void nfs_pagecache_init(struct nfs_context *nfs, struct nfsfh *nfsfh) { - /* init page cache */ - if (nfs->rpc->pagecache) { - nfsfh->pagecache.num_entries = nfs->rpc->pagecache; - nfsfh->pagecache.ttl = nfs->rpc->pagecache_ttl; - nfsfh->pagecache.entries = malloc(sizeof(struct nfs_pagecache_entry) * nfsfh->pagecache.num_entries); - nfs_pagecache_invalidate(nfs, nfsfh); - RPC_LOG(nfs->rpc, 2, "init pagecache entries %d pagesize %d\n", - nfsfh->pagecache.num_entries, NFS_BLKSIZE); - } -} - -void -nfs_set_auth(struct nfs_context *nfs, struct AUTH *auth) -{ - rpc_set_auth(nfs->rpc, auth); -} - -int -nfs_get_fd(struct nfs_context *nfs) -{ - return rpc_get_fd(nfs->rpc); -} - -int -nfs_queue_length(struct nfs_context *nfs) -{ - return rpc_queue_length(nfs->rpc); -} - -int -nfs_which_events(struct nfs_context *nfs) -{ - return rpc_which_events(nfs->rpc); -} - -int -nfs_service(struct nfs_context *nfs, int revents) -{ - return rpc_service(nfs->rpc, revents); -} - -char * -nfs_get_error(struct nfs_context *nfs) -{ - return rpc_get_error(nfs->rpc); -}; - -#ifdef HAVE_SO_BINDTODEVICE -void -nfs_set_interface(struct nfs_context *nfs, const char *ifname) -{ - rpc_set_interface(nfs_get_rpc_context(nfs), ifname); -} -#endif - -static int -nfs_set_context_args(struct nfs_context *nfs, const char *arg, const char *val) -{ - if (!strcmp(arg, "tcp-syncnt")) { - rpc_set_tcp_syncnt(nfs_get_rpc_context(nfs), atoi(val)); - } else if (!strcmp(arg, "uid")) { - rpc_set_uid(nfs_get_rpc_context(nfs), atoi(val)); - } else if (!strcmp(arg, "gid")) { - rpc_set_gid(nfs_get_rpc_context(nfs), atoi(val)); - } else if (!strcmp(arg, "readahead")) { - rpc_set_readahead(nfs_get_rpc_context(nfs), atoi(val)); - } else if (!strcmp(arg, "pagecache")) { - rpc_set_pagecache(nfs_get_rpc_context(nfs), atoi(val)); - } else if (!strcmp(arg, "debug")) { - rpc_set_debug(nfs_get_rpc_context(nfs), atoi(val)); - } else if (!strcmp(arg, "auto-traverse-mounts")) { - nfs->auto_traverse_mounts = atoi(val); - } else if (!strcmp(arg, "dircache")) { - nfs_set_dircache(nfs, atoi(val)); - } else if (!strcmp(arg, "autoreconnect")) { - nfs_set_autoreconnect(nfs, atoi(val)); -#ifdef HAVE_SO_BINDTODEVICE - } else if (!strcmp(arg, "if")) { - nfs_set_interface(nfs, val); -#endif - } else if (!strcmp(arg, "version")) { - if (nfs_set_version(nfs, atoi(val)) < 0) { - nfs_set_error(nfs, "NFS version %d is not supported", - atoi(val)); - return -1; - } - } else if (!strcmp(arg, "nfsport")) { - nfs->nfsport = atoi(val); - } else if (!strcmp(arg, "mountport")) { - nfs->mountport = atoi(val); - } - return 0; -} - -static struct nfs_url * -nfs_parse_url(struct nfs_context *nfs, const char *url, int dir, int incomplete) -{ - struct nfs_url *urls; - char *strp, *flagsp, *strp2; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - if (strncmp(url, "nfs://", 6)) { - nfs_set_error(nfs, "Invalid URL specified"); - return NULL; - } - - urls = malloc(sizeof(struct nfs_url)); - if (urls == NULL) { - nfs_set_error(nfs, "Out of memory"); - return NULL; - } - - memset(urls, 0x00, sizeof(struct nfs_url)); - urls->server = strdup(url + 6); - if (urls->server == NULL) { - nfs_destroy_url(urls); - nfs_set_error(nfs, "Out of memory"); - return NULL; - } - - if (urls->server[0] == '/' || urls->server[0] == '\0' || - urls->server[0] == '?') { - if (incomplete) { - flagsp = strchr(urls->server, '?'); - goto flags; - } - nfs_destroy_url(urls); - nfs_set_error(nfs, "Invalid server string"); - return NULL; - } - - strp = strchr(urls->server, '/'); - if (strp == NULL) { - if (incomplete) { - flagsp = strchr(urls->server, '?'); - goto flags; - } - nfs_destroy_url(urls); - nfs_set_error(nfs, "Incomplete or invalid URL specified."); - return NULL; - } - - urls->path = strdup(strp); - if (urls->path == NULL) { - nfs_destroy_url(urls); - nfs_set_error(nfs, "Out of memory"); - return NULL; - } - *strp = 0; - - if (dir) { - flagsp = strchr(urls->path, '?'); - goto flags; - } - - strp = strrchr(urls->path, '/'); - if (strp == NULL) { - if (incomplete) { - flagsp = strchr(urls->path, '?'); - goto flags; - } - nfs_destroy_url(urls); - nfs_set_error(nfs, "Incomplete or invalid URL specified."); - return NULL; - } - urls->file = strdup(strp); - if (urls->path == NULL) { - nfs_destroy_url(urls); - nfs_set_error(nfs, "Out of memory"); - return NULL; - } - *strp = 0; - flagsp = strchr(urls->file, '?'); - -flags: - if (flagsp) { - *flagsp = 0; - } - - if (urls->file && !strlen(urls->file)) { - free(urls->file); - urls->file = NULL; - if (!incomplete) { - nfs_destroy_url(urls); - nfs_set_error(nfs, "Incomplete or invalid URL " - "specified."); - return NULL; - } - } - - while (flagsp != NULL && *(flagsp+1) != 0) { - strp = flagsp + 1; - flagsp = strchr(strp, '&'); - if (flagsp) { - *flagsp = 0; - } - strp2 = strchr(strp, '='); - if (strp2) { - *strp2 = 0; - strp2++; - nfs_set_context_args(nfs, strp, strp2); - } - } - - if (urls->server && strlen(urls->server) <= 1) { - free(urls->server); - urls->server = NULL; - } - - return urls; -} - -struct nfs_url * -nfs_parse_url_full(struct nfs_context *nfs, const char *url) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - return nfs_parse_url(nfs, url, 0, 0); -} - -struct nfs_url * -nfs_parse_url_dir(struct nfs_context *nfs, const char *url) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - return nfs_parse_url(nfs, url, 1, 0); -} - -struct nfs_url * -nfs_parse_url_incomplete(struct nfs_context *nfs, const char *url) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - return nfs_parse_url(nfs, url, 0, 1); -} - - -void -nfs_destroy_url(struct nfs_url *url) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - if (url) { - free(url->server); - free(url->path); - free(url->file); - } - free(url); -} - -#define MAX_CLIENT_NAME 64 - -struct nfs_context * -nfs_init_context(void) -{ - struct nfs_context *nfs; - int i; - uint64_t v; - verifier4 verifier; - char client_name[MAX_CLIENT_NAME]; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - nfs = malloc(sizeof(struct nfs_context)); - if (nfs == NULL) { - return NULL; - } - memset(nfs, 0, sizeof(struct nfs_context)); - - nfs->rpc = rpc_init_context(); - if (nfs->rpc == NULL) { - free(nfs); - return NULL; - } - - nfs->cwd = strdup("/"); - nfs->mask = 022; - nfs->auto_traverse_mounts = 1; - nfs->dircache_enabled = 1; - /* Default is never give up, never surrender */ - nfs->auto_reconnect = -1; - nfs->version = NFS_V3; - - /* NFSv4 parameters */ - /* We need a "random" initial verifier */ - v = rpc_current_time() << 32 | getpid(); - for (i = 0; i < NFS4_VERIFIER_SIZE; i++) { - verifier[i] = v & 0xff; - v >>= 8; - } - nfs4_set_verifier(nfs, verifier); - - snprintf(client_name, MAX_CLIENT_NAME, "Libnfs pid:%d %d", getpid(), - (int)time(NULL)); - nfs4_set_client_name(nfs, client_name); - - return nfs; -} - -void -nfs4_set_client_name(struct nfs_context *nfs, const char *client_name) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s client_name=%s\n",__FUNCTION__,client_name); - - nfs->client_name = strdup(client_name); -} - -void -nfs4_set_verifier(struct nfs_context *nfs, const char *verifier) -{ - memcpy(nfs->verifier, verifier, NFS4_VERIFIER_SIZE); -} - -void -nfs_destroy_context(struct nfs_context *nfs) -{ - while (nfs->nested_mounts) { - struct nested_mounts *mnt = nfs->nested_mounts; - - LIBNFS_LIST_REMOVE(&nfs->nested_mounts, mnt); - free(mnt->path); - free(mnt->fh.val); - free(mnt); - } - - rpc_destroy_context(nfs->rpc); - nfs->rpc = NULL; - - free(nfs->server); - nfs->server = NULL; - - free(nfs->export); - nfs->export = NULL; - - free(nfs->cwd); - nfs->cwd = NULL; - - free(nfs->rootfh.val); - nfs->rootfh.len = 0; - nfs->rootfh.val = NULL; - - free(nfs->client_name); - nfs->client_name = NULL; - - while (nfs->dircache) { - struct nfsdir *nfsdir = nfs->dircache; - LIBNFS_LIST_REMOVE(&nfs->dircache, nfsdir); - nfs_free_nfsdir(nfsdir); - } - - free(nfs); -} - -struct rpc_cb_data { - char *server; - uint32_t program; - uint32_t version; - - rpc_cb cb; - void *private_data; -}; - -void free_rpc_cb_data(struct rpc_cb_data *data) -{ - free(data->server); - data->server = NULL; - free(data); -} - -static int -rpc_connect_port_internal(struct rpc_context *rpc, int port, struct rpc_cb_data *data); - -static void -rpc_connect_program_5_cb(struct rpc_context *rpc, int status, - void *command_data, void *private_data) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s \n",__FUNCTION__); - - struct rpc_cb_data *data = private_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Dont want any more callbacks even if the socket is closed */ - rpc->connect_cb = NULL; - - if (status != RPC_STATUS_SUCCESS) { - data->cb(rpc, status, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - - data->cb(rpc, status, NULL, data->private_data); - free_rpc_cb_data(data); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - -} - -static void -rpc_connect_program_4_cb(struct rpc_context *rpc, int status, - void *command_data, void *private_data) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - struct rpc_cb_data *data = private_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Dont want any more callbacks even if the socket is closed */ - rpc->connect_cb = NULL; - - if (status != RPC_STATUS_SUCCESS) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s no success\n",__FUNCTION__); - - data->cb(rpc, status, command_data, data->private_data); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after cb\n",__FUNCTION__); - - free_rpc_cb_data(data); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end no success\n",__FUNCTION__); - - return; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s success\n",__FUNCTION__); - - if (rpc_null_async(rpc, data->program, data->version, - rpc_connect_program_5_cb, data) != 0) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after rpc_null_async\n",__FUNCTION__); - - data->cb(rpc, RPC_STATUS_ERROR, command_data, data->private_data); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after cb\n",__FUNCTION__); - - free_rpc_cb_data(data); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end after null\n",__FUNCTION__); - - return; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - -} - -static void -rpc_connect_program_3_cb(struct rpc_context *rpc, int status, - void *command_data, void *private_data) -{ - struct rpc_cb_data *data = private_data; - struct pmap3_string_result *gar; - uint32_t rpc_port = 0; - char *ptr; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status != RPC_STATUS_SUCCESS) { - data->cb(rpc, status, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - - switch (rpc->s.ss_family) { - case AF_INET: - rpc_port = *(uint32_t *)(void *)command_data; - break; - case AF_INET6: - /* ouch. portmapper and ipv6 are not great */ - gar = command_data; - if (gar->addr == NULL) { - break; - } - ptr = strrchr(gar->addr, '.'); - if (ptr == NULL) { - break; - } - rpc_port = atoi(ptr + 1); - *ptr = 0; - ptr = strrchr(gar->addr, '.'); - if (ptr == NULL) { - break; - } - rpc_port += 256 * atoi(ptr + 1); - break; - } - if (rpc_port == 0) { - rpc_set_error(rpc, "RPC error. Program is not available on %s", - data->server); - data->cb(rpc, RPC_STATUS_ERROR, rpc_get_error(rpc), - data->private_data); - free_rpc_cb_data(data); - return; - } - - rpc_disconnect(rpc, "normal disconnect"); - if (rpc_connect_port_internal(rpc, rpc_port, data)) { - data->cb(rpc, RPC_STATUS_ERROR, command_data, - data->private_data); - free_rpc_cb_data(data); - return; - } -} - -static void -rpc_connect_program_2_cb(struct rpc_context *rpc, int status, - void *command_data, void *private_data) -{ - struct rpc_cb_data *data = private_data; - struct pmap3_mapping map; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status != RPC_STATUS_SUCCESS) { - data->cb(rpc, status, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - - switch (rpc->s.ss_family) { - case AF_INET: - if (rpc_pmap2_getport_async(rpc, data->program, data->version, - IPPROTO_TCP, - rpc_connect_program_3_cb, - private_data) != 0) { - data->cb(rpc, RPC_STATUS_ERROR, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - break; - case AF_INET6: - map.prog=data->program; - map.vers=data->version; - map.netid=""; - map.addr=""; - map.owner=""; - if (rpc_pmap3_getaddr_async(rpc, &map, - rpc_connect_program_3_cb, - private_data) != 0) { - data->cb(rpc, RPC_STATUS_ERROR, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - break; - } -} - -static void -rpc_connect_program_1_cb(struct rpc_context *rpc, int status, - void *command_data, void *private_data) -{ - struct rpc_cb_data *data = private_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Dont want any more callbacks even if the socket is closed */ - rpc->connect_cb = NULL; - - if (status != RPC_STATUS_SUCCESS) { - data->cb(rpc, status, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - - switch (rpc->s.ss_family) { - case AF_INET: - if (rpc_pmap2_null_async(rpc, rpc_connect_program_2_cb, - data) != 0) { - data->cb(rpc, RPC_STATUS_ERROR, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - break; - case AF_INET6: - if (rpc_pmap3_null_async(rpc, rpc_connect_program_2_cb, - data) != 0) { - data->cb(rpc, RPC_STATUS_ERROR, command_data, data->private_data); - free_rpc_cb_data(data); - return; - } - break; - } -} - -static int -rpc_connect_port_internal(struct rpc_context *rpc, int port, struct rpc_cb_data *data) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - if (rpc_connect_async(rpc, data->server, port, - rpc_connect_program_4_cb, data) != 0) { - return -1; - } - - return 0; -} - -int -rpc_connect_port_async(struct rpc_context *rpc, const char *server, - int port, - int program, int version, - rpc_cb cb, void *private_data) -{ - struct rpc_cb_data *data; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - data = malloc(sizeof(struct rpc_cb_data)); - if (data == NULL) { - debugNetPrintf(2,"[LIBNFS] %s error malloc\n",__FUNCTION__); - - return -1; - } - memset(data, 0, sizeof(struct rpc_cb_data)); - data->server = strdup(server); - data->program = program; - data->version = version; - - data->cb = cb; - data->private_data = private_data; - - if (rpc_connect_port_internal(rpc, port, data)) { - rpc_set_error(rpc, "Failed to start connection. %s", - rpc_get_error(rpc)); - free_rpc_cb_data(data); - return -1; - } - return 0; -} - -int -rpc_connect_program_async(struct rpc_context *rpc, const char *server, - int program, int version, - rpc_cb cb, void *private_data) -{ - struct rpc_cb_data *data; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - data = malloc(sizeof(struct rpc_cb_data)); - if (data == NULL) { - debugNetPrintf(2,"[LIBNFS] %s error malloc\n",__FUNCTION__); - - return -1; - } - memset(data, 0, sizeof(struct rpc_cb_data)); - data->server = strdup(server); - data->program = program; - data->version = version; - - data->cb = cb; - data->private_data = private_data; - - if (rpc_connect_async(rpc, server, 111, rpc_connect_program_1_cb, - data) != 0) { - rpc_set_error(rpc, "Failed to start connection. %s", - rpc_get_error(rpc)); - free_rpc_cb_data(data); - return -1; - } - return 0; -} - -void -free_nfs_cb_data(struct nfs_cb_data *data) -{ - if (data->continue_data != NULL) { - assert(data->free_continue_data); - data->free_continue_data(data->continue_data); - } - - free(data->saved_path); - free(data->fh.val); - if (!data->not_my_buffer) { - free(data->buffer); - } - - free(data); -} - -void -nfs_free_nfsfh(struct nfsfh *nfsfh) -{ - if (nfsfh->fh.val != NULL) { - free(nfsfh->fh.val); - nfsfh->fh.len = 0; - nfsfh->fh.val = NULL; - } - free(nfsfh->pagecache.entries); - free(nfsfh); -} - -/* - * Async call for mounting an nfs share and geting the root filehandle - */ -int -nfs_mount_async(struct nfs_context *nfs, const char *server, - const char *export, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_mount_async(nfs, server, export, cb, private_data); - case NFS_V4: - return nfs4_mount_async(nfs, server, export, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -/* - * Async call for umounting an nfs share - */ -int -nfs_umount_async(struct nfs_context *nfs, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_umount_async(nfs, cb, private_data); - case NFS_V4: - /* umount is a no-op in v4 */ - (*cb)(0, nfs, NULL, private_data); - return 0; - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_normalize_path(struct nfs_context *nfs, char *path) -{ - char *str; - size_t len; - - /* // -> / */ - while ((str = strstr(path, "//"))) { - while(*str) { - *str = *(str + 1); - str++; - } - } - - /* /./ -> / */ - while ((str = strstr(path, "/./"))) { - while(*(str + 1)) { - *str = *(str + 2); - str++; - } - } - - /* ^/../ -> error */ - if (!strncmp(path, "/../", 4)) { - nfs_set_error(nfs, - "Absolute path starts with '/../' " - "during normalization"); - return -1; - } - - /* ^[^/] -> error */ - if (path[0] != '/') { - nfs_set_error(nfs, - "Absolute path does not start with '/'"); - return -1; - } - - /* /string/../ -> / */ - while ((str = strstr(path, "/../"))) { - char *tmp; - - if (!strncmp(path, "/../", 4)) { - nfs_set_error(nfs, - "Absolute path starts with '/../' " - "during normalization"); - return -1; - } - - tmp = str - 1; - while (*tmp != '/') { - tmp--; - } - str += 3; - while((*(tmp++) = *(str++)) != '\0') - ; - } - - /* /$ -> \0 */ - len = strlen(path); - if (len > 1) { - if (path[len - 1] == '/') { - path[len - 1] = '\0'; - len--; - } - } - if (path[0] == '\0') { - nfs_set_error(nfs, - "Absolute path became '' " - "during normalization"); - return -1; - } - - /* /.$ -> \0 */ - if (len >= 2) { - if (!strcmp(&path[len - 2], "/.")) { - path[len - 2] = '\0'; - len -= 2; - } - } - - /* ^/..$ -> error */ - if (!strcmp(path, "/..")) { - nfs_set_error(nfs, - "Absolute path is '/..' " - "during normalization"); - return -1; - } - - /* /string/..$ -> / */ - if (len >= 3) { - if (!strcmp(&path[len - 3], "/..")) { - char *tmp = &path[len - 3]; - while (*--tmp != '/') - ; - *tmp = '\0'; - } - } - - return 0; -} - -int -nfs_stat_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_stat_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv4", - __FUNCTION__); - return -1; - } -} - -int -nfs_stat64_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_stat64_async(nfs, path, 0, - cb, private_data); - case NFS_V4: - return nfs4_stat64_async(nfs, path, 0, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_lstat64_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_stat64_async(nfs, path, 1, - cb, private_data); - case NFS_V4: - return nfs4_stat64_async(nfs, path, 1, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_open2_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_open_async(nfs, path, flags, mode, - cb, private_data); - case NFS_V4: - return nfs4_open_async(nfs, path, flags, mode, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_open_async(struct nfs_context *nfs, const char *path, int flags, - nfs_cb cb, void *private_data) -{ - return nfs_open2_async(nfs, path, flags, 0666 & ~nfs->mask, - cb, private_data); -} - -int -nfs_chdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_chdir_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_chdir_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_pread_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, - uint64_t count, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_pread_async_internal(nfs, nfsfh, offset, - (size_t)count, - cb, private_data, 0); - case NFS_V4: - return nfs4_pread_async_internal(nfs, nfsfh, offset, - (size_t)count, - cb, private_data, 0); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_read_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_pread_async_internal(nfs, nfsfh, nfsfh->offset, - (size_t)count, - cb, private_data, 1); - case NFS_V4: - return nfs4_pread_async_internal(nfs, nfsfh, nfsfh->offset, - (size_t)count, - cb, private_data, 1); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_pwrite_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t offset, - uint64_t count, const void *buf, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_pwrite_async_internal(nfs, nfsfh, offset, - (size_t)count, buf, - cb, private_data, 0); - case NFS_V4: - return nfs4_pwrite_async_internal(nfs, nfsfh, offset, - (size_t)count, buf, - cb, private_data, 0); - default: - nfs_set_error(nfs, "%s does not support NFSv%d.", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, - const void *buf, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_write_async(nfs, nfsfh, count, buf, - cb, private_data); - case NFS_V4: - return nfs4_write_async(nfs, nfsfh, count, buf, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_close_async(nfs, nfsfh, cb, private_data); - case NFS_V4: - return nfs4_close_async(nfs, nfsfh, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_fstat_async(nfs, nfsfh, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv4", - __FUNCTION__); - return -1; - } -} - -int -nfs_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_fstat64_async(nfs, nfsfh, cb, private_data); - case NFS_V4: - return nfs4_fstat64_async(nfs, nfsfh, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_fsync_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_fsync_async(nfs, nfsfh, cb, private_data); - case NFS_V4: - return nfs4_fsync_async(nfs, nfsfh, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_ftruncate_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t length, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_ftruncate_async(nfs, nfsfh, length, - cb, private_data); - case NFS_V4: - return nfs4_ftruncate_async(nfs, nfsfh, length, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_truncate_async(struct nfs_context *nfs, const char *path, uint64_t length, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_truncate_async(nfs, path, length, cb, private_data); - case NFS_V4: - return nfs4_truncate_async(nfs, path, length, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_mkdir2_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_mkdir2_async(nfs, path, mode, cb, private_data); - case NFS_V4: - return nfs4_mkdir2_async(nfs, path, mode, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_mkdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - return nfs_mkdir2_async(nfs, path, 0755, cb, private_data); -} - -int -nfs_rmdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_rmdir_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_rmdir_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_create_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_create_async(nfs, path, flags, mode, - cb, private_data); - case NFS_V4: - return nfs4_create_async(nfs, path, flags, mode, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_creat_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, - void *private_data) -{ - return nfs_create_async(nfs, path, 0, mode, cb, private_data); -} - -int -nfs_unlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_unlink_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_unlink_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_mknod_async(struct nfs_context *nfs, const char *path, int mode, int dev, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_mknod_async(nfs, path, mode, dev, cb, private_data); - case NFS_V4: - return nfs4_mknod_async(nfs, path, mode, dev, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_opendir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_opendir_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_opendir_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv4", - __FUNCTION__); - return -1; - } -} - -struct nfsdirent * -nfs_readdir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir) -{ - struct nfsdirent *nfsdirent = nfsdir->current; - - if (nfsdir->current != NULL) { - nfsdir->current = nfsdir->current->next; - } - return nfsdirent; -} - -long -nfs_telldir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir) -{ - long i; - struct nfsdirent *tmp; - - for (i = 0, tmp = nfsdir->entries; tmp; i++, tmp = tmp->next) { - if (tmp == nfsdir->current) { - return i; - } - } - return -1; -} - -void -nfs_seekdir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir, long loc) -{ - if (loc < 0) { - return; - } - for (nfsdir->current = nfsdir->entries; - nfsdir && loc--; - nfsdir = nfsdir->next) { - } -} - -void -nfs_rewinddir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir) -{ - nfsdir->current = nfsdir->entries; -} - -void -nfs_closedir(struct nfs_context *nfs, struct nfsdir *nfsdir) -{ - if (nfs && nfs->dircache_enabled) { - nfs_dircache_add(nfs, nfsdir); - } else { - nfs_free_nfsdir(nfsdir); - } -} - -void -nfs_getcwd(struct nfs_context *nfs, const char **cwd) -{ - if (cwd) { - *cwd = nfs->cwd; - } -} - -int -nfs_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int64_t offset, - int whence, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_lseek_async(nfs, nfsfh, offset, whence, - cb, private_data); - case NFS_V4: - return nfs4_lseek_async(nfs, nfsfh, offset, whence, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_lockf_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_lock_op op, uint64_t count, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V4: - return nfs4_lockf_async(nfs, nfsfh, op, count, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_fcntl_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - enum nfs4_fcntl_op cmd, void *arg, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V4: - return nfs4_fcntl_async(nfs, nfsfh, cmd, arg, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_statvfs_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_statvfs_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_statvfs64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_statvfs64_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_statvfs64_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_readlink_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_readlink_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_chmod_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_chmod_async_internal(nfs, path, 0, mode, - cb, private_data); - case NFS_V4: - return nfs4_chmod_async_internal(nfs, path, 0, mode, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_lchmod_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_chmod_async_internal(nfs, path, 1, mode, - cb, private_data); - case NFS_V4: - return nfs4_chmod_async_internal(nfs, path, 1, mode, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_fchmod_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_fchmod_async(nfs, nfsfh, mode, cb, private_data); - case NFS_V4: - return nfs4_fchmod_async(nfs, nfsfh, mode, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_chown_async(struct nfs_context *nfs, const char *path, int uid, int gid, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_chown_async_internal(nfs, path, 0, uid, gid, - cb, private_data); - case NFS_V4: - return nfs4_chown_async_internal(nfs, path, 0, uid, gid, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_lchown_async(struct nfs_context *nfs, const char *path, int uid, int gid, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_chown_async_internal(nfs, path, 1, uid, gid, - cb, private_data); - case NFS_V4: - return nfs4_chown_async_internal(nfs, path, 1, uid, gid, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_fchown_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, - int gid, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_fchown_async(nfs, nfsfh, uid, gid, - cb, private_data); - case NFS_V4: - return nfs4_fchown_async(nfs, nfsfh, uid, gid, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_utimes_async(struct nfs_context *nfs, const char *path, - struct timeval *times, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_utimes_async_internal(nfs, path, 0, times, - cb, private_data); - case NFS_V4: - return nfs4_utimes_async_internal(nfs, path, 0, times, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_lutimes_async(struct nfs_context *nfs, const char *path, - struct timeval *times, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_utimes_async_internal(nfs, path, 1, times, - cb, private_data); - case NFS_V4: - return nfs4_utimes_async_internal(nfs, path, 1, times, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_utime_async(struct nfs_context *nfs, const char *path, - struct utimbuf *times, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_utime_async(nfs, path, times, cb, private_data); - case NFS_V4: - return nfs4_utime_async(nfs, path, times, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv4", - __FUNCTION__); - return -1; - } -} - -int -nfs_access_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_access_async(nfs, path, mode, cb, private_data); - case NFS_V4: - return nfs4_access_async(nfs, path, mode, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_access2_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_access2_async(nfs, path, cb, private_data); - case NFS_V4: - return nfs4_access2_async(nfs, path, cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv4", - __FUNCTION__); - return -1; - } -} - -int -nfs_symlink_async(struct nfs_context *nfs, const char *target, - const char *newpath, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_symlink_async(nfs, target, newpath, - cb, private_data); - case NFS_V4: - return nfs4_symlink_async(nfs, target, newpath, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_rename_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_rename_async(nfs, oldpath, newpath, - cb, private_data); - case NFS_V4: - return nfs4_rename_async(nfs, oldpath, newpath, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -int -nfs_link_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data) -{ - switch (nfs->version) { - case NFS_V3: - return nfs3_link_async(nfs, oldpath, newpath, - cb, private_data); - case NFS_V4: - return nfs4_link_async(nfs, oldpath, newpath, - cb, private_data); - default: - nfs_set_error(nfs, "%s does not support NFSv%d", - __FUNCTION__, nfs->version); - return -1; - } -} - -/* - * Get the maximum supported READ3 size by the server - */ -uint64_t -nfs_get_readmax(struct nfs_context *nfs) -{ - return nfs->readmax; -} - -/* - * Get the maximum supported WRITE3 size by the server - */ -uint64_t -nfs_get_writemax(struct nfs_context *nfs) -{ - return nfs->writemax; -} - -void -nfs_set_tcp_syncnt(struct nfs_context *nfs, int v) { - rpc_set_tcp_syncnt(nfs->rpc, v); -} - -void -nfs_set_uid(struct nfs_context *nfs, int uid) { - rpc_set_uid(nfs->rpc, uid); -} - -void -nfs_set_gid(struct nfs_context *nfs, int gid) { - rpc_set_gid(nfs->rpc, gid); -} - -void -nfs_set_pagecache(struct nfs_context *nfs, uint32_t v) { - rpc_set_pagecache(nfs->rpc, v); -} - -void -nfs_set_pagecache_ttl(struct nfs_context *nfs, uint32_t v) { - rpc_set_pagecache_ttl(nfs->rpc, v); -} - -void -nfs_set_readahead(struct nfs_context *nfs, uint32_t v) { - rpc_set_readahead(nfs->rpc, v); -} - -void -nfs_set_debug(struct nfs_context *nfs, int level) { - rpc_set_debug(nfs->rpc, level); -} - -void -nfs_set_dircache(struct nfs_context *nfs, int enabled) { - nfs->dircache_enabled = enabled; -} - -void -nfs_set_autoreconnect(struct nfs_context *nfs, int num_retries) { - nfs->auto_reconnect = num_retries; -} - -int -nfs_set_version(struct nfs_context *nfs, int version) { - switch (version) { - case NFS_V3: - case NFS_V4: - nfs->version = version; - break; - default: - nfs_set_error(nfs, "NFS version %d is not supported", version); - return -1; - } - return 0; -} - -void -nfs_set_error(struct nfs_context *nfs, char *error_string, ...) -{ - va_list ap; - char *str = NULL; - - va_start(ap, error_string); - str = malloc(1024); - vsnprintf(str, 1024, error_string, ap); - if (nfs->rpc->error_string != NULL) { - free(nfs->rpc->error_string); - } - nfs->rpc->error_string = str; - debugNetPrintf(2,"[LIBNFS] %s error %s\n",__FUNCTION__, nfs->rpc->error_string); - - va_end(ap); -} - -struct mount_cb_data { - rpc_cb cb; - void *private_data; - char *server; -}; - -static void -free_mount_cb_data(struct mount_cb_data *data) -{ - if (data->server != NULL) { - free(data->server); - data->server = NULL; - } - - free(data); -} - -static void -mount_export_5_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct mount_cb_data *data = private_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status != RPC_STATUS_SUCCESS) { - data->cb(rpc, -EFAULT, command_data, data->private_data); - free_mount_cb_data(data); - return; - } - - data->cb(rpc, 0, command_data, data->private_data); - if (rpc_disconnect(rpc, "normal disconnect") != 0) { - rpc_set_error(rpc, "Failed to disconnect\n"); - } - free_mount_cb_data(data); -} - -static void -mount_export_4_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct mount_cb_data *data = private_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Dont want any more callbacks even if the socket is closed */ - rpc->connect_cb = NULL; - - if (status != RPC_STATUS_SUCCESS) { - data->cb(rpc, -EFAULT, command_data, data->private_data); - free_mount_cb_data(data); - return; - } - - if (rpc_mount3_export_async(rpc, mount_export_5_cb, data) != 0) { - data->cb(rpc, -ENOMEM, command_data, data->private_data); - free_mount_cb_data(data); - return; - } -} - -int -mount_getexports_async(struct rpc_context *rpc, const char *server, rpc_cb cb, - void *private_data) -{ - struct mount_cb_data *data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - data = malloc(sizeof(struct mount_cb_data)); - if (data == NULL) { - return -1; - } - memset(data, 0, sizeof(struct mount_cb_data)); - data->cb = cb; - data->private_data = private_data; - data->server = strdup(server); - if (data->server == NULL) { - free_mount_cb_data(data); - return -1; - } - if (rpc_connect_program_async(rpc, data->server, MOUNT_PROGRAM, - MOUNT_V3, mount_export_4_cb, data) != 0) { - rpc_set_error(rpc, "Failed to start connection. %s", - rpc_get_error(rpc)); - free_mount_cb_data(data); - return -1; - } - - return 0; -} - -struct rpc_context * -nfs_get_rpc_context(struct nfs_context *nfs) -{ - assert(nfs->rpc->magic == RPC_CONTEXT_MAGIC); - return nfs->rpc; -} - -const char * -nfs_get_server(struct nfs_context *nfs) { - return nfs->server; -} - -const char * -nfs_get_export(struct nfs_context *nfs) { - return nfs->export; -} - -const struct nfs_fh * -nfs_get_rootfh(struct nfs_context *nfs) { - return &nfs->rootfh; -} - -struct nfs_fh * -nfs_get_fh(struct nfsfh *nfsfh) { - return &nfsfh->fh; -} - -uint16_t -nfs_umask(struct nfs_context *nfs, uint16_t mask) { - uint16_t tmp = nfs->mask; - nfs->mask = mask; - return tmp; -} - -/* -* Sets timeout for nfs apis -*/ -void -nfs_set_timeout(struct nfs_context *nfs,int timeout) -{ - rpc_set_timeout(nfs->rpc,timeout); -} - -/* -* Gets timeout for nfs apis -*/ -int -nfs_get_timeout(struct nfs_context *nfs) -{ - return rpc_get_timeout(nfs->rpc); -} - -int -rpc_null_async(struct rpc_context *rpc, int program, int version, rpc_cb cb, - void *private_data) -{ - struct rpc_pdu *pdu; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - pdu = rpc_allocate_pdu(rpc, program, version, 0, cb, private_data, - (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu " - "for NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu " - "for NULL call"); - return -1; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - - return 0; -} diff --git a/source/liborbisNfs/mount.c b/source/liborbisNfs/mount.c deleted file mode 100644 index e025072..0000000 --- a/source/liborbisNfs/mount.c +++ /dev/null @@ -1,339 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifdef WIN32 -#include -#endif/*WIN32*/ - -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-mount.h" - -int rpc_mount3_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/null call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/null call"); - return -1; - } - - return 0; -} - -int rpc_mount_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - return rpc_mount3_null_async(rpc, cb, private_data); -} - -int rpc_mount3_mnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_MNT, cb, private_data, (zdrproc_t)zdr_mountres3, sizeof(mountres3)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/mnt call"); - return -1; - } - - if (zdr_dirpath(&pdu->zdr, &export) == 0) { - rpc_set_error(rpc, "ZDR error. Failed to encode mount/mnt call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/mnt call"); - return -1; - } - - return 0; -} - -int rpc_mount_mnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data) -{ - return rpc_mount3_mnt_async(rpc, cb, export, private_data); -} - -int rpc_mount3_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_DUMP, cb, private_data, (zdrproc_t)zdr_mountlist, sizeof(mountlist)); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for mount/dump"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue mount/dump pdu"); - return -1; - } - - return 0; -} - -int rpc_mount_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - return rpc_mount3_dump_async(rpc, cb, private_data); -} - -int rpc_mount3_umnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNT, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for mount/umnt"); - return -1; - } - - if (zdr_dirpath(&pdu->zdr, &export) == 0) { - rpc_set_error(rpc, "failed to encode dirpath for mount/umnt"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue mount/umnt pdu"); - return -1; - } - - return 0; -} - -int rpc_mount_umnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data) -{ - return rpc_mount3_umnt_async(rpc, cb, export, private_data); -} - -int rpc_mount3_umntall_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNTALL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for mount/umntall"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue mount/umntall pdu"); - return -1; - } - - return 0; -} - -int rpc_mount_umntall_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - return rpc_mount3_umntall_async(rpc, cb, private_data); -} - -int rpc_mount3_export_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_EXPORT, cb, private_data, (zdrproc_t)zdr_exports, sizeof(exports)); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for mount/export"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue mount/export pdu"); - return -1; - } - - return 0; -} - -int rpc_mount_export_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - return rpc_mount3_export_async(rpc, cb, private_data); -} - -char *mountstat3_to_str(int st) -{ - enum mountstat3 stat = st; - - char *str = "unknown mount stat"; - switch (stat) { - case MNT3_OK: str="MNT3_OK"; break; - case MNT3ERR_PERM: str="MNT3ERR_PERM"; break; - case MNT3ERR_NOENT: str="MNT3ERR_NOENT"; break; - case MNT3ERR_IO: str="MNT3ERR_IO"; break; - case MNT3ERR_ACCES: str="MNT3ERR_ACCES"; break; - case MNT3ERR_NOTDIR: str="MNT3ERR_NOTDIR"; break; - case MNT3ERR_INVAL: str="MNT3ERR_INVAL"; break; - case MNT3ERR_NAMETOOLONG: str="MNT3ERR_NAMETOOLONG"; break; - case MNT3ERR_NOTSUPP: str="MNT3ERR_NOTSUPP"; break; - case MNT3ERR_SERVERFAULT: str="MNT3ERR_SERVERFAULT"; break; - } - return str; -} - - -int mountstat3_to_errno(int st) -{ - enum mountstat3 stat = st; - - switch (stat) { - case MNT3_OK: return 0; break; - case MNT3ERR_PERM: return -EPERM; break; - case MNT3ERR_NOENT: return -EPERM; break; - case MNT3ERR_IO: return -EIO; break; - case MNT3ERR_ACCES: return -EACCES; break; - case MNT3ERR_NOTDIR: return -ENOTDIR; break; - case MNT3ERR_INVAL: return -EINVAL; break; - case MNT3ERR_NAMETOOLONG: return -E2BIG; break; - case MNT3ERR_NOTSUPP: return -EINVAL; break; - case MNT3ERR_SERVERFAULT: return -EIO; break; - } - return -ERANGE; -} - -int rpc_mount1_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V1, MOUNT1_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for MOUNT1/NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for MOUNT1/NULL call"); - return -1; - } - - return 0; -} - -int rpc_mount1_mnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V1, MOUNT1_MNT, cb, private_data, (zdrproc_t)zdr_mountres1, sizeof(mountres1)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for MOUNT1/MNT call"); - return -1; - } - - if (zdr_dirpath(&pdu->zdr, &export) == 0) { - rpc_set_error(rpc, "ZDR error. Failed to encode MOUNT1/MNT call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for MOUNT1/MNT call"); - return -1; - } - - return 0; -} - -int rpc_mount1_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V1, MOUNT1_DUMP, cb, private_data, (zdrproc_t)zdr_mountlist, sizeof(mountlist)); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for MOUNT1/DUMP"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue MOUNT1/DUMP pdu"); - return -1; - } - - return 0; -} - -int rpc_mount1_umnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V1, MOUNT1_UMNT, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for MOUNT1/UMNT"); - return -1; - } - - if (zdr_dirpath(&pdu->zdr, &export) == 0) { - rpc_set_error(rpc, "failed to encode dirpath for MOUNT1/UMNT"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue MOUNT1/UMNT pdu"); - return -1; - } - - return 0; -} - -int rpc_mount1_umntall_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V1, MOUNT1_UMNTALL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for MOUNT1/UMNTALL"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue MOUNT1/UMNTALL pdu"); - return -1; - } - - return 0; -} - -int rpc_mount1_export_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V1, MOUNT1_EXPORT, cb, private_data, (zdrproc_t)zdr_exports, sizeof(exports)); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to allocate pdu for MOUNT1/EXPORT"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue MOUNT1/EXPORT pdu"); - return -1; - } - - return 0; -} - diff --git a/source/liborbisNfs/nfs.c b/source/liborbisNfs/nfs.c deleted file mode 100644 index 9733f19..0000000 --- a/source/liborbisNfs/nfs.c +++ /dev/null @@ -1,1273 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifdef WIN32 -#include -#else -#include -#endif/*WIN32*/ - -#include -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-nfs.h" - -char *nfsstat3_to_str(int error) -{ - switch (error) { - case NFS3_OK: return "NFS3_OK"; break; - case NFS3ERR_PERM: return "NFS3ERR_PERM"; break; - case NFS3ERR_NOENT: return "NFS3ERR_NOENT"; break; - case NFS3ERR_IO: return "NFS3ERR_IO"; break; - case NFS3ERR_NXIO: return "NFS3ERR_NXIO"; break; - case NFS3ERR_ACCES: return "NFS3ERR_ACCES"; break; - case NFS3ERR_EXIST: return "NFS3ERR_EXIST"; break; - case NFS3ERR_XDEV: return "NFS3ERR_XDEV"; break; - case NFS3ERR_NODEV: return "NFS3ERR_NODEV"; break; - case NFS3ERR_NOTDIR: return "NFS3ERR_NOTDIR"; break; - case NFS3ERR_ISDIR: return "NFS3ERR_ISDIR"; break; - case NFS3ERR_INVAL: return "NFS3ERR_INVAL"; break; - case NFS3ERR_FBIG: return "NFS3ERR_FBIG"; break; - case NFS3ERR_NOSPC: return "NFS3ERR_NOSPC"; break; - case NFS3ERR_ROFS: return "NFS3ERR_ROFS"; break; - case NFS3ERR_MLINK: return "NFS3ERR_MLINK"; break; - case NFS3ERR_NAMETOOLONG: return "NFS3ERR_NAMETOOLONG"; break; - case NFS3ERR_NOTEMPTY: return "NFS3ERR_NOTEMPTY"; break; - case NFS3ERR_DQUOT: return "NFS3ERR_DQUOT"; break; - case NFS3ERR_STALE: return "NFS3ERR_STALE"; break; - case NFS3ERR_REMOTE: return "NFS3ERR_REMOTE"; break; - case NFS3ERR_BADHANDLE: return "NFS3ERR_BADHANDLE"; break; - case NFS3ERR_NOT_SYNC: return "NFS3ERR_NOT_SYNC"; break; - case NFS3ERR_BAD_COOKIE: return "NFS3ERR_BAD_COOKIE"; break; - case NFS3ERR_NOTSUPP: return "NFS3ERR_NOTSUPP"; break; - case NFS3ERR_TOOSMALL: return "NFS3ERR_TOOSMALL"; break; - case NFS3ERR_SERVERFAULT: return "NFS3ERR_SERVERFAULT"; break; - case NFS3ERR_BADTYPE: return "NFS3ERR_BADTYPE"; break; - case NFS3ERR_JUKEBOX: return "NFS3ERR_JUKEBOX"; break; - }; - return "unknown nfs error"; -} - -int nfsstat3_to_errno(int error) -{ - switch (error) { - case NFS3_OK: return 0; break; - case NFS3ERR_PERM: return -EPERM; break; - case NFS3ERR_NOENT: return -ENOENT; break; - case NFS3ERR_IO: return -EIO; break; - case NFS3ERR_NXIO: return -ENXIO; break; - case NFS3ERR_ACCES: return -EACCES; break; - case NFS3ERR_EXIST: return -EEXIST; break; - case NFS3ERR_XDEV: return -EXDEV; break; - case NFS3ERR_NODEV: return -ENODEV; break; - case NFS3ERR_NOTDIR: return -ENOTDIR; break; - case NFS3ERR_ISDIR: return -EISDIR; break; - case NFS3ERR_INVAL: return -EINVAL; break; - case NFS3ERR_FBIG: return -EFBIG; break; - case NFS3ERR_NOSPC: return -ENOSPC; break; - case NFS3ERR_ROFS: return -EROFS; break; - case NFS3ERR_MLINK: return -EMLINK; break; - case NFS3ERR_NAMETOOLONG: return -ENAMETOOLONG; break; - case NFS3ERR_NOTEMPTY: return -ENOTEMPTY; break; - case NFS3ERR_DQUOT: return -ERANGE; break; - case NFS3ERR_STALE: return -ESTALE; break; - case NFS3ERR_REMOTE: return -EIO; break; - case NFS3ERR_BADHANDLE: return -EIO; break; - case NFS3ERR_NOT_SYNC: return -EIO; break; - case NFS3ERR_BAD_COOKIE: return -EIO; break; - case NFS3ERR_NOTSUPP: return -EINVAL; break; - case NFS3ERR_TOOSMALL: return -EIO; break; - case NFS3ERR_SERVERFAULT: return -EIO; break; - case NFS3ERR_BADTYPE: return -EINVAL; break; - case NFS3ERR_JUKEBOX: return -EAGAIN; break; - }; - return -ERANGE; -} - - -/* - * NFSv3 - */ -int rpc_nfs3_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/NULL call"); - return -2; - } - - return 0; -} - -int rpc_nfs_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - return rpc_nfs3_null_async(rpc, cb, private_data); -} - -int rpc_nfs3_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct GETATTR3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_GETATTR, cb, private_data, (zdrproc_t)zdr_GETATTR3res, sizeof(GETATTR3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/GETATTR call"); - return -1; - } - - if (zdr_GETATTR3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETATTR3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/GETATTR call"); - return -3; - } - - return 0; -} - -int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) -{ - GETATTR3args args; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = fh->data.data_len; - args.object.data.data_val = fh->data.data_val; - - return rpc_nfs3_getattr_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct PATHCONF3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_PATHCONF, cb, private_data, (zdrproc_t)zdr_PATHCONF3res, sizeof(PATHCONF3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/PATHCONF call"); - return -1; - } - - if (zdr_PATHCONF3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode PATHCONF3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/PATHCONF call"); - return -3; - } - - return 0; -} - -int rpc_nfs_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) -{ - PATHCONF3args args; - - memset(&args, 0, sizeof(PATHCONF3args)); - args.object.data.data_len = fh->data.data_len; - args.object.data.data_val = fh->data.data_val; - - return rpc_nfs3_pathconf_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct LOOKUP3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LOOKUP, cb, private_data, (zdrproc_t)zdr_LOOKUP3res, sizeof(LOOKUP3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/LOOKUP call"); - return -1; - } - - if (zdr_LOOKUP3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode LOOKUP3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/LOOKUP call"); - return -3; - } - - return 0; -} - -int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *name, void *private_data) -{ - LOOKUP3args args; - - memset(&args, 0, sizeof(LOOKUP3args)); - args.what.dir.data.data_len = fh->data.data_len; - args.what.dir.data.data_val = fh->data.data_val; - args.what.name = name; - - return rpc_nfs3_lookup_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_access_async(struct rpc_context *rpc, rpc_cb cb, struct ACCESS3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_ACCESS, cb, private_data, (zdrproc_t)zdr_ACCESS3res, sizeof(ACCESS3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/ACCESS call"); - return -1; - } - - if (zdr_ACCESS3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode ACCESS3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/ACCESS call"); - return -3; - } - - return 0; -} - -int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, int access, void *private_data) -{ - ACCESS3args args; - - memset(&args, 0, sizeof(ACCESS3args)); - args.object.data.data_len = fh->data.data_len; - args.object.data.data_val = fh->data.data_val; - args.access = access; - - return rpc_nfs3_access_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_read_async(struct rpc_context *rpc, rpc_cb cb, struct READ3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READ, cb, private_data, (zdrproc_t)zdr_READ3res, sizeof(READ3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READ call"); - return -1; - } - - if (zdr_READ3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READ3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READ call"); - return -3; - } - - return 0; -} - -int rpc_nfs_read_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t offset, uint64_t count, void *private_data) -{ - READ3args args; - - memset(&args, 0, sizeof(READ3args)); - args.file.data.data_len = fh->data.data_len; - args.file.data.data_val = fh->data.data_val; - args.offset = offset; - args.count = (count3)count; - - return rpc_nfs3_read_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_write_async(struct rpc_context *rpc, rpc_cb cb, struct WRITE3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu2(rpc, NFS_PROGRAM, NFS_V3, NFS3_WRITE, cb, private_data, (zdrproc_t)zdr_WRITE3res, sizeof(WRITE3res), args->count); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/WRITE call"); - return -1; - } - - if (zdr_WRITE3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode WRITE3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/WRITE call"); - return -3; - } - - return 0; -} - -int rpc_nfs_write_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *buf, uint64_t offset, uint64_t count, int stable_how, void *private_data) -{ - WRITE3args args; - - memset(&args, 0, sizeof(WRITE3args)); - args.file.data.data_len = fh->data.data_len; - args.file.data.data_val = fh->data.data_val; - args.offset = offset; - args.count = (count3)count; - args.stable = stable_how; - args.data.data_len = (count3)count; - args.data.data_val = buf; - - return rpc_nfs3_write_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_commit_async(struct rpc_context *rpc, rpc_cb cb, struct COMMIT3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_COMMIT, cb, private_data, (zdrproc_t)zdr_COMMIT3res, sizeof(COMMIT3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/COMMIT call"); - return -1; - } - - if (zdr_COMMIT3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode COMMIT3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/COMMIT call"); - return -3; - } - - return 0; -} - -int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) -{ - COMMIT3args args; - - memset(&args, 0, sizeof(COMMIT3args)); - args.file.data.data_len = fh->data.data_len; - args.file.data.data_val = fh->data.data_val; - args.offset = 0; - args.count = 0; - - return rpc_nfs3_commit_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SETATTR, cb, private_data, (zdrproc_t)zdr_SETATTR3res, sizeof(SETATTR3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/SETATTR call"); - return -1; - } - - if (zdr_SETATTR3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode SETATTR3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/SETATTR call"); - return -3; - } - - return 0; -} - -int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data) -{ - return rpc_nfs3_setattr_async(rpc, cb, args, private_data); -} - -int rpc_nfs3_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKDIR, cb, private_data, (zdrproc_t)zdr_MKDIR3res, sizeof(MKDIR3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/MKDIR call"); - return -1; - } - - if (zdr_MKDIR3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode MKDIR3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/MKDIR call"); - return -3; - } - - return 0; -} - -int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data) -{ - return rpc_nfs3_mkdir_async(rpc, cb, args, private_data); -} - -int rpc_nfs3_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct RMDIR3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RMDIR, cb, private_data, (zdrproc_t)zdr_RMDIR3res, sizeof(RMDIR3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/RMDIR call"); - return -1; - } - - if (zdr_RMDIR3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode RMDIR3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/RMDIR call"); - return -3; - } - - return 0; -} - -int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data) -{ - RMDIR3args args; - - memset(&args, 0, sizeof(RMDIR3args)); - args.object.dir.data.data_len = fh->data.data_len; - args.object.dir.data.data_val = fh->data.data_val; - args.object.name = dir; - - return rpc_nfs3_rmdir_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_CREATE, cb, private_data, (zdrproc_t)zdr_CREATE3res, sizeof(CREATE3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/CREATE call"); - return -1; - } - - if (zdr_CREATE3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode CREATE3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/CREATE call"); - return -3; - } - - return 0; -} - -int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data) -{ - return rpc_nfs3_create_async(rpc, cb, args, private_data); -} - -int rpc_nfs3_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct MKNOD3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKNOD, cb, private_data, (zdrproc_t)zdr_MKNOD3res, sizeof(MKNOD3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/MKNOD call"); - return -1; - } - - if (zdr_MKNOD3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode MKNOD3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/MKNOD call"); - return -3; - } - - return 0; -} - -int rpc_nfs_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, int mode, int major, int minor, void *private_data) -{ - MKNOD3args args; - - memset(&args, 0, sizeof(MKNOD3args)); - args.where.dir.data.data_len = fh->data.data_len; - args.where.dir.data.data_val = fh->data.data_val; - args.where.name = file; - - switch (mode & S_IFMT) { - case S_IFCHR: - args.what.type = NF3CHR; - args.what.mknoddata3_u.chr_device.dev_attributes.mode.set_it = 1; - args.what.mknoddata3_u.chr_device.dev_attributes.mode.set_mode3_u.mode = mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - args.what.mknoddata3_u.chr_device.spec.specdata1 = major; - args.what.mknoddata3_u.chr_device.spec.specdata2 = minor; - break; - case S_IFBLK: - args.what.type = NF3BLK; - args.what.mknoddata3_u.blk_device.dev_attributes.mode.set_it = 1; - args.what.mknoddata3_u.blk_device.dev_attributes.mode.set_mode3_u.mode = mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - args.what.mknoddata3_u.blk_device.spec.specdata1 = major; - args.what.mknoddata3_u.blk_device.spec.specdata2 = minor; - case S_IFSOCK: - args.what.type = NF3SOCK; - args.what.mknoddata3_u.sock_attributes.mode.set_it = 1; - args.what.mknoddata3_u.sock_attributes.mode.set_mode3_u.mode = mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - break; - case S_IFIFO: - args.what.type = NF3FIFO; - args.what.mknoddata3_u.pipe_attributes.mode.set_it = 1; - args.what.mknoddata3_u.pipe_attributes.mode.set_mode3_u.mode = mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - break; - default: - rpc_set_error(rpc, "Invalid file type for NFS3/MKNOD call"); - return -1; - } - - return rpc_nfs3_mknod_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_remove_async(struct rpc_context *rpc, rpc_cb cb, struct REMOVE3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_REMOVE, cb, private_data, (zdrproc_t)zdr_REMOVE3res, sizeof(REMOVE3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/REMOVE call"); - return -1; - } - - if (zdr_REMOVE3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode REMOVE3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/REMOVE call"); - return -3; - } - - return 0; -} - -int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, void *private_data) -{ - REMOVE3args args; - - memset(&args, 0, sizeof(REMOVE3args)); - args.object.dir.data.data_len = fh->data.data_len; - args.object.dir.data.data_val = fh->data.data_val; - args.object.name = file; - - return rpc_nfs3_remove_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct READDIR3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIR, cb, private_data, (zdrproc_t)zdr_READDIR3res, sizeof(READDIR3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READDIR call"); - return -1; - } - - if (zdr_READDIR3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READDIR3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READDIR call"); - return -3; - } - - return 0; -} - -int rpc_nfs_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t cookie, char *cookieverf, int count, void *private_data) -{ - READDIR3args args; - - memset(&args, 0, sizeof(READDIR3args)); - args.dir.data.data_len = fh->data.data_len; - args.dir.data.data_val = fh->data.data_val; - args.cookie = cookie; - memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3)); - args.count = count; - - return rpc_nfs3_readdir_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, struct READDIRPLUS3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIRPLUS, cb, private_data, (zdrproc_t)zdr_READDIRPLUS3res, sizeof(READDIRPLUS3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READDIRPLUS call"); - return -1; - } - - if (zdr_READDIRPLUS3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READDIRPLUS3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READDIRPLUS call"); - return -3; - } - - return 0; -} - -int rpc_nfs_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t cookie, char *cookieverf, int count, void *private_data) -{ - READDIRPLUS3args args; - - memset(&args, 0, sizeof(READDIRPLUS3args)); - args.dir.data.data_len = fh->data.data_len; - args.dir.data.data_val = fh->data.data_val; - args.cookie = cookie; - memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3)); - args.dircount = count; - args.maxcount = count * 8; - - return rpc_nfs3_readdirplus_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct FSSTAT3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSSTAT, cb, private_data, (zdrproc_t)zdr_FSSTAT3res, sizeof(FSSTAT3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/FSSTAT call"); - return -1; - } - - if (zdr_FSSTAT3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode FSSTAT3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/FSSTAT call"); - return -3; - } - - return 0; -} - -int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) -{ - FSSTAT3args args; - - memset(&args, 0, sizeof(FSSTAT3args)); - args.fsroot.data.data_len = fh->data.data_len; - args.fsroot.data.data_val = fh->data.data_val; - - return rpc_nfs3_fsstat_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct FSINFO3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSINFO, cb, private_data, (zdrproc_t)zdr_FSINFO3res, sizeof(FSINFO3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/FSINFO call"); - return -1; - } - - if (zdr_FSINFO3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode FSINFO3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/FSINFO call"); - return -3; - } - - return 0; -} - -int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) -{ - FSINFO3args args; - - memset(&args, 0, sizeof(FSINFO3args)); - args.fsroot.data.data_len = fh->data.data_len; - args.fsroot.data.data_val = fh->data.data_val; - - return rpc_nfs3_fsinfo_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READLINK, cb, private_data, (zdrproc_t)zdr_READLINK3res, sizeof(READLINK3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READLINK call"); - return -1; - } - - if (zdr_READLINK3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READLINK3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READLINK call"); - return -3; - } - - return 0; -} - -int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data) -{ - return rpc_nfs3_readlink_async(rpc, cb, args, private_data); -} - -int rpc_nfs3_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SYMLINK, cb, private_data, (zdrproc_t)zdr_SYMLINK3res, sizeof(SYMLINK3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/SYMLINK call"); - return -1; - } - - if (zdr_SYMLINK3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode SYMLINK3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/SYMLINK call"); - return -3; - } - - return 0; -} - -int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data) -{ - return rpc_nfs3_symlink_async(rpc, cb, args, private_data); -} - -int rpc_nfs3_rename_async(struct rpc_context *rpc, rpc_cb cb, struct RENAME3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RENAME, cb, private_data, (zdrproc_t)zdr_RENAME3res, sizeof(RENAME3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/RENAME call"); - return -1; - } - - if (zdr_RENAME3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode RENAME3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/RENAME call"); - return -3; - } - - return 0; -} - -int rpc_nfs_rename_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *olddir, char *oldname, struct nfs_fh3 *newdir, char *newname, void *private_data) -{ - RENAME3args args; - - memset(&args, 0, sizeof(RENAME3args)); - args.from.dir.data.data_len = olddir->data.data_len; - args.from.dir.data.data_val = olddir->data.data_val; - args.from.name = oldname; - args.to.dir.data.data_len = newdir->data.data_len; - args.to.dir.data.data_val = newdir->data.data_val; - args.to.name = newname; - - return rpc_nfs3_rename_async(rpc, cb, &args, private_data); -} - -int rpc_nfs3_link_async(struct rpc_context *rpc, rpc_cb cb, struct LINK3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LINK, cb, private_data, (zdrproc_t)zdr_LINK3res, sizeof(LINK3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/LINK call"); - return -1; - } - - if (zdr_LINK3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode LINK3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/LINK call"); - return -3; - } - - return 0; -} - -int rpc_nfs_link_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *file, struct nfs_fh3 *newdir, char *newname, void *private_data) -{ - LINK3args args; - - memset(&args, 0, sizeof(LINK3args)); - args.file.data.data_len = file->data.data_len; - args.file.data.data_val = file->data.data_val; - args.link.dir.data.data_len = newdir->data.data_len; - args.link.dir.data.data_val = newdir->data.data_val; - args.link.name = newname; - - return rpc_nfs3_link_async(rpc, cb, &args, private_data); -} - -/* - * NFSv2 - */ -int rpc_nfs2_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/NULL call"); - return -2; - } - - return 0; -} - -int rpc_nfs2_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct GETATTR2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_GETATTR, cb, private_data, (zdrproc_t)zdr_GETATTR2res, sizeof(GETATTR2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/GETATTR call"); - return -1; - } - - if (zdr_GETATTR2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETATTR2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/GETATTR call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_SETATTR, cb, private_data, (zdrproc_t)zdr_SETATTR2res, sizeof(SETATTR2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/SETATTR call"); - return -1; - } - - if (zdr_SETATTR2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode SETATTR2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/SETATTR call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct LOOKUP2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_LOOKUP, cb, private_data, (zdrproc_t)zdr_LOOKUP2res, sizeof(LOOKUP2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/LOOKUP call"); - return -1; - } - - if (zdr_LOOKUP2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode LOOKUP2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/LOOKUP call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_READLINK, cb, private_data, (zdrproc_t)zdr_READLINK2res, sizeof(READLINK2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/READLINK call"); - return -1; - } - - if (zdr_READLINK2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READLINK2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/READLINK call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_read_async(struct rpc_context *rpc, rpc_cb cb, struct READ2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_READ, cb, private_data, (zdrproc_t)zdr_READ2res, sizeof(READ2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/READ call"); - return -1; - } - - if (zdr_READ2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READ2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/READ call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_write_async(struct rpc_context *rpc, rpc_cb cb, struct WRITE2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu2(rpc, NFS_PROGRAM, NFS_V2, NFS2_WRITE, cb, private_data, (zdrproc_t)zdr_WRITE2res, sizeof(WRITE2res), args->totalcount); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/WRITE call"); - return -1; - } - - if (zdr_WRITE2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode WRITE2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/WRITE call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_CREATE, cb, private_data, (zdrproc_t)zdr_CREATE2res, sizeof(CREATE2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/CREATE call"); - return -1; - } - - if (zdr_CREATE2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode CREATE2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/CREATE call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_remove_async(struct rpc_context *rpc, rpc_cb cb, struct REMOVE2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_REMOVE, cb, private_data, (zdrproc_t)zdr_REMOVE2res, sizeof(REMOVE2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/REMOVE call"); - return -1; - } - - if (zdr_REMOVE2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode REMOVE2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/REMOVE call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_rename_async(struct rpc_context *rpc, rpc_cb cb, struct RENAME2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_RENAME, cb, private_data, (zdrproc_t)zdr_RENAME2res, sizeof(RENAME2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/RENAME call"); - return -1; - } - - if (zdr_RENAME2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode RENAME2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/RENAME call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_link_async(struct rpc_context *rpc, rpc_cb cb, LINK2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_LINK, cb, private_data, (zdrproc_t)zdr_LINK2res, sizeof(LINK2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/LINK call"); - return -1; - } - - if (zdr_LINK2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode LINK2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/LINK call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_SYMLINK, cb, private_data, (zdrproc_t)zdr_SYMLINK2res, sizeof(SYMLINK2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/SYMLINK call"); - return -1; - } - - if (zdr_SYMLINK2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode SYMLINK2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/SYMLINK call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_MKDIR, cb, private_data, (zdrproc_t)zdr_MKDIR2res, sizeof(MKDIR2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/MKDIR call"); - return -1; - } - - if (zdr_MKDIR2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode MKDIR2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/MKDIR call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct RMDIR2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_RMDIR, cb, private_data, (zdrproc_t)zdr_RMDIR2res, sizeof(RMDIR2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/RMDIR call"); - return -1; - } - - if (zdr_RMDIR2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode RMDIR2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/RMDIR call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct READDIR2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_READDIR, cb, private_data, (zdrproc_t)zdr_READDIR2res, sizeof(READDIR2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/READDIR call"); - return -1; - } - - if (zdr_READDIR2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READDIR2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/READDIR call"); - return -3; - } - - return 0; -} - -int rpc_nfs2_statfs_async(struct rpc_context *rpc, rpc_cb cb, struct STATFS2args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_STATFS, cb, private_data, (zdrproc_t)zdr_STATFS2res, sizeof(STATFS2res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/STATFS call"); - return -1; - } - - if (zdr_STATFS2args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode STATFS2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/STATFS call"); - return -3; - } - - return 0; -} diff --git a/source/liborbisNfs/nfs4.c b/source/liborbisNfs/nfs4.c deleted file mode 100644 index dc2cda2..0000000 --- a/source/liborbisNfs/nfs4.c +++ /dev/null @@ -1,232 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2016 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifdef WIN32 -#include -#else -#include -#endif/*WIN32*/ - -#include -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-nfs4.h" - -char * -nfsstat4_to_str(int error) -{ - switch (error) { - case NFS4_OK: return "NFS4_OK"; break; - case NFS4ERR_PERM: return "NFS4ERR_PERM"; break; - case NFS4ERR_NOENT: return "NFS4ERR_NOENT"; break; - case NFS4ERR_IO: return "NFS4ERR_IO"; break; - case NFS4ERR_NXIO: return "NFS4ERR_NXIO"; break; - case NFS4ERR_ACCESS: return "NFS4ERR_ACCESS"; break; - case NFS4ERR_EXIST: return "NFS4ERR_EXIST"; break; - case NFS4ERR_XDEV: return "NFS4ERR_XDEV"; break; - case NFS4ERR_NOTDIR: return "NFS4ERR_NOTDIR"; break; - case NFS4ERR_ISDIR: return "NFS4ERR_ISDIR"; break; - case NFS4ERR_INVAL: return "NFS4ERR_INVAL"; break; - case NFS4ERR_FBIG: return "NFS4ERR_FBIG"; break; - case NFS4ERR_NOSPC: return "NFS4ERR_NOSPC"; break; - case NFS4ERR_ROFS: return"NFS4ERR_ROFS"; break; - case NFS4ERR_MLINK: return "NFS4ERR_MLINK"; break; - case NFS4ERR_NAMETOOLONG: return "NFS4ERR_NAMETOOLONG"; break; - case NFS4ERR_NOTEMPTY: return "NFS4ERR_NOTEMPTY"; break; - case NFS4ERR_DQUOT: return "NFS4ERR_DQUOT"; break; - case NFS4ERR_STALE: return "NFS4ERR_STALE"; break; - case NFS4ERR_BADHANDLE: return "NFS4ERR_BADHANDLE"; break; - case NFS4ERR_BAD_COOKIE: return "NFS4ERR_BAD_COOKIE"; break; - case NFS4ERR_NOTSUPP: return "NFS4ERR_NOTSUPP"; break; - case NFS4ERR_TOOSMALL: return "NFS4ERR_TOOSMALL"; break; - case NFS4ERR_SERVERFAULT: return "NFS4ERR_SERVERFAULT"; break; - case NFS4ERR_BADTYPE: return "NFS4ERR_BADTYPE"; break; - case NFS4ERR_DELAY: return "NFS4ERR_DELAY"; break; - case NFS4ERR_SAME: return "NFS4ERR_SAME"; break; - case NFS4ERR_DENIED: return "NFS4ERR_DENIED"; break; - case NFS4ERR_EXPIRED: return "NFS4ERR_EXPIRED"; break; - case NFS4ERR_LOCKED: return "NFS4ERR_LOCKED"; break; - case NFS4ERR_GRACE: return "NFS4ERR_GRACE"; break; - case NFS4ERR_FHEXPIRED: return "NFS4ERR_FHEXPIRED"; break; - case NFS4ERR_SHARE_DENIED: return "NFS4ERR_SHARE_DENIED"; break; - case NFS4ERR_WRONGSEC: return "NFS4ERR_WRONGSEC"; break; - case NFS4ERR_CLID_INUSE: return "NFS4ERR_CLID_INUSE"; break; - case NFS4ERR_RESOURCE: return "NFS4ERR_RESOURCE"; break; - case NFS4ERR_MOVED: return "NFS4ERR_MOVED"; break; - case NFS4ERR_NOFILEHANDLE: return "NFS4ERR_NOFILEHANDLE"; break; - case NFS4ERR_MINOR_VERS_MISMATCH: - return "NFS4ERR_MINOR_VERS_MISMATCH"; break; - case NFS4ERR_STALE_CLIENTID: return "NFS4ERR_STALE_CLIENTID"; break; - case NFS4ERR_STALE_STATEID: return "NFS4ERR_STALE_STATEID"; break; - case NFS4ERR_OLD_STATEID: return "NFS4ERR_OLD_STATEID"; break; - case NFS4ERR_BAD_STATEID: return "NFS4ERR_BAD_STATEID"; break; - case NFS4ERR_BAD_SEQID: return "NFS4ERR_BAD_SEQID"; break; - case NFS4ERR_NOT_SAME: return "NFS4ERR_NOT_SAME"; break; - case NFS4ERR_LOCK_RANGE: return "NFS4ERR_LOCK_RANGE"; break; - case NFS4ERR_SYMLINK: return "NFS4ERR_SYMLINK"; break; - case NFS4ERR_RESTOREFH: return "NFS4ERR_RESTOREFH"; break; - case NFS4ERR_LEASE_MOVED: return "NFS4ERR_LEASE_MOVED"; break; - case NFS4ERR_ATTRNOTSUPP: return "NFS4ERR_ATTRNOTSUPP"; break; - case NFS4ERR_NO_GRACE: return "NFS4ERR_NO_GRACE"; break; - case NFS4ERR_RECLAIM_BAD: return "NFS4ERR_RECLAIM_BAD"; break; - case NFS4ERR_RECLAIM_CONFLICT: return "NFS4ERR_RECLAIM_CONFLICT"; break; - case NFS4ERR_BADZDR: return "NFS4ERR_BADZDR"; break; - case NFS4ERR_LOCKS_HELD: return "NFS4ERR_LOCKS_HELD"; break; - case NFS4ERR_OPENMODE: return "NFS4ERR_OPENMODE"; break; - case NFS4ERR_BADOWNER: return "NFS4ERR_BADOWNER"; break; - case NFS4ERR_BADCHAR: return "NFS4ERR_BADCHAR"; break; - case NFS4ERR_BADNAME: return "NFS4ERR_BADNAME"; break; - case NFS4ERR_BAD_RANGE: return "NFS4ERR_BAD_RANGE"; break; - case NFS4ERR_LOCK_NOTSUPP: return "NFS4ERR_LOCK_NOTSUPP"; break; - case NFS4ERR_OP_ILLEGAL: return "NFS4ERR_OP_ILLEGAL"; break; - case NFS4ERR_DEADLOCK: return "NFS4ERR_DEADLOCK"; break; - case NFS4ERR_FILE_OPEN: return "NFS4ERR_FILE_OPEN"; break; - case NFS4ERR_ADMIN_REVOKED: return "NFS4ERR_ADMIN_REVOKED"; break; - case NFS4ERR_CB_PATH_DOWN: return "NFS4ERR_CB_PATH_DOWN"; break; - }; - return "unknown nfsv4 error"; -} - -int -nfsstat4_to_errno(int error) -{ - switch (error) { - case NFS4_OK: return 0; - case NFS4ERR_PERM: return -EPERM; - case NFS4ERR_NOENT: return -ENOENT ; - case NFS4ERR_IO: return -EIO; - case NFS4ERR_NXIO: return -ENXIO; - case NFS4ERR_ACCESS: return -EACCES ; - case NFS4ERR_EXIST: return -EEXIST; - case NFS4ERR_XDEV: return -EXDEV; - case NFS4ERR_NOTDIR: return -ENOTDIR ; - case NFS4ERR_ISDIR: return -EISDIR ; - case NFS4ERR_INVAL: return -EINVAL; - case NFS4ERR_FBIG: return -EFBIG; - case NFS4ERR_NOSPC: return -ENOSPC; - case NFS4ERR_ROFS: return -EROFS; - case NFS4ERR_MLINK: return -EMLINK; - case NFS4ERR_NAMETOOLONG: return -ENAMETOOLONG; - case NFS4ERR_NOTEMPTY: return -ENOTEMPTY; - case NFS4ERR_DQUOT: return -ERANGE; - case NFS4ERR_STALE: return -EIO; - case NFS4ERR_BADHANDLE: return -EINVAL; - case NFS4ERR_BAD_COOKIE: return -EINVAL; - case NFS4ERR_NOTSUPP: return -EINVAL; - case NFS4ERR_TOOSMALL: return -EIO; - case NFS4ERR_SERVERFAULT: return -EIO; - case NFS4ERR_BADTYPE: return -EINVAL; - case NFS4ERR_DELAY: return -EIO; - case NFS4ERR_SAME: return -EIO; - case NFS4ERR_DENIED: return -EIO; - case NFS4ERR_EXPIRED: return -EIO; - case NFS4ERR_LOCKED: return -EIO; - case NFS4ERR_GRACE: return -EIO; - case NFS4ERR_FHEXPIRED: return -EIO; - case NFS4ERR_SHARE_DENIED: return -EIO; - case NFS4ERR_WRONGSEC: return -EIO; - case NFS4ERR_CLID_INUSE: return -EIO; - case NFS4ERR_RESOURCE: return -EIO; - case NFS4ERR_MOVED: return -EIO; - case NFS4ERR_NOFILEHANDLE: return -EIO; - case NFS4ERR_MINOR_VERS_MISMATCH: return -EIO; - case NFS4ERR_STALE_CLIENTID: return -EIO; - case NFS4ERR_STALE_STATEID: return -EIO; - case NFS4ERR_OLD_STATEID: return -EIO; - case NFS4ERR_BAD_STATEID: return -EINVAL; - case NFS4ERR_BAD_SEQID: return -EINVAL; - case NFS4ERR_NOT_SAME: return -EIO; - case NFS4ERR_LOCK_RANGE: return -EIO; - case NFS4ERR_SYMLINK: return -EIO; - case NFS4ERR_RESTOREFH: return -EIO; - case NFS4ERR_ATTRNOTSUPP: return -EINVAL; - case NFS4ERR_NO_GRACE: return -EIO; - case NFS4ERR_RECLAIM_BAD: return -EIO; - case NFS4ERR_RECLAIM_CONFLICT: return -EIO; - case NFS4ERR_BADZDR: return -EINVAL; - case NFS4ERR_LOCKS_HELD: return -EIO; - case NFS4ERR_OPENMODE: return -EIO; - case NFS4ERR_BADOWNER: return -EINVAL; - case NFS4ERR_BADCHAR: return -EINVAL; - case NFS4ERR_BADNAME: return -EINVAL; - case NFS4ERR_BAD_RANGE: return -EINVAL; - case NFS4ERR_LOCK_NOTSUPP: return -EINVAL; - case NFS4ERR_OP_ILLEGAL: return -EIO; - case NFS4ERR_DEADLOCK: return -EIO; - case NFS4ERR_FILE_OPEN: return -EIO; - case NFS4ERR_ADMIN_REVOKED: return -EIO; - case NFS4ERR_CB_PATH_DOWN: return -EIO; - }; - return -ERANGE; -} - -int -rpc_nfs4_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS4_PROGRAM, NFS_V4, NFSPROC4_NULL, cb, - private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu " - "for NFS4/NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for " - "NFS4/NULL call"); - return -1; - } - - return 0; -} - -int -rpc_nfs4_compound_async(struct rpc_context *rpc, rpc_cb cb, - struct COMPOUND4args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFS4_PROGRAM, NFS_V4, NFSPROC4_COMPOUND, - cb, private_data, (zdrproc_t)zdr_COMPOUND4res, - sizeof(COMPOUND4res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for " - "NFS4/COMPOUND call"); - return -1; - } - - if (zdr_COMPOUND4args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode COMPOUND4args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for " - "NFS4/COMPOUND4 call"); - return -3; - } - - return 0; -} diff --git a/source/liborbisNfs/nfs_v3.c b/source/liborbisNfs/nfs_v3.c deleted file mode 100644 index 28b3c00..0000000 --- a/source/liborbisNfs/nfs_v3.c +++ /dev/null @@ -1,5110 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2017 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * High level api to nfsv3 filesystems - */ -#ifndef _GNU_SOURCE -#define _GNU_SOURCE -#endif - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef HAVE_INTTYPES_H -#include -#else -#define PRIu64 "llu" -#endif - -#ifdef HAVE_UTIME_H -#include -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#ifdef HAVE_SYS_VFS_H -#include -#endif - -#ifdef HAVE_SYS_STATVFS_H -#include -#endif - -#if defined(__ANDROID__) && !defined(HAVE_SYS_STATVFS_H) -#define statvfs statfs -#endif - -#ifdef HAVE_NETINET_IN_H -#include -#endif - -#ifdef HAVE_STRINGS_H -#include -#endif - -#ifdef MAJOR_IN_MKDEV -#include -#endif - -#ifdef HAVE_SYS_SYSMACROS_H -#include -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "libnfs-zdr.h" -#include "slist.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-raw-mount.h" -#include "libnfs-private.h" - -static dev_t -specdata3_to_rdev(struct specdata3 *rdev) -{ -#ifdef makedev - return makedev(rdev->specdata1, rdev->specdata2); -#else - return 0; -#endif -} - -struct mount_attr_cb { - int wait_count; - struct nfs_cb_data *data; -}; - -struct mount_attr_item_cb { - struct mount_attr_cb *ma; - struct nested_mounts *mnt; -}; - -struct nfs_mcb_data { - struct nfs_cb_data *data; - uint64_t offset; - size_t count; -}; - -static int -check_nfs3_error(struct nfs_context *nfs, int status, - struct nfs_cb_data *data, void *command_data) -{ - if (status == RPC_STATUS_ERROR) { - data->cb(-EFAULT, nfs, command_data, data->private_data); - return 1; - } - if (status == RPC_STATUS_CANCEL) { - data->cb(-EINTR, nfs, "Command was cancelled", - data->private_data); - return 1; - } - if (status == RPC_STATUS_TIMEOUT) { - data->cb(-EINTR, nfs, "Command timed out", - data->private_data); - return 1; - } - - return 0; -} - -static int nfs3_lookup_path_async_internal(struct nfs_context *nfs, - struct nfs_attr *attr, - struct nfs_cb_data *data, - struct nfs_fh *fh); - -/* - * Functions to first look up a path, component by component, and then finally - * call a specific function once the filehandle for the final component is - * found. - */ -static void -nfs3_lookup_path_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - READLINK3res *res; - char *path, *newpath; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: READLINK of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - path = res->READLINK3res_u.resok.data; - - /* Handle absolute paths, ensuring that the path lies within the - * export. */ - if (path[0] == '/') { - if (strstr(path, nfs->export) == path) { - char *ptr = path + strlen(nfs->export); - if (*ptr == '/') { - newpath = strdup(ptr); - } else if (*ptr == '\0') { - newpath = strdup("/"); - } else { - data->cb(-ENOENT, nfs, "Symbolic link points " - "outside export", data->private_data); - free_nfs_cb_data(data); - return; - } - } else { - data->cb(-ENOENT, nfs, "Symbolic link points outside " - "export", data->private_data); - free_nfs_cb_data(data); - return; - } - - if (!newpath) - goto nomem; - } else { - /* Handle relative paths, both the case where the current - * component is an intermediate component and when it is the - * final component. */ - if (data->path[0]) { - /* Since path points to a component and saved_path - * always starts with '/', path[-1] is valid. */ - data->path[-1] = '\0'; - newpath = malloc(strlen(data->saved_path) + - strlen(path) + strlen(data->path) + 6); - if (!newpath) - goto nomem; - - sprintf(newpath, "%s/../%s/%s", data->saved_path, path, - data->path); - } else { - newpath = malloc(strlen(data->saved_path) + - strlen(path) + 5); - if (!newpath) - goto nomem; - - sprintf(newpath, "%s/../%s", data->saved_path, path); - } - } - free(data->saved_path); - data->saved_path = newpath; - - if (nfs_normalize_path(nfs, data->saved_path) != 0) { - data->cb(-ENOENT, nfs, "Symbolic link resolves to invalid " - "path", data->private_data); - free_nfs_cb_data(data); - return; - } - - data->path = data->saved_path; - nfs3_lookup_path_async_internal(nfs, NULL, data, &nfs->rootfh); - return; - -nomem: - data->cb(-ENOMEM, nfs, "Failed to allocate memory for path", - data->private_data); - free_nfs_cb_data(data); -} - -static void -fattr3_to_nfs_attr(struct nfs_attr *attr, fattr3 *fa3) -{ - attr->type = fa3->type; - attr->mode = fa3->mode; - attr->uid = fa3->uid; - attr->gid = fa3->gid; - attr->nlink = fa3->nlink; - attr->size = fa3->size; - attr->used = fa3->used; - attr->fsid = fa3->fsid; - attr->rdev.specdata1 = fa3->rdev.specdata1; - attr->rdev.specdata2 = fa3->rdev.specdata2; - attr->atime.seconds = fa3->atime.seconds; - attr->atime.nseconds = fa3->atime.nseconds; - attr->mtime.seconds = fa3->mtime.seconds; - attr->mtime.nseconds = fa3->mtime.nseconds; - attr->ctime.seconds = fa3->ctime.seconds; - attr->ctime.nseconds = fa3->ctime.nseconds; -} - -static void -nfs3_lookup_path_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - LOOKUP3res *res; - struct nfs_attr attr; - struct nfs_fh fh; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Lookup of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - memset(&attr, 0, sizeof(attr)); - if (res->LOOKUP3res_u.resok.obj_attributes.attributes_follow) { - fattr3_to_nfs_attr(&attr, &res->LOOKUP3res_u.resok.obj_attributes.post_op_attr_u.attributes); - } - - /* This function will always invoke the callback and cleanup - * for failures. So no need to check the return value. - */ - fh.val = res->LOOKUP3res_u.resok.object.data.data_val; - fh.len = res->LOOKUP3res_u.resok.object.data.data_len; - nfs3_lookup_path_async_internal(nfs, &attr, data, &fh); -} - -static int -nfs3_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_attr *attr, - struct nfs_cb_data *data, struct nfs_fh *fh) -{ - char *path, *slash; - LOOKUP3args args; - - while (*data->path == '/') { - data->path++; - } - - path = data->path; - slash = strchr(path, '/'); - - if (attr && attr->type == NF3LNK) { - if (data->continue_int & O_NOFOLLOW) { - data->cb(-ELOOP, nfs, "Symbolic link encountered", - data->private_data); - free_nfs_cb_data(data); - return -1; - } - if (!data->no_follow || *path != '\0') { - READLINK3args rl_args; - - if (data->link_count++ >= MAX_LINK_COUNT) { - data->cb(-ELOOP, nfs, "Too many levels of " - "symbolic links", data->private_data); - free_nfs_cb_data(data); - return -1; - } - - rl_args.symlink.data.data_len = fh->len; - rl_args.symlink.data.data_val = fh->val; - - if (rpc_nfs3_readlink_async(nfs->rpc, - nfs3_lookup_path_2_cb, - &rl_args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to " - "send READLINK call for %s", - data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - - if (slash != NULL) { - *slash = '/'; - } - return 0; - } - } - - if (slash != NULL) { - /* Clear slash so that path is a zero terminated string for - * the current path component. Set it back to '/' again later - * when we are finished referencing this component so that - * data->saved_path will still point to the full - * normalized path. - */ - *slash = 0; - data->path = slash+1; - } else { - while (*data->path != 0) { - data->path++; - } - } - - if (*path == 0) { - data->fh.len = fh->len; - data->fh.val = malloc(data->fh.len); - if (data->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory: Failed to " - "allocate fh for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - memcpy(data->fh.val, fh->val, data->fh.len); - if (slash != NULL) { - *slash = '/'; - } - data->continue_cb(nfs, attr, data); - return 0; - } - - memset(&args, 0, sizeof(LOOKUP3args)); - args.what.dir.data.data_len = fh->len; - args.what.dir.data.data_val = fh->val; - args.what.name = path; - - if (rpc_nfs3_lookup_async(nfs->rpc, nfs3_lookup_path_1_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send lookup " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - if (slash != NULL) { - *slash = '/'; - } - return 0; -} - -static void -nfs3_lookup_path_getattr_cb(struct rpc_context *rpc, int status, - void *command_data, void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - GETATTR3res *res; - struct nfs_attr attr; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: GETATTR of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - fattr3_to_nfs_attr(&attr, &res->GETATTR3res_u.resok.obj_attributes); - /* This function will always invoke the callback and cleanup - * for failures. So no need to check the return value. - */ - nfs3_lookup_path_async_internal(nfs, &attr, data, &nfs->rootfh); -} - -/* This function will free continue_data on error */ -static int -nfs3_lookuppath_async(struct nfs_context *nfs, const char *path, int no_follow, - nfs_cb cb, void *private_data, - continue_func continue_cb, void *continue_data, - void (*free_continue_data)(void *), - uint64_t continue_int) -{ - struct nfs_cb_data *data; - struct GETATTR3args args; - struct nfs_fh *fh; - - if (path == NULL || path[0] == '\0') { - path = "."; - } - - data = calloc(1, sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory: failed to allocate " - "nfs_cb_data structure"); - if (continue_data) { - free_continue_data(continue_data); - } - return -1; - } - data->nfs = nfs; - data->cb = cb; - data->continue_cb = continue_cb; - data->continue_data = continue_data; - data->free_continue_data = free_continue_data; - data->continue_int = continue_int; - data->private_data = private_data; - data->no_follow = no_follow; - if (path[0] == '/') { - data->saved_path = strdup(path); - } else { - data->saved_path = malloc(strlen(path) + strlen(nfs->cwd) + 2); - if (data->saved_path == NULL) { - nfs_set_error(nfs, "Out of memory: failed to " - "allocate path string"); - free_nfs_cb_data(data); - return -1; - } - sprintf(data->saved_path, "%s/%s", nfs->cwd, path); - } - - if (data->saved_path == NULL) { - nfs_set_error(nfs, "Out of memory: failed to copy path " - "string"); - free_nfs_cb_data(data); - return -1; - } - if (nfs_normalize_path(nfs, data->saved_path) != 0) { - free_nfs_cb_data(data); - return -1; - } - - data->path = data->saved_path; - fh = &nfs->rootfh; - - if (data->path[0]) { - struct nested_mounts *mnt; - /* Make sure we match on longest nested export. - * TODO: If we make sure the list is sorted we can skip this - * check and end the loop on first match. - */ - size_t max_match_len = 0; - - /* Do we need to switch to a different nested export ? */ - for (mnt = nfs->nested_mounts; mnt; mnt = mnt->next) { - if (strlen(mnt->path) < max_match_len) - continue; - if (strncmp(mnt->path, data->saved_path, - strlen(mnt->path))) - continue; - if (data->saved_path[strlen(mnt->path)] != '\0' - && data->saved_path[strlen(mnt->path)] != '/') - continue; - - data->saved_path = strdup(data->path - + strlen(mnt->path)); - free(data->path); - data->path = data->saved_path; - fh = &mnt->fh; - max_match_len = strlen(mnt->path); - } - - /* This function will always invoke the callback and cleanup - * for failures. So no need to check the return value. - */ - nfs3_lookup_path_async_internal(nfs, NULL, data, fh); - return 0; - } - - /* We have a request for "", so just perform a GETATTR3 so we can - * return the attributes to the caller. - */ - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = fh->len; - args.object.data.data_val = fh->val; - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_lookup_path_getattr_cb, - &args, data) != 0) { - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static void -nfs3_mount_8_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct mount_attr_item_cb *ma_item = private_data; - struct mount_attr_cb *ma = ma_item->ma; - struct nfs_cb_data *data = ma->data; - struct nfs_context *nfs = data->nfs; - GETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status != RPC_STATUS_SUCCESS) { - goto finished; - } - - res = command_data; - if (res->status != NFS3_OK) - goto finished; - - fattr3_to_nfs_attr(&ma_item->mnt->attr, - &res->GETATTR3res_u.resok.obj_attributes); - -finished: - free(ma_item); - ma->wait_count--; - if (ma->wait_count > 0) - return; - - free(ma); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static void -nfs3_mount_7_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct mount_attr_cb *ma = NULL; - struct nested_mounts *mnt; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - if (!nfs->nested_mounts) - goto finished; - - /* nested mount traversals are best-effort only, so any - * failures just means that we don't get traversal for that - * particular mount. We do not fail the call from the application. - */ - ma = malloc(sizeof(struct mount_attr_cb)); - if (ma == NULL) - goto finished; - memset(ma, 0, sizeof(struct mount_attr_cb)); - ma->data = data; - - for(mnt = nfs->nested_mounts; mnt; mnt = mnt->next) { - struct mount_attr_item_cb *ma_item; - struct GETATTR3args args; - - ma_item = malloc(sizeof(struct mount_attr_item_cb)); - if (ma_item == NULL) - goto finished; - ma_item->mnt = mnt; - ma_item->ma = ma; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = mnt->fh.len; - args.object.data.data_val = mnt->fh.val; - - if (rpc_nfs3_getattr_async(rpc, nfs3_mount_8_cb, &args, - ma_item) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, - nfs_get_error(nfs)); - free(ma_item); - continue; - } - - ma->wait_count++; - } - -finished: - if (ma && ma->wait_count) - return; - - free(ma); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static void -nfs3_mount_6_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - FSINFO3res *res = command_data; - struct GETATTR3args args; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: FSINFO of %s failed with %s(%d)", - nfs->export, nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs->readmax = res->FSINFO3res_u.resok.rtmax; - nfs->writemax = res->FSINFO3res_u.resok.wtmax; - - /* The server supports sizes up to rtmax and wtmax, so it is legal - * to use smaller transfers sizes. - */ - if (nfs->readmax > NFS_MAX_XFER_SIZE) - nfs->readmax = NFS_MAX_XFER_SIZE; - else if (nfs->readmax < NFSMAXDATA2) { - nfs_set_error(nfs, "server max rsize of %" PRIu64, - nfs->readmax); - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - if (nfs->writemax > NFS_MAX_XFER_SIZE) - nfs->writemax = NFS_MAX_XFER_SIZE; - else if (nfs->writemax < NFSMAXDATA2) { - nfs_set_error(nfs, "server max wsize of %" PRIu64, - nfs->writemax); - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = nfs->rootfh.len; - args.object.data.data_val = nfs->rootfh.val; - - if (rpc_nfs3_getattr_async(rpc, nfs3_mount_7_cb, &args, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } -} - -static void -nfs3_mount_5_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct FSINFO3args args; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - /* NFS TCP: As we are connected now we can pass on the auto-reconnect - * settings to the RPC layer. - */ - rpc_set_autoreconnect(rpc, nfs->auto_reconnect); - - args.fsroot.data.data_len = nfs->rootfh.len; - args.fsroot.data.data_val = nfs->rootfh.val; - if (rpc_nfs3_fsinfo_async(rpc, nfs3_mount_6_cb, &args, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } -} - -struct mount_discovery_cb { - int wait_count; - int error; - int status; - struct nfs_cb_data *data; -}; - -struct mount_discovery_item_cb { - struct mount_discovery_cb *md_cb; - char *path; -}; - -static void -nfs3_mount_4_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct mount_discovery_item_cb *md_item_cb = private_data; - struct mount_discovery_cb *md_cb = md_item_cb->md_cb; - struct nfs_cb_data *data = md_cb->data; - struct nfs_context *nfs = data->nfs; - mountres3 *res; - struct nested_mounts *mnt; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status == RPC_STATUS_ERROR) { - nfs_set_error(nfs, "MOUNT failed with RPC_STATUS_ERROR"); - md_cb->error = -EFAULT; - goto finished; - } - if (status == RPC_STATUS_CANCEL) { - nfs_set_error(nfs, "MOUNT failed with RPC_STATUS_CANCEL"); - md_cb->status = RPC_STATUS_CANCEL; - goto finished; - } - if (status == RPC_STATUS_TIMEOUT) { - nfs_set_error(nfs, "MOUNT timed out"); - md_cb->status = RPC_STATUS_TIMEOUT; - goto finished; - } - - res = command_data; - if (res->fhs_status != MNT3_OK) { - nfs_set_error(nfs, "RPC error: Mount failed with error " - "%s(%d) %s(%d)", - mountstat3_to_str(res->fhs_status), - res->fhs_status, - strerror(-mountstat3_to_errno(res->fhs_status)), - -mountstat3_to_errno(res->fhs_status)); - md_cb->error = mountstat3_to_errno(res->fhs_status); - goto finished; - } - - mnt = malloc(sizeof(*mnt)); - if (mnt == NULL) { - nfs_set_error(nfs, "Out of memory. Could not allocate memory " - "to store mount handle"); - md_cb->error = -ENOMEM; - goto finished; - } - memset(mnt, 0, sizeof(*mnt)); - - mnt->fh.len = res->mountres3_u.mountinfo.fhandle.fhandle3_len; - mnt->fh.val = malloc(mnt->fh.len); - if (mnt->fh.val == NULL) { - free(mnt); - goto finished; - } - memcpy(mnt->fh.val, - res->mountres3_u.mountinfo.fhandle.fhandle3_val, - mnt->fh.len); - - mnt->path = md_item_cb->path; - md_item_cb->path = NULL; - - LIBNFS_LIST_ADD(&nfs->nested_mounts, mnt); - -finished: - free(md_item_cb->path); - free(md_item_cb); - md_cb->wait_count--; - if (md_cb->wait_count > 0) - return; - - rpc_disconnect(rpc, "normal disconnect"); - - if (md_cb->status == RPC_STATUS_CANCEL) { - data->cb(-EINTR, nfs, "Command was cancelled", - data->private_data); - free(md_cb); - free_nfs_cb_data(data); - return; - } - if (md_cb->error) { - data->cb(md_cb->error, nfs, command_data, data->private_data); - free(md_cb); - free_nfs_cb_data(data); - return; - } - - if (nfs->nfsport) { - if (rpc_connect_port_async(nfs->rpc, nfs->server, nfs->nfsport, - NFS_PROGRAM, NFS_V3, - nfs3_mount_5_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free(md_cb); - free_nfs_cb_data(data); - return; - } - return; - } - - if (rpc_connect_program_async(nfs->rpc, nfs->server, NFS_PROGRAM, - NFS_V3, nfs3_mount_5_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free(md_cb); - free_nfs_cb_data(data); - return; - } - free(md_cb); -} - -static void -nfs3_mount_3_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - exports res; - int len; - struct mount_discovery_cb *md_cb = NULL; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - /* Iterate over all exports and check if there are any mounts nested - * below the current mount. - */ - len = strlen(nfs->export); - if (!len) { - data->cb(-EFAULT, nfs, "Export is empty", data->private_data); - free_nfs_cb_data(data); - return; - } - res = *(exports *)command_data; - while (res) { - struct mount_discovery_item_cb *md_item_cb; - - if (strncmp(nfs->export, res->ex_dir, len)) { - res = res->ex_next; - continue; - } - if (res->ex_dir[len - 1] != '/' && res->ex_dir[len] != '/') { - res = res->ex_next; - continue; - } - - /* There is no need to fail the whole mount if anything - * below fails. Just clean up and continue. At worst it - * just mean that we might not be able to access any nested - * mounts. - */ - md_item_cb = malloc(sizeof(*md_item_cb)); - if (md_item_cb == NULL) - continue; - - memset(md_item_cb, 0, sizeof(*md_item_cb)); - - md_item_cb->path = strdup(res->ex_dir + len - - (nfs->export[len -1] == '/')); - if (md_item_cb->path == NULL) { - free(md_item_cb); - continue; - } - - if (md_cb == NULL) { - md_cb = malloc(sizeof(*md_cb)); - if (md_cb == NULL) { - free(md_item_cb->path); - free(md_item_cb); - continue; - } - memset(md_cb, 0, sizeof(*md_cb)); - md_cb->data = data; - md_cb->status = RPC_STATUS_SUCCESS; - md_cb->error = 0; - } - md_item_cb->md_cb = md_cb; - - if (rpc_mount3_mnt_async(rpc, nfs3_mount_4_cb, - res->ex_dir, md_item_cb) != 0) { - nfs_set_error(nfs, "%s: %s", - __FUNCTION__, nfs_get_error(nfs)); - if (md_cb->wait_count == 0) { - free(md_cb); - md_cb = NULL; - } - free(md_item_cb->path); - free(md_item_cb); - continue; - } - md_cb->wait_count++; - - res = res->ex_next; - } - - if (md_cb) - return; - - /* We did not have any nested mounts to check so we can proceed straight - * to reconnecting to NFSd. - */ - rpc_disconnect(rpc, "normal disconnect"); - - if (nfs->nfsport) { - if (rpc_connect_port_async(nfs->rpc, nfs->server, nfs->nfsport, - NFS_PROGRAM, NFS_V3, - nfs3_mount_5_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - return; - } - - if (rpc_connect_program_async(nfs->rpc, nfs->server, NFS_PROGRAM, - NFS_V3, nfs3_mount_5_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } -} - -static void -nfs3_mount_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - mountres3 *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->fhs_status != MNT3_OK) { - nfs_set_error(nfs, "RPC error: Mount failed with error " - "%s(%d) %s(%d)", - mountstat3_to_str(res->fhs_status), - res->fhs_status, - strerror(-mountstat3_to_errno(res->fhs_status)), - -mountstat3_to_errno(res->fhs_status)); - data->cb(mountstat3_to_errno(res->fhs_status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs->rootfh.len = res->mountres3_u.mountinfo.fhandle.fhandle3_len; - nfs->rootfh.val = malloc(nfs->rootfh.len); - if (nfs->rootfh.val == NULL) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - memcpy(nfs->rootfh.val, - res->mountres3_u.mountinfo.fhandle.fhandle3_val, - nfs->rootfh.len); - - if (nfs->auto_traverse_mounts) { - if (rpc_mount3_export_async(rpc, nfs3_mount_3_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - return; - } - - rpc_disconnect(rpc, "normal disconnect"); - if (nfs->nfsport) { - if (rpc_connect_port_async(nfs->rpc, nfs->server, nfs->nfsport, - NFS_PROGRAM, NFS_V3, - nfs3_mount_5_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - return; - } - - if (rpc_connect_program_async(nfs->rpc, nfs->server, NFS_PROGRAM, - NFS_V3, nfs3_mount_5_cb, data) != 0) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } -} - - -static void -nfs3_mount_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - if (rpc_mount3_mnt_async(rpc, nfs3_mount_2_cb, nfs->export, - data) != 0) { - nfs_set_error(nfs, "%s: %s.", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } -} - -int -nfs3_mount_async(struct nfs_context *nfs, const char *server, - const char *export, nfs_cb cb, void *private_data) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - struct nfs_cb_data *data; - char *new_server, *new_export; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory. failed to allocate " - "memory for nfs mount data"); - debugNetPrintf(2,"[LIBNFS] %s malloc error\n",__FUNCTION__); - - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - new_server = strdup(server); - new_export = strdup(export); - if (nfs->server != NULL) { - free(nfs->server); - } - nfs->server = new_server; - if (nfs->export != NULL) { - free(nfs->export); - } - nfs->export = new_export; - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - if (nfs->mountport) { - if (rpc_connect_port_async(nfs->rpc, server, nfs->mountport, - MOUNT_PROGRAM, MOUNT_V3, - nfs3_mount_1_cb, data) != 0) { - nfs_set_error(nfs, "Failed to start connection. %s", - nfs_get_error(nfs)); - free_nfs_cb_data(data); - return -1; - } - return 0; - } - - if (rpc_connect_program_async(nfs->rpc, server, - MOUNT_PROGRAM, MOUNT_V3, - nfs3_mount_1_cb, data) != 0) { - nfs_set_error(nfs, "Failed to start connection. %s", - nfs_get_error(nfs)); - free_nfs_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs3_umount_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - rpc_disconnect(rpc, "umount"); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static void -nfs3_umount_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - if (rpc_mount3_umnt_async(rpc, nfs3_umount_2_cb, nfs->export, - data) != 0) { - nfs_set_error(nfs, "%s: %s.", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } -} - -int -nfs3_umount_async(struct nfs_context *nfs, nfs_cb cb, void *private_data) -{ - struct nfs_cb_data *data; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory. failed to allocate " - "memory for nfs mount data"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - rpc_disconnect(nfs->rpc, "umount"); - - if (nfs->mountport) { - if (rpc_connect_port_async(nfs->rpc, nfs->server, - nfs->mountport, - MOUNT_PROGRAM, MOUNT_V3, - nfs3_umount_1_cb, data) != 0) { - nfs_set_error(nfs, "Failed to start connection. %s", - nfs_get_error(nfs)); - free_nfs_cb_data(data); - return -1; - } - return 0; - } - - if (rpc_connect_program_async(nfs->rpc, nfs->server, - MOUNT_PROGRAM, MOUNT_V3, - nfs3_umount_1_cb, data) != 0) { - nfs_set_error(nfs, "Failed to start connection. %s", - nfs_get_error(nfs)); - free_nfs_cb_data(data); - return -1; - } - - return 0; -} - - -struct nfs_link_data { - char *oldpath; - struct nfs_fh oldfh; - char *newparent; - char *newobject; - struct nfs_fh newdir; -}; - -static void -free_nfs_link_data(void *mem) -{ - struct nfs_link_data *data = mem; - - free(data->oldpath); - free(data->oldfh.val); - free(data->newparent); - free(data->newobject); - free(data->newdir.val); - free(data); -} - -static void -nfs3_link_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - LINK3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfs_link_data *link_data = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: LINK %s -> %s/%s failed with " - "%s(%d)", link_data->oldpath, - link_data->newparent, - link_data->newobject, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &link_data->newdir); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_link_continue_2_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct nfs_link_data *link_data = data->continue_data; - LINK3args args; - - /* steal the filehandle */ - link_data->newdir = data->fh; - data->fh.val = NULL; - - memset(&args, 0, sizeof(LINK3args)); - args.file.data.data_len = link_data->oldfh.len; - args.file.data.data_val = link_data->oldfh.val; - args.link.dir.data.data_len = link_data->newdir.len; - args.link.dir.data.data_val = link_data->newdir.val; - args.link.name = link_data->newobject; - if (rpc_nfs3_link_async(nfs->rpc, nfs3_link_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send LINK " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static int -nfs3_link_continue_1_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct nfs_link_data *link_data = data->continue_data; - - /* steal the filehandle */ - link_data->oldfh = data->fh; - data->fh.val = NULL; - - if (nfs3_lookuppath_async(nfs, link_data->newparent, 0, - data->cb, data->private_data, - nfs3_link_continue_2_internal, - link_data, free_nfs_link_data, 0) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - data->continue_data = NULL; - free_nfs_cb_data(data); - return -1; - } - data->continue_data = NULL; - free_nfs_cb_data(data); - - return 0; -} - -int -nfs3_link_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data) -{ - char *ptr; - struct nfs_link_data *link_data; - - link_data = malloc(sizeof(struct nfs_link_data)); - if (link_data == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for link data"); - return -1; - } - memset(link_data, 0, sizeof(struct nfs_link_data)); - - link_data->oldpath = strdup(oldpath); - if (link_data->oldpath == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for oldpath"); - free_nfs_link_data(link_data); - return -1; - } - - link_data->newobject = strdup(newpath); - if (link_data->newobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to strdup " - "newpath"); - free_nfs_link_data(link_data); - return -1; - } - ptr = strrchr(link_data->newobject, '/'); - if (ptr == NULL) { - link_data->newparent = NULL; - } else { - *ptr = 0; - link_data->newparent = link_data->newobject; - - ptr++; - link_data->newobject = strdup(ptr); - } - if (link_data->newobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for newobject"); - free_nfs_link_data(link_data); - return -1; - } - - if (nfs3_lookuppath_async(nfs, link_data->oldpath, 0, - cb, private_data, - nfs3_link_continue_1_internal, - link_data, free_nfs_link_data, 0) != 0) { - return -1; - } - - return 0; -} - -struct nfs_rename_data { - char *oldparent; - char *oldobject; - struct nfs_fh olddir; - char *newparent; - char *newobject; - struct nfs_fh newdir; -}; - -static void -free_nfs_rename_data(void *mem) -{ - struct nfs_rename_data *data = mem; - - free(data->oldparent); - free(data->oldobject); - free(data->olddir.val); - free(data->newparent); - free(data->newobject); - free(data->newdir.val); - free(data); -} - -static void -nfs3_rename_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - RENAME3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfs_rename_data *rename_data = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: RENAME %s/%s -> %s/%s failed " - "with %s(%d)", rename_data->oldparent, - rename_data->oldobject, rename_data->newparent, - rename_data->newobject, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_rename_continue_2_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct nfs_rename_data *rename_data = data->continue_data; - RENAME3args args; - - /* Drop the destination directory from the cache */ - nfs_dircache_drop(nfs, &data->fh); - - /* steal the filehandle */ - rename_data->newdir = data->fh; - data->fh.val = NULL; - - args.from.dir.data.data_len = rename_data->olddir.len; - args.from.dir.data.data_val = rename_data->olddir.val; - args.from.name = rename_data->oldobject; - args.to.dir.data.data_len = rename_data->newdir.len; - args.to.dir.data.data_val = rename_data->newdir.val; - args.to.name = rename_data->newobject; - if (rpc_nfs3_rename_async(nfs->rpc, nfs3_rename_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send RENAME " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static int -nfs3_rename_continue_1_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct nfs_rename_data *rename_data = data->continue_data; - - /* Drop the source directory from the cache */ - nfs_dircache_drop(nfs, &data->fh); - - /* steal the filehandle */ - rename_data->olddir = data->fh; - data->fh.val = NULL; - - if (nfs3_lookuppath_async(nfs, rename_data->newparent, 0, - data->cb, data->private_data, - nfs3_rename_continue_2_internal, - rename_data, free_nfs_rename_data, 0) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - data->continue_data = NULL; - free_nfs_cb_data(data); - return -1; - } - data->continue_data = NULL; - free_nfs_cb_data(data); - - return 0; -} - -int -nfs3_rename_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data) -{ - char *ptr; - struct nfs_rename_data *rename_data; - - rename_data = malloc(sizeof(struct nfs_rename_data)); - if (rename_data == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for rename data"); - return -1; - } - memset(rename_data, 0, sizeof(struct nfs_rename_data)); - - rename_data->oldobject = strdup(oldpath); - if (rename_data->oldobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to strdup " - "oldpath"); - free_nfs_rename_data(rename_data); - return -1; - } - ptr = strrchr(rename_data->oldobject, '/'); - if (ptr == NULL) { - rename_data->oldparent = NULL; - } else { - *ptr = 0; - rename_data->oldparent = rename_data->oldobject; - - ptr++; - rename_data->oldobject = strdup(ptr); - } - if (rename_data->oldobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for oldobject"); - free_nfs_rename_data(rename_data); - return -1; - } - - rename_data->newobject = strdup(newpath); - if (rename_data->newobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to strdup " - "newpath"); - free_nfs_rename_data(rename_data); - return -1; - } - ptr = strrchr(rename_data->newobject, '/'); - if (ptr == NULL) { - rename_data->newparent = NULL; - } else { - *ptr = 0; - rename_data->newparent = rename_data->newobject; - - ptr++; - rename_data->newobject = strdup(ptr); - } - if (rename_data->newobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for newobject"); - free_nfs_rename_data(rename_data); - return -1; - } - - if (nfs3_lookuppath_async(nfs, rename_data->oldparent, 0, - cb, private_data, - nfs3_rename_continue_1_internal, - rename_data, free_nfs_rename_data, 0) != 0) { - return -1; - } - - return 0; -} - - -struct nfs_symlink_data { - char *target; - char *linkparent; - char *linkobject; -}; - -static void -free_nfs_symlink_data(void *mem) -{ - struct nfs_symlink_data *data = mem; - - free(data->target); - free(data->linkparent); - free(data->linkobject); - free(data); -} - -static void -nfs3_symlink_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - SYMLINK3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfs_symlink_data *symlink_data = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: SYMLINK %s/%s -> %s failed with " - "%s(%d)", symlink_data->linkparent, - symlink_data->linkobject, - symlink_data->target, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_symlink_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct nfs_symlink_data *symlink_data = data->continue_data; - SYMLINK3args args; - - memset(&args, 0, sizeof(SYMLINK3args)); - args.where.dir.data.data_len = data->fh.len; - args.where.dir.data.data_val = data->fh.val; - args.where.name = symlink_data->linkobject; - args.symlink.symlink_attributes.mode.set_it = 1; - args.symlink.symlink_attributes.mode.set_mode3_u.mode = S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH; - args.symlink.symlink_data = symlink_data->target; - - if (rpc_nfs3_symlink_async(nfs->rpc, nfs3_symlink_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send SYMLINK " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_symlink_async(struct nfs_context *nfs, const char *target, - const char *linkname, nfs_cb cb, void *private_data) -{ - char *ptr; - struct nfs_symlink_data *symlink_data; - - symlink_data = malloc(sizeof(struct nfs_symlink_data)); - if (symlink_data == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for symlink data"); - return -1; - } - memset(symlink_data, 0, sizeof(struct nfs_symlink_data)); - - symlink_data->target = strdup(target); - if (symlink_data->target == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for target"); - free_nfs_symlink_data(symlink_data); - return -1; - } - - symlink_data->linkobject = strdup(linkname); - if (symlink_data->linkobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to strdup " - "linkname"); - free_nfs_symlink_data(symlink_data); - return -1; - } - ptr = strrchr(symlink_data->linkobject, '/'); - if (ptr == NULL) { - symlink_data->linkparent = NULL; - } else { - *ptr = 0; - symlink_data->linkparent = symlink_data->linkobject; - - ptr++; - symlink_data->linkobject = strdup(ptr); - } - - if (symlink_data->linkobject == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "mode buffer for new path"); - free_nfs_symlink_data(symlink_data); - return -1; - } - - if (nfs3_lookuppath_async(nfs, symlink_data->linkparent, 0, - cb, private_data, - nfs3_symlink_continue_internal, - symlink_data, free_nfs_symlink_data, 0) - != 0) { - return -1; - } - - return 0; -} - - -static void -nfs3_access2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - ACCESS3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - unsigned int result = 0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: ACCESS of %s failed with %s(%d)", - data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - if (res->ACCESS3res_u.resok.access & ACCESS3_READ) { - result |= R_OK; - } - if (res->ACCESS3res_u.resok.access & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE)) { - result |= W_OK; - } - if (res->ACCESS3res_u.resok.access & (ACCESS3_LOOKUP | ACCESS3_EXECUTE)) { - result |= X_OK; - } - - data->cb(result, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_access2_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - ACCESS3args args; - - memset(&args, 0, sizeof(ACCESS3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - args.access = ACCESS3_READ | ACCESS3_LOOKUP | ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE | ACCESS3_EXECUTE; - - if (rpc_nfs3_access_async(nfs->rpc, nfs3_access2_cb, - &args, data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_access2_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_access2_continue_internal, - NULL, NULL, 0) != 0) { - return -1; - } - - return 0; -} - - -static void -nfs3_access_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - ACCESS3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - unsigned int mode = 0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: ACCESS of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - if ((data->continue_int & R_OK) && (res->ACCESS3res_u.resok.access & ACCESS3_READ)) { - mode |= R_OK; - } - if ((data->continue_int & W_OK) && (res->ACCESS3res_u.resok.access & (ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE))) { - mode |= W_OK; - } - if ((data->continue_int & X_OK) && (res->ACCESS3res_u.resok.access & (ACCESS3_LOOKUP | ACCESS3_EXECUTE))) { - mode |= X_OK; - } - - if (data->continue_int != mode) { - nfs_set_error(nfs, "NFS: ACCESS denied. Required access " - "%c%c%c. Allowed access %c%c%c", - data->continue_int&R_OK?'r':'-', - data->continue_int&W_OK?'w':'-', - data->continue_int&X_OK?'x':'-', - mode&R_OK?'r':'-', - mode&W_OK?'w':'-', - mode&X_OK?'x':'-'); - data->cb(-EACCES, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_access_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - int nfsmode = 0; - ACCESS3args args; - - if (data->continue_int & R_OK) { - nfsmode |= ACCESS3_READ; - } - if (data->continue_int & W_OK) { - nfsmode |= ACCESS3_MODIFY | ACCESS3_EXTEND | ACCESS3_DELETE; - } - if (data->continue_int & X_OK) { - nfsmode |= ACCESS3_LOOKUP | ACCESS3_EXECUTE; - } - - memset(&args, 0, sizeof(ACCESS3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - args.access = nfsmode; - - if (rpc_nfs3_access_async(nfs->rpc, nfs3_access_cb, &args, data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_access_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_access_continue_internal, - NULL, NULL, - mode & (R_OK | W_OK | X_OK)) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_utimes_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - SETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: SETATTR failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_utimes_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - SETATTR3args args; - struct timeval *utimes_data = data->continue_data; - - memset(&args, 0, sizeof(SETATTR3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - if (utimes_data != NULL) { - args.new_attributes.atime.set_it = SET_TO_CLIENT_TIME; - args.new_attributes.atime.set_atime_u.atime.seconds = utimes_data[0].tv_sec; - args.new_attributes.atime.set_atime_u.atime.nseconds = utimes_data[0].tv_usec * 1000; - args.new_attributes.mtime.set_it = SET_TO_CLIENT_TIME; - args.new_attributes.mtime.set_mtime_u.mtime.seconds = utimes_data[1].tv_sec; - args.new_attributes.mtime.set_mtime_u.mtime.nseconds = utimes_data[1].tv_usec * 1000; - } else { - args.new_attributes.atime.set_it = SET_TO_SERVER_TIME; - args.new_attributes.mtime.set_it = SET_TO_SERVER_TIME; - } - - if (rpc_nfs3_setattr_async(nfs->rpc, nfs3_utimes_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send SETATTR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_utimes_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, struct timeval *times, - nfs_cb cb, void *private_data) -{ - struct timeval *new_times = NULL; - - if (times != NULL) { - new_times = malloc(sizeof(struct timeval)*2); - if (new_times == NULL) { - nfs_set_error(nfs, "Failed to allocate memory " - "for timeval structure"); - return -1; - } - - memcpy(new_times, times, sizeof(struct timeval)*2); - } - - if (nfs3_lookuppath_async(nfs, path, no_follow, cb, private_data, - nfs3_utimes_continue_internal, - new_times, free, 0) != 0) { - return -1; - } - - return 0; -} - -int -nfs3_utime_async(struct nfs_context *nfs, const char *path, - struct utimbuf *times, nfs_cb cb, void *private_data) -{ - struct timeval *new_times = NULL; - - if (times != NULL) { - new_times = malloc(sizeof(struct timeval)*2); - if (new_times == NULL) { - nfs_set_error(nfs, "Failed to allocate memory " - "for timeval structure"); - return -1; - } - - new_times[0].tv_sec = times->actime; - new_times[0].tv_usec = 0; - new_times[1].tv_sec = times->modtime; - new_times[1].tv_usec = 0; - } - - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_utimes_continue_internal, - new_times, free, 0) != 0) { - return -1; - } - - return 0; -} - - -static void -nfs3_chown_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - SETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: SETATTR failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -struct nfs_chown_data { - uid_t uid; - gid_t gid; -}; - -static int -nfs3_chown_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - SETATTR3args args; - struct nfs_chown_data *chown_data = data->continue_data; - - memset(&args, 0, sizeof(SETATTR3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - if (chown_data->uid != (uid_t)-1) { - args.new_attributes.uid.set_it = 1; - args.new_attributes.uid.set_uid3_u.uid = chown_data->uid; - } - if (chown_data->gid != (gid_t)-1) { - args.new_attributes.gid.set_it = 1; - args.new_attributes.gid.set_gid3_u.gid = chown_data->gid; - } - - if (rpc_nfs3_setattr_async(nfs->rpc, nfs3_chown_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send SETATTR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_chown_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int uid, int gid, - nfs_cb cb, void *private_data) -{ - struct nfs_chown_data *chown_data; - - chown_data = malloc(sizeof(struct nfs_chown_data)); - if (chown_data == NULL) { - nfs_set_error(nfs, "Failed to allocate memory for " - "chown data structure"); - return -1; - } - - chown_data->uid = uid; - chown_data->gid = gid; - - if (nfs3_lookuppath_async(nfs, path, no_follow, cb, private_data, - nfs3_chown_continue_internal, - chown_data, free, 0) != 0) { - return -1; - } - - return 0; -} - -int -nfs3_fchown_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, - int gid, nfs_cb cb, void *private_data) -{ - struct nfs_cb_data *data; - struct nfs_chown_data *chown_data; - - chown_data = malloc(sizeof(struct nfs_chown_data)); - if (chown_data == NULL) { - nfs_set_error(nfs, "Failed to allocate memory for " - "fchown data structure"); - return -1; - } - - chown_data->uid = uid; - chown_data->gid = gid; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory. failed to allocate " - "memory for fchown data"); - free(chown_data); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - data->continue_data = chown_data; - data->free_continue_data = free; - data->fh.len = nfsfh->fh.len; - data->fh.val = malloc(data->fh.len); - if (data->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory: Failed to allocate fh"); - free_nfs_cb_data(data); - return -1; - } - memcpy(data->fh.val, nfsfh->fh.val, data->fh.len); - - if (nfs3_chown_continue_internal(nfs, NULL, data) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_chmod_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - SETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: SETATTR failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_chmod_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - SETATTR3args args; - - memset(&args, 0, sizeof(SETATTR3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - args.new_attributes.mode.set_it = 1; - args.new_attributes.mode.set_mode3_u.mode = (mode3)data->continue_int; - - if (rpc_nfs3_setattr_async(nfs->rpc, nfs3_chmod_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send SETATTR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_chmod_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int mode, nfs_cb cb, - void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, no_follow, cb, private_data, - nfs3_chmod_continue_internal, - NULL, NULL, mode) != 0) { - return -1; - } - - return 0; -} - -int -nfs3_fchmod_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode, - nfs_cb cb, void *private_data) -{ - struct nfs_cb_data *data; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory. failed to allocate " - "memory for fchmod data"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - data->continue_int = mode; - data->fh.len = nfsfh->fh.len; - data->fh.val = malloc(data->fh.len); - if (data->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory: Failed to allocate fh"); - free_nfs_cb_data(data); - return -1; - } - memcpy(data->fh.val, nfsfh->fh.val, data->fh.len); - - if (nfs3_chmod_continue_internal(nfs, NULL, data) != 0) { - return -1; - } - - return 0; -} - - -static void -nfs3_readlink_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - READLINK3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: READLINK of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - data->cb(0, nfs, res->READLINK3res_u.resok.data, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_readlink_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - READLINK3args args; - - args.symlink.data.data_val = data->fh.val; - args.symlink.data.data_len = data->fh.len; - - if (rpc_nfs3_readlink_async(nfs->rpc, nfs3_readlink_1_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send READLINK " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 1, cb, private_data, - nfs3_readlink_continue_internal, - NULL, NULL, 0) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_statvfs_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - FSSTAT3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct statvfs svfs; - struct nfs_statvfs_64 svfs64; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: FSSTAT of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - if (data->continue_int == 0) { - /* statvfs */ - svfs.f_bsize = NFS_BLKSIZE; - svfs.f_frsize = NFS_BLKSIZE; - svfs.f_blocks = res->FSSTAT3res_u.resok.tbytes/NFS_BLKSIZE; - svfs.f_bfree = res->FSSTAT3res_u.resok.fbytes/NFS_BLKSIZE; - svfs.f_bavail = res->FSSTAT3res_u.resok.abytes/NFS_BLKSIZE; - svfs.f_files = (uint32_t)res->FSSTAT3res_u.resok.tfiles; - svfs.f_ffree = (uint32_t)res->FSSTAT3res_u.resok.ffiles; -#if !defined(__ANDROID__) - svfs.f_favail = (uint32_t)res->FSSTAT3res_u.resok.afiles; - svfs.f_fsid = 0; - svfs.f_flag = 0; - svfs.f_namemax = 256; -#endif - data->cb(0, nfs, &svfs, data->private_data); - } else { - /* statvfs64 */ - svfs64.f_bsize = NFS_BLKSIZE; - svfs64.f_frsize = NFS_BLKSIZE; - svfs64.f_blocks = res->FSSTAT3res_u.resok.tbytes/NFS_BLKSIZE; - svfs64.f_bfree = res->FSSTAT3res_u.resok.fbytes/NFS_BLKSIZE; - svfs64.f_bavail = res->FSSTAT3res_u.resok.abytes/NFS_BLKSIZE; - svfs64.f_files = res->FSSTAT3res_u.resok.tfiles; - svfs64.f_ffree = res->FSSTAT3res_u.resok.ffiles; - svfs64.f_favail = res->FSSTAT3res_u.resok.afiles; - svfs64.f_fsid = 0; - svfs64.f_flag = 0; - svfs64.f_namemax = 256; - - data->cb(0, nfs, &svfs64, data->private_data); - } - - free_nfs_cb_data(data); -} - -static int -nfs3_statvfs_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - FSSTAT3args args; - - args.fsroot.data.data_len = data->fh.len; - args.fsroot.data.data_val = data->fh.val; - if (rpc_nfs3_fsstat_async(nfs->rpc, nfs3_statvfs_1_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send FSSTAT " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_statvfs_continue_internal, - NULL, NULL, 0) != 0) { - return -1; - } - - return 0; -} - -int -nfs3_statvfs64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_statvfs_continue_internal, - NULL, NULL, 1) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_lseek_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - GETATTR3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - int64_t size = 0; - int64_t offset = (int64_t) data->offset; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: GETATTR failed with " - "%s(%d)", nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free(data); - return; - } - - size = (int64_t)res->GETATTR3res_u.resok.obj_attributes.size; - - if (offset < 0 && - -offset > (int64_t)size) { - data->cb(-EINVAL, nfs, &data->nfsfh->offset, - data->private_data); - } else { - data->nfsfh->offset = data->offset + size; - data->cb(0, nfs, &data->nfsfh->offset, data->private_data); - } - - free(data); -} - -int -nfs3_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int64_t offset, - int whence, nfs_cb cb, void *private_data) -{ - struct nfs_cb_data *data; - struct GETATTR3args args; - - if (whence == SEEK_SET) { - if (offset < 0) { - cb(-EINVAL, nfs, &nfsfh->offset, private_data); - } else { - nfsfh->offset = offset; - cb(0, nfs, &nfsfh->offset, private_data); - } - return 0; - } - if (whence == SEEK_CUR) { - if (offset < 0 && - nfsfh->offset < (uint64_t)(-offset)) { - cb(-EINVAL, nfs, &nfsfh->offset, private_data); - } else { - nfsfh->offset += offset; - cb(0, nfs, &nfsfh->offset, private_data); - } - return 0; - } - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "Out Of Memory: Failed to malloc nfs " - "cb data"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - - data->nfs = nfs; - data->nfsfh = nfsfh; - data->offset = offset; - data->cb = cb; - data->private_data = private_data; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = nfsfh->fh.len; - args.object.data.data_val = nfsfh->fh.val; - - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_lseek_1_cb, - &args, data) != 0) { - free(data); - return -1; - } - return 0; -} - - -/* ReadDirPlus Emulation Callback data */ -struct rdpe_cb_data { - int getattrcount; - int status; - struct nfs_cb_data *data; -}; - -/* ReadDirPlus Emulation LOOKUP Callback data */ -struct rdpe_lookup_cb_data { - struct rdpe_cb_data *rdpe_cb_data; - struct nfsdirent *nfsdirent; -}; - -/* Workaround for servers lacking READDIRPLUS. - * Use READDIR instead and a GETATTR-loop */ -static void -nfs3_opendir_3_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - LOOKUP3res *res = command_data; - struct rdpe_lookup_cb_data *rdpe_lookup_cb_data = private_data; - struct rdpe_cb_data *rdpe_cb_data = rdpe_lookup_cb_data->rdpe_cb_data; - struct nfs_cb_data *data = rdpe_cb_data->data; - struct nfsdir *nfsdir = data->continue_data; - struct nfs_context *nfs = data->nfs; - struct nfsdirent *nfsdirent = rdpe_lookup_cb_data->nfsdirent; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - free(rdpe_lookup_cb_data); - - rdpe_cb_data->getattrcount--; - - if (status == RPC_STATUS_ERROR) { - - nfs_set_error(nfs, "LOOKUP during READDIRPLUS emulation " - "failed with RPC_STATUS_ERROR"); - rdpe_cb_data->status = RPC_STATUS_ERROR; - } - if (status == RPC_STATUS_CANCEL) { - nfs_set_error(nfs, "LOOKUP during READDIRPLUS emulation " - "failed with RPC_STATUS_CANCEL"); - rdpe_cb_data->status = RPC_STATUS_CANCEL; - } - if (status == RPC_STATUS_TIMEOUT) { - nfs_set_error(nfs, "LOOKUP during READDIRPLUS emulation " - "timed out"); - rdpe_cb_data->status = RPC_STATUS_CANCEL; - } - if (status == RPC_STATUS_SUCCESS && res->status == NFS3_OK) { - if (res->LOOKUP3res_u.resok.obj_attributes.attributes_follow) { - fattr3 *attributes = &res->LOOKUP3res_u.resok.obj_attributes.post_op_attr_u.attributes; - - nfsdirent->type = attributes->type; - nfsdirent->mode = attributes->mode; - switch (nfsdirent->type) { - case NF3REG: nfsdirent->mode |= S_IFREG; break; - case NF3DIR: nfsdirent->mode |= S_IFDIR; break; - case NF3BLK: nfsdirent->mode |= S_IFBLK; break; - case NF3CHR: nfsdirent->mode |= S_IFCHR; break; - case NF3LNK: nfsdirent->mode |= S_IFLNK; break; - case NF3SOCK: nfsdirent->mode |= S_IFSOCK; break; - case NF3FIFO: nfsdirent->mode |= S_IFIFO; break; - }; - nfsdirent->size = attributes->size; - - nfsdirent->atime.tv_sec = attributes->atime.seconds; - nfsdirent->atime.tv_usec = attributes->atime.nseconds/1000; - nfsdirent->atime_nsec = attributes->atime.nseconds; - nfsdirent->mtime.tv_sec = attributes->mtime.seconds; - nfsdirent->mtime.tv_usec = attributes->mtime.nseconds/1000; - nfsdirent->mtime_nsec = attributes->mtime.nseconds; - nfsdirent->ctime.tv_sec = attributes->ctime.seconds; - nfsdirent->ctime.tv_usec = attributes->ctime.nseconds/1000; - nfsdirent->ctime_nsec = attributes->ctime.nseconds; - nfsdirent->uid = attributes->uid; - nfsdirent->gid = attributes->gid; - nfsdirent->nlink = attributes->nlink; - nfsdirent->dev = attributes->fsid; - nfsdirent->rdev = specdata3_to_rdev(&attributes->rdev); - nfsdirent->blksize = NFS_BLKSIZE; - nfsdirent->blocks = (attributes->used + 512 - 1) / 512; - nfsdirent->used = attributes->used; - } - } - - if (rdpe_cb_data->getattrcount == 0) { - if (rdpe_cb_data->status != RPC_STATUS_SUCCESS) { - nfs_set_error(nfs, "READDIRPLUS emulation " - "failed: %s", rpc_get_error(rpc)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - nfs_free_nfsdir(nfsdir); - } else { - data->cb(0, nfs, nfsdir, data->private_data); - } - free(rdpe_cb_data); - data->continue_data = NULL; - free_nfs_cb_data(data); - } -} - -static int -lookup_missing_attributes(struct nfs_context *nfs, - struct nfsdir *nfsdir, - struct nfs_cb_data *data) -{ - struct rdpe_cb_data *rdpe_cb_data = NULL; - struct nfsdirent *nfsdirent; - - for (nfsdirent = nfsdir->entries; - nfsdirent; - nfsdirent = nfsdirent->next) { - struct rdpe_lookup_cb_data *rdpe_lookup_cb_data; - LOOKUP3args args; - - /* If type == 0 we assume it is a case of the server not - * giving us the attributes for this entry during READIR[PLUS] - * so we fallback to LOOKUP3 - */ - if (nfsdirent->type != 0) { - continue; - } - - if (rdpe_cb_data == NULL) { - rdpe_cb_data = malloc(sizeof(struct rdpe_cb_data)); - rdpe_cb_data->getattrcount = 0; - rdpe_cb_data->status = RPC_STATUS_SUCCESS; - rdpe_cb_data->data = data; - } - rdpe_lookup_cb_data = malloc(sizeof(struct rdpe_lookup_cb_data)); - rdpe_lookup_cb_data->rdpe_cb_data = rdpe_cb_data; - rdpe_lookup_cb_data->nfsdirent = nfsdirent; - - memset(&args, 0, sizeof(LOOKUP3args)); - args.what.dir.data.data_len = data->fh.len; - args.what.dir.data.data_val = data->fh.val; - args.what.name = nfsdirent->name; - - if (rpc_nfs3_lookup_async(nfs->rpc, nfs3_opendir_3_cb, &args, - rdpe_lookup_cb_data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "READDIR LOOKUP call"); - - /* if we have already commands in flight, we cant just - * stop, we have to wait for the commands in flight to - * complete - */ - continue; - } - rdpe_cb_data->getattrcount++; - } - if (rdpe_cb_data != NULL) { - return rdpe_cb_data->getattrcount; - } - return 0; -} - -static void -nfs3_opendir_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - READDIR3res *res = command_data; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsdir *nfsdir = data->continue_data; - struct nfsdirent *nfsdirent; - struct entry3 *entry; - uint64_t cookie = 0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: READDIR of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - - entry =res->READDIR3res_u.resok.reply.entries; - while (entry != NULL) { - nfsdirent = malloc(sizeof(struct nfsdirent)); - if (nfsdirent == NULL) { - data->cb(-ENOMEM, nfs, "Failed to allocate dirent", - data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - memset(nfsdirent, 0, sizeof(struct nfsdirent)); - nfsdirent->name = strdup(entry->name); - if (nfsdirent->name == NULL) { - data->cb(-ENOMEM, nfs, "Failed to allocate " - "dirent->name", data->private_data); - free(nfsdirent); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - nfsdirent->inode = entry->fileid; - - nfsdirent->next = nfsdir->entries; - nfsdir->entries = nfsdirent; - - cookie = entry->cookie; - entry = entry->nextentry; - } - - if (res->READDIR3res_u.resok.reply.eof == 0) { - READDIR3args args; - - args.dir.data.data_len = data->fh.len; - args.dir.data.data_val = data->fh.val; - args.cookie = cookie; - memcpy(&args.cookieverf, res->READDIR3res_u.resok.cookieverf, - sizeof(cookieverf3)); - args.count = 8192; - - if (rpc_nfs3_readdir_async(nfs->rpc, nfs3_opendir_2_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "READDIR call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - return; - } - - if (res->READDIR3res_u.resok.dir_attributes.attributes_follow) - fattr3_to_nfs_attr(&nfsdir->attr, &res->READDIR3res_u.resok.dir_attributes.post_op_attr_u.attributes); - - /* steal the dirhandle */ - nfsdir->current = nfsdir->entries; - - if (lookup_missing_attributes(nfs, nfsdir, data) == 0) { - data->cb(0, nfs, nfsdir, data->private_data); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } -} - -static void -nfs3_opendir_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - READDIRPLUS3res *res = command_data; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsdir *nfsdir = data->continue_data; - struct entryplus3 *entry; - uint64_t cookie = 0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - - if (status == RPC_STATUS_SUCCESS && res->status == NFS3ERR_NOTSUPP) { - READDIR3args args; - - args.dir.data.data_len = data->fh.len; - args.dir.data.data_val = data->fh.val; - args.cookie = cookie; - memset(&args.cookieverf, 0, sizeof(cookieverf3)); - args.count = 8192; - - if (rpc_nfs3_readdir_async(nfs->rpc, nfs3_opendir_2_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "READDIR call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - return; - } - - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: READDIRPLUS of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - - entry =res->READDIRPLUS3res_u.resok.reply.entries; - while (entry != NULL) { - struct nfsdirent *nfsdirent; - struct nfs_attr attr; - int has_attr = 0; - - memset(&attr, 0, sizeof(attr)); - - nfsdirent = malloc(sizeof(struct nfsdirent)); - if (nfsdirent == NULL) { - data->cb(-ENOMEM, nfs, "Failed to allocate dirent", - data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - memset(nfsdirent, 0, sizeof(struct nfsdirent)); - nfsdirent->name = strdup(entry->name); - if (nfsdirent->name == NULL) { - data->cb(-ENOMEM, nfs, "Failed to allocate " - "dirent->name", data->private_data); - free(nfsdirent); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - nfsdirent->inode = entry->fileid; - - if (entry->name_attributes.attributes_follow) { - fattr3_to_nfs_attr(&attr, &entry->name_attributes.post_op_attr_u.attributes); - has_attr = 1; - } - - if (!has_attr) { - struct nested_mounts *mnt; - int splen = strlen(data->saved_path); - - /* A single '/' is a special case, treat it as - * zero-length below. */ - if (splen == 1) - splen = 0; - - /* No name attributes. Is it a nested mount then?*/ - for(mnt = nfs->nested_mounts; mnt; mnt = mnt->next) { - if (strncmp(data->saved_path, mnt->path, splen)) - continue; - if (mnt->path[splen] != '/') - continue; - if (strcmp(mnt->path + splen + 1, entry->name)) - continue; - attr = mnt->attr; - has_attr = 1; - break; - } - } - if (has_attr) { - struct specdata3 sd3 = { attr.rdev.specdata1, - attr.rdev.specdata2 }; - - nfsdirent->type = attr.type; - nfsdirent->mode = attr.mode; - switch (nfsdirent->type) { - case NF3REG: nfsdirent->mode |= S_IFREG; break; - case NF3DIR: nfsdirent->mode |= S_IFDIR; break; - case NF3BLK: nfsdirent->mode |= S_IFBLK; break; - case NF3CHR: nfsdirent->mode |= S_IFCHR; break; - case NF3LNK: nfsdirent->mode |= S_IFLNK; break; - case NF3SOCK: nfsdirent->mode |= S_IFSOCK; break; - case NF3FIFO: nfsdirent->mode |= S_IFIFO; break; - }; - nfsdirent->size = attr.size; - - nfsdirent->atime.tv_sec = attr.atime.seconds; - nfsdirent->atime.tv_usec = attr.atime.nseconds/1000; - nfsdirent->atime_nsec = attr.atime.nseconds; - nfsdirent->mtime.tv_sec = attr.mtime.seconds; - nfsdirent->mtime.tv_usec = attr.mtime.nseconds/1000; - nfsdirent->mtime_nsec = attr.mtime.nseconds; - nfsdirent->ctime.tv_sec = attr.ctime.seconds; - nfsdirent->ctime.tv_usec = attr.ctime.nseconds/1000; - nfsdirent->ctime_nsec = attr.ctime.nseconds; - nfsdirent->uid = attr.uid; - nfsdirent->gid = attr.gid; - nfsdirent->nlink = attr.nlink; - nfsdirent->dev = attr.fsid; - nfsdirent->rdev = specdata3_to_rdev(&sd3); - nfsdirent->blksize = NFS_BLKSIZE; - nfsdirent->blocks = (attr.used + 512 - 1) / 512; - nfsdirent->used = attr.used; - } - - nfsdirent->next = nfsdir->entries; - nfsdir->entries = nfsdirent; - - cookie = entry->cookie; - entry = entry->nextentry; - } - - if (res->READDIRPLUS3res_u.resok.reply.eof == 0) { - READDIRPLUS3args args; - - args.dir.data.data_len = data->fh.len; - args.dir.data.data_val = data->fh.val; - args.cookie = cookie; - memcpy(&args.cookieverf, - res->READDIRPLUS3res_u.resok.cookieverf, - sizeof(cookieverf3)); - args.dircount = 8192; - args.maxcount = 8192; - - if (rpc_nfs3_readdirplus_async(nfs->rpc, nfs3_opendir_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "READDIRPLUS call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - nfs_free_nfsdir(nfsdir); - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } - return; - } - - if (res->READDIRPLUS3res_u.resok.dir_attributes.attributes_follow) { - fattr3_to_nfs_attr(&nfsdir->attr, &res->READDIRPLUS3res_u.resok.dir_attributes.post_op_attr_u.attributes); - } - - /* steal the dirhandle */ - nfsdir->current = nfsdir->entries; - - if (lookup_missing_attributes(nfs, nfsdir, data) == 0) { - data->cb(0, nfs, nfsdir, data->private_data); - /* We can not free data->continue_data here */ - data->continue_data = NULL; - free_nfs_cb_data(data); - return; - } -} - -static int -nfs3_opendir_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr, - struct nfs_cb_data *data) -{ - READDIRPLUS3args args; - struct nfsdir *nfsdir = data->continue_data; - struct nfsdir *cached; - - cached = nfs_dircache_find(nfs, &data->fh); - if (cached) { - if (attr && attr->mtime.seconds == cached->attr.mtime.seconds - && attr->mtime.nseconds == cached->attr.mtime.nseconds) { - cached->current = cached->entries; - data->cb(0, nfs, cached, data->private_data); - free_nfs_cb_data(data); - return 0; - } else { - /* cache must be stale */ - nfs_free_nfsdir(cached); - } - } - - nfsdir->fh.len = data->fh.len; - nfsdir->fh.val = malloc(nfsdir->fh.len); - if (nfsdir->fh.val == NULL) { - nfs_set_error(nfs, "OOM when allocating fh for nfsdir"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - memcpy(nfsdir->fh.val, data->fh.val, data->fh.len); - - args.dir.data.data_len = data->fh.len; - args.dir.data.data_val = data->fh.val; - args.cookie = 0; - memset(&args.cookieverf, 0, sizeof(cookieverf3)); - args.dircount = 8192; - args.maxcount = 8192; - if (rpc_nfs3_readdirplus_async(nfs->rpc, nfs3_opendir_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "READDIRPLUS call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_opendir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - struct nfsdir *nfsdir; - - nfsdir = malloc(sizeof(struct nfsdir)); - if (nfsdir == NULL) { - nfs_set_error(nfs, "failed to allocate buffer for nfsdir"); - return -1; - } - memset(nfsdir, 0, sizeof(struct nfsdir)); - - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_opendir_continue_internal, - nfsdir, free, 0) != 0) { - return -1; - } - - return 0; -} - -struct mknod_cb_data { - char *path; - int mode; - int major; - int minor; -}; - -static void -free_mknod_cb_data(void *ptr) -{ - struct mknod_cb_data *data = ptr; - - free(data->path); - free(data); -} - -static void -nfs3_mknod_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - MKNOD3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - char *str = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - str = &str[strlen(str) + 1]; - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: MKNOD of %s/%s failed with " - "%s(%d)", data->saved_path, str, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_mknod_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct mknod_cb_data *cb_data = data->continue_data; - char *str = cb_data->path; - MKNOD3args args; - - memset(&args, 0, sizeof(args)); - - str = &str[strlen(str) + 1]; - - args.where.dir.data.data_len = data->fh.len; - args.where.dir.data.data_val = data->fh.val; - args.where.name = str; - switch (cb_data->mode & S_IFMT) { - case S_IFCHR: - args.what.type = NF3CHR; - args.what.mknoddata3_u.chr_device.dev_attributes.mode.set_it = 1; - args.what.mknoddata3_u.chr_device.dev_attributes.mode.set_mode3_u.mode = cb_data->mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - args.what.mknoddata3_u.chr_device.spec.specdata1 = cb_data->major; - args.what.mknoddata3_u.chr_device.spec.specdata2 = cb_data->minor; - break; - case S_IFBLK: - args.what.type = NF3BLK; - args.what.mknoddata3_u.blk_device.dev_attributes.mode.set_it = 1; - args.what.mknoddata3_u.blk_device.dev_attributes.mode.set_mode3_u.mode = cb_data->mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - args.what.mknoddata3_u.blk_device.spec.specdata1 = cb_data->major; - args.what.mknoddata3_u.blk_device.spec.specdata2 = cb_data->minor; - break; - case S_IFSOCK: - args.what.type = NF3SOCK; - args.what.mknoddata3_u.sock_attributes.mode.set_it = 1; - args.what.mknoddata3_u.sock_attributes.mode.set_mode3_u.mode = cb_data->mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - break; - case S_IFIFO: - args.what.type = NF3FIFO; - args.what.mknoddata3_u.pipe_attributes.mode.set_it = 1; - args.what.mknoddata3_u.pipe_attributes.mode.set_mode3_u.mode = cb_data->mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); - break; - default: - nfs_set_error(nfs, "Invalid file type for " - "NFS3/MKNOD call"); - data->cb(-EINVAL, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - - if (rpc_nfs3_mknod_async(nfs->rpc, nfs3_mknod_cb, &args, data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_mknod_async(struct nfs_context *nfs, const char *path, int mode, int dev, - nfs_cb cb, void *private_data) -{ - char *ptr; - struct mknod_cb_data *cb_data; - - cb_data = malloc(sizeof(struct mknod_cb_data)); - if (cb_data == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "mode buffer for cb data"); - return -1; - } - - ptr = strrchr(path, '/'); - if (ptr) { - cb_data->path = strdup(path); - if (cb_data->path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for mknod path"); - return -1; - } - ptr = strrchr(cb_data->path, '/'); - *ptr = 0; - } else { - cb_data->path = malloc(strlen(path) + 2); - if (cb_data->path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for mknod path"); - return -1; - } - sprintf(cb_data->path, "%c%s", '\0', path); - } - - cb_data->mode = mode; - cb_data->major = major(dev); - cb_data->minor = minor(dev); - - /* data->path now points to the parent directory and beyond the - * null terminator is the new node to create */ - if (nfs3_lookuppath_async(nfs, cb_data->path, 0, cb, private_data, - nfs3_mknod_continue_internal, - cb_data, free_mknod_cb_data, 0) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_unlink_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - REMOVE3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - char *str = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - str = &str[strlen(str) + 1]; - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: REMOVE of %s/%s failed with " - "%s(%d)", data->saved_path, str, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_unlink_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - char *str = data->continue_data; - struct REMOVE3args args; - - str = &str[strlen(str) + 1]; - - args.object.dir.data.data_len = data->fh.len; - args.object.dir.data.data_val = data->fh.val; - args.object.name = str; - if (rpc_nfs3_remove_async(nfs->rpc, nfs3_unlink_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send REMOVE " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_unlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - char *new_path; - char *ptr; - - ptr = strrchr(path, '/'); - if (ptr) { - new_path = strdup(path); - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for unlink path"); - return -1; - } - ptr = strrchr(new_path, '/'); - *ptr = 0; - } else { - new_path = malloc(strlen(path) + 2); - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for unlink path"); - return -1; - } - sprintf(new_path, "%c%s", '\0', path); - } - - /* new_path now points to the parent directory and beyond the - * null terminator is the object to unlink */ - if (nfs3_lookuppath_async(nfs, new_path, 0, cb, private_data, - nfs3_unlink_continue_internal, - new_path, free, 0) != 0) { - return -1; - } - - return 0; -} - -struct create_cb_data { - char *path; - int flags; - int mode; -}; - -static void -free_create_cb_data(void *ptr) -{ - struct create_cb_data *data = ptr; - - free(data->path); - free(data); -} - -static void -nfs3_create_trunc_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *nfsfh = data->nfsfh; - SETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - nfs_free_nfsfh(nfsfh); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Setattr failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - nfs_free_nfsfh(nfsfh); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, nfsfh, data->private_data); - free_nfs_cb_data(data); -} - -static void -nfs3_create_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - LOOKUP3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *nfsfh; - struct create_cb_data *cb_data = data->continue_data; - char *str = cb_data->path; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - str = &str[strlen(str) + 1]; - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: CREATE of %s/%s failed with " - "%s(%d)", data->saved_path, str, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfsfh = malloc(sizeof(struct nfsfh)); - if (nfsfh == NULL) { - nfs_set_error(nfs, "NFS: Failed to allocate nfsfh structure"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - memset(nfsfh, 0, sizeof(struct nfsfh)); - - if (cb_data->flags & O_SYNC) { - nfsfh->is_sync = 1; - } - if (cb_data->flags & O_APPEND) { - nfsfh->is_append = 1; - } - - /* copy the filehandle */ - nfsfh->fh.len = res->LOOKUP3res_u.resok.object.data.data_len; - nfsfh->fh.val = malloc(nfsfh->fh.len); - if (nfsfh->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory: Failed to allocate " - "fh structure"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - free(nfsfh); - return; - } - memcpy(nfsfh->fh.val, - res->LOOKUP3res_u.resok.object.data.data_val, - nfsfh->fh.len); - - /* Try to truncate it if we were requested to */ - if (cb_data->flags & O_TRUNC) { - SETATTR3args args; - - data->nfsfh = nfsfh; - - memset(&args, 0, sizeof(SETATTR3args)); - args.object.data.data_len = nfsfh->fh.len; - args.object.data.data_val = nfsfh->fh.val; - args.new_attributes.size.set_it = 1; - args.new_attributes.size.set_size3_u.size = 0; - - if (rpc_nfs3_setattr_async(nfs->rpc, nfs3_create_trunc_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "SETATTR call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - nfs_free_nfsfh(nfsfh); - return; - } - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, nfsfh, data->private_data); - free_nfs_cb_data(data); -} - -static void -nfs3_create_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - CREATE3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct create_cb_data *cb_data = data->continue_data; - char *str = cb_data->path; - LOOKUP3args args; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - str = &str[strlen(str) + 1]; - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: CREATE of %s/%s failed with " - "%s(%d)", data->saved_path, str, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - memset(&args, 0, sizeof(LOOKUP3args)); - args.what.dir.data.data_len = data->fh.len; - args.what.dir.data.data_val = data->fh.val; - args.what.name = str; - - if (rpc_nfs3_lookup_async(nfs->rpc, nfs3_create_2_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send lookup " - "call for %s/%s", data->saved_path, str); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - return; -} - -static int -nfs3_create_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct create_cb_data *cb_data = data->continue_data; - char *str = cb_data->path; - CREATE3args args; - - str = &str[strlen(str) + 1]; - - memset(&args, 0, sizeof(CREATE3args)); - args.where.dir.data.data_len = data->fh.len; - args.where.dir.data.data_val = data->fh.val; - args.where.name = str; - args.how.mode = (cb_data->flags & O_EXCL) ? GUARDED : UNCHECKED; - args.how.createhow3_u.obj_attributes.mode.set_it = 1; - args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode = cb_data->mode; - - if (rpc_nfs3_create_async(nfs->rpc, nfs3_create_1_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send CREATE " - "call for %s/%s", data->path, str); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_create_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data) -{ - struct create_cb_data *cb_data; - char *ptr; - - cb_data = malloc(sizeof(struct create_cb_data)); - if (cb_data == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "mode buffer for cb data"); - return -1; - } - - ptr = strrchr(path, '/'); - if (ptr) { - cb_data->path = strdup(path); - if (cb_data->path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for creat path"); - return -1; - } - ptr = strrchr(cb_data->path, '/'); - *ptr = 0; - } else { - cb_data->path = malloc(strlen(path) + 2); - if (cb_data->path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for creat path"); - return -1; - } - sprintf(cb_data->path, "%c%s", '\0', path); - } - - cb_data->flags = flags; - cb_data->mode = mode; - - /* new_path now points to the parent directory and beyond the - * null terminator is the new object to create */ - if (nfs3_lookuppath_async(nfs, cb_data->path, 0, cb, private_data, - nfs3_create_continue_internal, cb_data, - free_create_cb_data, 0) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_rmdir_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - RMDIR3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - char *str = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - str = &str[strlen(str) + 1]; - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: RMDIR of %s/%s failed with " - "%s(%d)", data->saved_path, str, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_rmdir_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - char *str = data->continue_data; - RMDIR3args args; - - str = &str[strlen(str) + 1]; - - args.object.dir.data.data_len = data->fh.len; - args.object.dir.data.data_val = data->fh.val; - args.object.name = str; - if (rpc_nfs3_rmdir_async(nfs->rpc, nfs3_rmdir_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send RMDIR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_rmdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - char *new_path; - char *ptr; - - ptr = strrchr(path, '/'); - if (ptr) { - new_path = strdup(path); - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for rmdir path"); - return -1; - } - ptr = strrchr(new_path, '/'); - *ptr = 0; - } else { - new_path = malloc(strlen(path) + 2); - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for rmdir path"); - return -1; - } - sprintf(new_path, "%c%s", '\0', path); - } - - /* new_path now points to the parent directory and beyond the - * null terminator is the directory to remove */ - if (nfs3_lookuppath_async(nfs, new_path, 0, cb, private_data, - nfs3_rmdir_continue_internal, - new_path, free, 0) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_mkdir_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - MKDIR3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - char *str = data->continue_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - str = &str[strlen(str) + 1]; - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: MKDIR of %s/%s failed " - "with %s(%d)", data->saved_path, str, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_mkdir_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - char *str = data->continue_data; - int mode = (int)data->continue_int; - MKDIR3args args; - - str = &str[strlen(str) + 1]; - - memset(&args, 0, sizeof(MKDIR3args)); - args.where.dir.data.data_len = data->fh.len; - args.where.dir.data.data_val = data->fh.val; - args.where.name = str; - args.attributes.mode.set_it = 1; - args.attributes.mode.set_mode3_u.mode = mode; - - if (rpc_nfs3_mkdir_async(nfs->rpc, nfs3_mkdir_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send MKDIR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_mkdir2_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - char *new_path; - char *ptr; - - ptr = strrchr(path, '/'); - if (ptr) { - new_path = strdup(path); - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for mkdir path"); - return -1; - } - ptr = strrchr(new_path, '/'); - *ptr = 0; - } else { - new_path = malloc(strlen(path) + 2); - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory, failed to allocate " - "buffer for mkdir path"); - return -1; - } - sprintf(new_path, "%c%s", '\0', path); - } - - /* new_path now points to the parent directory and beyond the - * null terminator is the new directory to create */ - if (nfs3_lookuppath_async(nfs, new_path, 0, cb, private_data, - nfs3_mkdir_continue_internal, - new_path, free, mode) != 0) { - return -1; - } - - return 0; -} - -static int -nfs3_truncate_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - uint64_t offset = data->continue_int; - struct nfsfh nfsfh; - - memset(&nfsfh, 0, sizeof(struct nfsfh)); - nfsfh.fh = data->fh; - - if (nfs_ftruncate_async(nfs, &nfsfh, offset, data->cb, - data->private_data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send SETATTR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - free_nfs_cb_data(data); - return 0; -} - -int -nfs3_truncate_async(struct nfs_context *nfs, const char *path, uint64_t length, - nfs_cb cb, void *private_data) -{ - uint64_t offset; - - offset = length; - - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_truncate_continue_internal, - NULL, NULL, offset) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_ftruncate_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - SETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Setattr failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfs_dircache_drop(nfs, &data->fh); - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -int -nfs3_ftruncate_async(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t length, nfs_cb cb, void *private_data) -{ - struct nfs_cb_data *data; - SETATTR3args args; - - nfs_pagecache_invalidate(nfs, nfsfh); - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - memset(&args, 0, sizeof(SETATTR3args)); - args.object.data.data_len = nfsfh->fh.len; - args.object.data.data_val = nfsfh->fh.val; - args.new_attributes.size.set_it = 1; - args.new_attributes.size.set_size3_u.size = length; - - if (rpc_nfs3_setattr_async(nfs->rpc, nfs3_ftruncate_cb, - &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send SETATTR " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static void -nfs3_fsync_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMMIT3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Commit failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); -} - -int -nfs3_fsync_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - struct nfs_cb_data *data; - struct COMMIT3args args; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - args.file.data.data_len = nfsfh->fh.len; - args.file.data.data_val = nfsfh->fh.val; - args.offset = 0; - args.count = 0; - if (rpc_nfs3_commit_async(nfs->rpc, nfs3_fsync_cb, &args, data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send COMMIT " - "call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static void -nfs3_stat_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - GETATTR3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; -#ifdef WIN32 - struct __stat64 st; -#else - struct stat st; -#endif - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: GETATTR of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - st.st_dev = (dev_t)res->GETATTR3res_u.resok.obj_attributes.fsid; - st.st_ino = (ino_t)res->GETATTR3res_u.resok.obj_attributes.fileid; - st.st_mode = res->GETATTR3res_u.resok.obj_attributes.mode; - switch (res->GETATTR3res_u.resok.obj_attributes.type) { - case NF3REG: - st.st_mode |= S_IFREG; - break; - case NF3DIR: - st.st_mode |= S_IFDIR; - break; - case NF3BLK: - st.st_mode |= S_IFBLK; - break; - case NF3CHR: - st.st_mode |= S_IFCHR; - break; - case NF3LNK: - st.st_mode |= S_IFLNK; - break; - case NF3SOCK: - st.st_mode |= S_IFSOCK; - break; - case NF3FIFO: - st.st_mode |= S_IFIFO; - break; - } - st.st_nlink = res->GETATTR3res_u.resok.obj_attributes.nlink; - st.st_uid = res->GETATTR3res_u.resok.obj_attributes.uid; - st.st_gid = res->GETATTR3res_u.resok.obj_attributes.gid; - st.st_rdev = specdata3_to_rdev(&res->GETATTR3res_u.resok.obj_attributes.rdev); - st.st_size = res->GETATTR3res_u.resok.obj_attributes.size; -#ifndef WIN32 - st.st_blksize = NFS_BLKSIZE; - st.st_blocks = (res->GETATTR3res_u.resok.obj_attributes.used + 512 - 1) / 512; -#endif//WIN32 - st.st_atime = res->GETATTR3res_u.resok.obj_attributes.atime.seconds; - st.st_mtime = res->GETATTR3res_u.resok.obj_attributes.mtime.seconds; - st.st_ctime = res->GETATTR3res_u.resok.obj_attributes.ctime.seconds; -#ifdef HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC - st.st_atim.tv_nsec = res->GETATTR3res_u.resok.obj_attributes.atime.nseconds; - st.st_mtim.tv_nsec = res->GETATTR3res_u.resok.obj_attributes.mtime.nseconds; - st.st_ctim.tv_nsec = res->GETATTR3res_u.resok.obj_attributes.ctime.nseconds; -#endif - - data->cb(0, nfs, &st, data->private_data); - free_nfs_cb_data(data); -} - -int -nfs3_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - struct nfs_cb_data *data; - struct GETATTR3args args; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = nfsfh->fh.len; - args.object.data.data_val = nfsfh->fh.val; - - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_stat_1_cb, &args, - data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static void -nfs3_stat64_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - GETATTR3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfs_stat_64 st; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: GETATTR of %s failed with " - "%s(%d)", data->saved_path, - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - st.nfs_dev = res->GETATTR3res_u.resok.obj_attributes.fsid; - st.nfs_ino = res->GETATTR3res_u.resok.obj_attributes.fileid; - st.nfs_mode = res->GETATTR3res_u.resok.obj_attributes.mode; - switch (res->GETATTR3res_u.resok.obj_attributes.type) { - case NF3REG: - st.nfs_mode |= S_IFREG; - break; - case NF3DIR: - st.nfs_mode |= S_IFDIR; - break; - case NF3BLK: - st.nfs_mode |= S_IFBLK; - break; - case NF3CHR: - st.nfs_mode |= S_IFCHR; - break; - case NF3LNK: - st.nfs_mode |= S_IFLNK; - break; - case NF3SOCK: - st.nfs_mode |= S_IFSOCK; - break; - case NF3FIFO: - st.nfs_mode |= S_IFIFO; - break; - } - st.nfs_nlink = res->GETATTR3res_u.resok.obj_attributes.nlink; - st.nfs_uid = res->GETATTR3res_u.resok.obj_attributes.uid; - st.nfs_gid = res->GETATTR3res_u.resok.obj_attributes.gid; - st.nfs_rdev = specdata3_to_rdev(&res->GETATTR3res_u.resok.obj_attributes.rdev); - st.nfs_size = res->GETATTR3res_u.resok.obj_attributes.size; - st.nfs_blksize = NFS_BLKSIZE; - st.nfs_blocks = (res->GETATTR3res_u.resok.obj_attributes.used + 512 - 1) / 512; - st.nfs_atime = res->GETATTR3res_u.resok.obj_attributes.atime.seconds; - st.nfs_mtime = res->GETATTR3res_u.resok.obj_attributes.mtime.seconds; - st.nfs_ctime = res->GETATTR3res_u.resok.obj_attributes.ctime.seconds; - st.nfs_atime_nsec = res->GETATTR3res_u.resok.obj_attributes.atime.nseconds; - st.nfs_mtime_nsec = res->GETATTR3res_u.resok.obj_attributes.mtime.nseconds; - st.nfs_ctime_nsec = res->GETATTR3res_u.resok.obj_attributes.ctime.nseconds; - st.nfs_used = res->GETATTR3res_u.resok.obj_attributes.used; - - data->cb(0, nfs, &st, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_stat64_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct GETATTR3args args; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_stat64_1_cb, - &args, data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_stat64_async(struct nfs_context *nfs, const char *path, - int no_follow, nfs_cb cb, void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, no_follow, cb, private_data, - nfs3_stat64_continue_internal, - NULL, NULL, 0) != 0) { - return -1; - } - - return 0; -} - -int -nfs3_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - struct nfs_cb_data *data; - struct GETATTR3args args; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = nfsfh->fh.len; - args.object.data.data_val = nfsfh->fh.val; - - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_stat64_1_cb, &args, - data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -static int -nfs3_stat_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - struct GETATTR3args args; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_stat_1_cb, &args, - data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -int -nfs3_stat_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_stat_continue_internal, - NULL, NULL, 0) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_close_cb(int err, struct nfs_context *nfs, void *ret_data, - void *private_data) { - struct nfs_cb_data *data = private_data; - nfs_free_nfsfh(data->nfsfh); - data->cb(err, nfs, ret_data, data->private_data); - free_nfs_cb_data(data); -} - -int -nfs3_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - struct nfs_cb_data *data; - - if (!nfsfh->is_dirty) { - nfs_free_nfsfh(nfsfh); - cb(0, nfs, NULL, private_data); - return 0; - } - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - - data->nfsfh = nfsfh; - data->cb = cb; - data->private_data = private_data; - - return nfs_fsync_async(nfs, nfsfh, nfs3_close_cb, data); -} - -static void -nfs3_write_append_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - GETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: GETATTR failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - if (nfs3_pwrite_async_internal(nfs, data->nfsfh, res->GETATTR3res_u.resok.obj_attributes.size, data->count, data->usrbuf, data->cb, data->private_data, 1) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - free_nfs_cb_data(data); -} - -static void -nfs3_fill_WRITE3args (WRITE3args *args, struct nfsfh *fh, uint64_t offset, - uint64_t count, const void *buf) -{ - memset(args, 0, sizeof(WRITE3args)); - args->file.data.data_len = fh->fh.len; - args->file.data.data_val = fh->fh.val; - args->offset = offset; - args->count = (count3)count; - args->stable = fh->is_sync ? FILE_SYNC : UNSTABLE; - args->data.data_len = (count3)count; - args->data.data_val = (char *)buf; -} - -static void -nfs3_pwrite_mcb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_mcb_data *mdata = private_data; - struct nfs_cb_data *data = mdata->data; - struct nfs_context *nfs = data->nfs; - WRITE3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - data->num_calls--; - - /* Flag the failure but do not invoke callback until we have - * received all responses. - */ - if (status == RPC_STATUS_ERROR) { - data->error = 1; - } - if (status == RPC_STATUS_CANCEL) { - data->cancel = 1; - } - if (status == RPC_STATUS_TIMEOUT) { - data->cancel = 1; - } - - if (status == RPC_STATUS_SUCCESS) { - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Write failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status)); - data->error = 1; - } else { - size_t count = res->WRITE3res_u.resok.count; - - if (count < mdata->count) { - if (count == 0) { - nfs_set_error(nfs, "NFS: Write failed. No bytes written!"); - data->error = 1; - } else { - /* reissue reminder of this write request */ - WRITE3args args; - mdata->offset += count; - mdata->count -= count; - - nfs3_fill_WRITE3args(&args, - data->nfsfh, - mdata->offset, - mdata->count, - &data->usrbuf[mdata->offset - data->offset]); - if (rpc_nfs3_write_async(nfs->rpc, - nfs3_pwrite_mcb, - &args, mdata) == 0) { - data->num_calls++; - return; - } else { - nfs_set_error(nfs, "RPC error: Failed to send WRITE call for %s", data->path); - data->oom = 1; - } - } - } - if (count > 0) { - if (data->max_offset < mdata->offset + count) { - data->max_offset = mdata->offset + count; - } - } - } - } - - free(mdata); - - if (data->num_calls > 0) { - /* still waiting for more replies */ - return; - } - if (data->oom != 0) { - data->cb(-ENOMEM, nfs, command_data, data->private_data); - free_nfs_cb_data(data); - return; - } - if (data->error != 0) { - data->cb(-EFAULT, nfs, command_data, data->private_data); - free_nfs_cb_data(data); - return; - } - if (data->cancel != 0) { - data->cb(-EINTR, nfs, "Command was cancelled", data->private_data); - free_nfs_cb_data(data); - return; - } - - - if (data->update_pos) { - data->nfsfh->offset = data->max_offset; - } - - nfs_pagecache_put(&data->nfsfh->pagecache, data->offset, data->usrbuf, data->count); - data->cb((int)(data->max_offset - data->offset), nfs, NULL, data->private_data); - - free_nfs_cb_data(data); -} - -int -nfs3_pwrite_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, const char *buf, - nfs_cb cb, void *private_data, int update_pos) -{ - struct nfs_cb_data *data; - - nfsfh->is_dirty = 1; - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - data->nfsfh = nfsfh; - data->usrbuf = buf; - data->update_pos = update_pos; - - /* hello, clang-analyzer */ - assert(data->num_calls == 0); - - /* chop requests into chunks of at most WRITEMAX bytes if necessary. - * we send all writes in parallel so that performance is still good. - */ - data->max_offset = offset; - data->offset = offset; - data->count = count; - - do { - size_t writecount = count; - struct nfs_mcb_data *mdata; - WRITE3args args; - - if (writecount > nfs_get_writemax(nfs)) { - writecount = (size_t)nfs_get_writemax(nfs); - } - - mdata = malloc(sizeof(struct nfs_mcb_data)); - if (mdata == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_mcb_data structure"); - if (data->num_calls == 0) { - free_nfs_cb_data(data); - return -1; - } - data->oom = 1; - break; - } - memset(mdata, 0, sizeof(struct nfs_mcb_data)); - mdata->data = data; - mdata->offset = offset; - mdata->count = writecount; - - nfs3_fill_WRITE3args(&args, nfsfh, offset, writecount, - &buf[offset - data->offset]); - - if (rpc_nfs3_write_async(nfs->rpc, nfs3_pwrite_mcb, - &args, mdata) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send WRITE " - "call for %s", data->path); - free(mdata); - if (data->num_calls == 0) { - free_nfs_cb_data(data); - return -1; - } - data->oom = 1; - break; - } - - count -= writecount; - offset += writecount; - data->num_calls++; - } while (count > 0); - - return 0; -} - -int -nfs3_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, - const void *buf, nfs_cb cb, void *private_data) -{ - if (nfsfh->is_append) { - struct GETATTR3args args; - struct nfs_cb_data *data; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - data->nfsfh = nfsfh; - data->usrbuf = buf; - data->count = (size_t)count; - - memset(&args, 0, sizeof(GETATTR3args)); - args.object.data.data_len = nfsfh->fh.len; - args.object.data.data_val = nfsfh->fh.val; - - if (rpc_nfs3_getattr_async(nfs->rpc, nfs3_write_append_cb, - &args, data) != 0) { - free_nfs_cb_data(data); - return -1; - } - return 0; - } - return nfs3_pwrite_async_internal(nfs, nfsfh, nfsfh->offset, - (size_t)count, buf, - cb, private_data, 1); -} - -static void -nfs3_fill_READ3args(READ3args *args, struct nfsfh *fh, uint64_t offset, - uint64_t count) -{ - memset(args, 0, sizeof(READ3args)); - args->file.data.data_len = fh->fh.len; - args->file.data.data_val = fh->fh.val; - args->offset = offset; - args->count = (count3)count; -} - -static void -nfs3_pread_mcb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_mcb_data *mdata = private_data; - struct nfs_cb_data *data = mdata->data; - struct nfs_context *nfs = data->nfs; - READ3res *res; - int cb_err; - void *cb_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - data->num_calls--; - - /* Flag the failure but do not invoke callback until we have - * received all responses. - */ - if (status == RPC_STATUS_ERROR) { - data->error = 1; - } - if (status == RPC_STATUS_CANCEL) { - data->cancel = 1; - } - if (status == RPC_STATUS_TIMEOUT) { - data->cancel = 1; - } - - if (status == RPC_STATUS_SUCCESS) { - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Read failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->error = 1; - } else { - size_t count = res->READ3res_u.resok.count; - if (count < data->count && data->buffer == NULL) { - /* we need a reassembly buffer after all */ - data->buffer = malloc(mdata->count); - if (data->buffer == NULL) { - data->oom = 1; - goto out; - } - } - if (count > 0) { - if (count == data->count && data->buffer == NULL) { - data->buffer = res->READ3res_u.resok.data.data_val; - data->not_my_buffer = 1; - } else if (count <= mdata->count) { - /* copy data into reassembly buffer */ - memcpy(&data->buffer[mdata->offset - data->offset], res->READ3res_u.resok.data.data_val, count); - } else { - nfs_set_error(nfs, "NFS: Read overflow. Server has sent more data than requested!"); - data->error = 1; - goto out; - } - if (data->max_offset < mdata->offset + count) { - data->max_offset = mdata->offset + count; - } - } - /* check if we have received a short read */ - if (count < mdata->count && !res->READ3res_u.resok.eof) { - if (count == 0) { - nfs_set_error(nfs, "NFS: Read failed. No bytes read and not at EOF!"); - data->error = 1; - } else { - /* reissue reminder of this read request */ - READ3args args; - mdata->offset += count; - mdata->count -= count; - nfs3_fill_READ3args(&args, data->nfsfh, - mdata->offset, - mdata->count); - if (rpc_nfs3_read_async(nfs->rpc, - nfs3_pread_mcb, - &args, mdata) - == 0) { - data->num_calls++; - return; - } else { - nfs_set_error(nfs, "RPC error: Failed to send READ call for %s", data->path); - data->oom = 1; - } - } - } - } - } - -out: - free(mdata); - - if (data->num_calls > 0) { - /* still waiting for more replies */ - return; - } - if (data->oom != 0) { - data->cb(-ENOMEM, nfs, command_data, data->private_data); - free_nfs_cb_data(data); - return; - } - if (data->error != 0) { - data->cb(-EFAULT, nfs, command_data, data->private_data); - free_nfs_cb_data(data); - return; - } - if (data->cancel != 0) { - data->cb(-EINTR, nfs, "Command was cancelled", - data->private_data); - free_nfs_cb_data(data); - return; - } - - data->nfsfh->ra.fh_offset = data->max_offset; - - nfs_pagecache_put(&data->nfsfh->pagecache, data->offset, data->buffer, - (size_t)(data->max_offset - data->offset)); - - if (data->max_offset > data->org_offset + data->org_count) { - data->max_offset = data->org_offset + data->org_count; - } - if (data->update_pos) { - data->nfsfh->offset = data->max_offset; - } - - cb_err = (int)(data->max_offset - data->org_offset); - cb_data = data->buffer + (data->org_offset - data->offset); - data->cb(cb_err, nfs, cb_data, data->private_data); - free_nfs_cb_data(data); - return; -} - -int -nfs3_pread_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, nfs_cb cb, - void *private_data, int update_pos) -{ - struct nfs_cb_data *data; - - data = malloc(sizeof(struct nfs_cb_data)); - if (data == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate " - "nfs_cb_data structure"); - debugNetPrintf(3,"[LIBNFS] %s 1 \n",__FUNCTION__); - return -1; - } - memset(data, 0, sizeof(struct nfs_cb_data)); - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - data->nfsfh = nfsfh; - data->org_offset = offset; - data->org_count = (count3)count; - data->update_pos = update_pos; - - assert(data->num_calls == 0); - - if (nfsfh->pagecache.num_entries) { - /* align start offset to blocksize */ - count += offset & (NFS_BLKSIZE - 1); - offset &= ~(NFS_BLKSIZE - 1); - - /* align end offset to blocksize */ - count += NFS_BLKSIZE - 1 ; - count &= ~(NFS_BLKSIZE - 1); - } - - data->offset = offset; - data->count = (count3)count; - - if (nfsfh->pagecache.num_entries) { - while (count > 0) { - char *cdata = nfs_pagecache_get(&nfsfh->pagecache, - offset); - if (!cdata) { - break; - } - /* we copy data from the pagecache so we need a - * reassembly buffer */ - if (data->buffer == NULL) { - data->buffer = malloc(data->count); - if (data->buffer == NULL) { - free_nfs_cb_data(data); - return -ENOMEM; - } - } - memcpy(data->buffer + offset - data->offset, cdata, - NFS_BLKSIZE); - offset += NFS_BLKSIZE; - count -= NFS_BLKSIZE; - } - if (!count) { - data->nfsfh->ra.fh_offset = data->offset + data->count; - if (update_pos) { - data->nfsfh->offset = data->org_offset + data->org_count; - } - data->cb(data->org_count, nfs, data->buffer + (data->org_offset - data->offset), data->private_data); - free_nfs_cb_data(data); - return 0; - } - } - - if (nfs->rpc->readahead) { - nfsfh->ra.cur_ra = MAX(NFS_BLKSIZE, nfsfh->ra.cur_ra); - if (offset >= nfsfh->ra.fh_offset && - offset <= nfsfh->ra.fh_offset + nfsfh->ra.cur_ra + NFS_BLKSIZE) { - if (nfs->rpc->readahead > nfsfh->ra.cur_ra) { - nfsfh->ra.cur_ra <<= 1; - } - } else { - nfsfh->ra.cur_ra = 0; - } - count += nfsfh->ra.cur_ra; - data->count += nfsfh->ra.cur_ra; - } - - if ((data->count > nfs_get_readmax(nfs) || data->count > data->org_count) && - (data->buffer == NULL || nfsfh->ra.cur_ra > 0)) { - /* we do readahead, a big read or aligned out the request so we - * need a (bigger) reassembly buffer */ - data->buffer = realloc(data->buffer, data->count + nfsfh->ra.cur_ra); - if (data->buffer == NULL) { - free_nfs_cb_data(data); - return -ENOMEM; - } - } - - data->max_offset = data->offset; - - /* chop requests into chunks of at most READMAX bytes if necessary. - * we send all reads in parallel so that performance is still good. - */ - do { - size_t readcount = count; - struct nfs_mcb_data *mdata; - READ3args args; - - if (readcount > nfs_get_readmax(nfs)) { - readcount = (size_t)nfs_get_readmax(nfs); - } - - mdata = malloc(sizeof(struct nfs_mcb_data)); - if (mdata == NULL) { - nfs_set_error(nfs, "out of memory: failed to allocate nfs_mcb_data structure"); - if (data->num_calls == 0) { - free_nfs_cb_data(data); - debugNetPrintf(3,"[LIBNFS] %s 2 \n",__FUNCTION__); - - return -1; - } - data->oom = 1; - break; - } - memset(mdata, 0, sizeof(struct nfs_mcb_data)); - mdata->data = data; - mdata->offset = offset; - mdata->count = readcount; - - nfs3_fill_READ3args(&args, nfsfh, offset, readcount); - - if (rpc_nfs3_read_async(nfs->rpc, nfs3_pread_mcb, - &args, mdata) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send READ " - "call for %s", data->path); - free(mdata); - if (data->num_calls == 0) { - free_nfs_cb_data(data); - debugNetPrintf(3,"[LIBNFS] %s 3 \n",__FUNCTION__); - - return -1; - } - data->oom = 1; - break; - } - - count -= readcount; - offset += readcount; - data->num_calls++; - } while (count > 0); - - return 0; -} - -static int -nfs3_chdir_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - /* steal saved_path */ - free(nfs->cwd); - nfs->cwd = data->saved_path; - data->saved_path = NULL; - - data->cb(0, nfs, NULL, data->private_data); - free_nfs_cb_data(data); - - return 0; -} - -int -nfs3_chdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_chdir_continue_internal, - NULL, NULL, 0) != 0) { - return -1; - } - - return 0; -} - -static void -nfs3_open_trunc_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *nfsfh; - SETATTR3res *res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: Setattr failed with %s(%d)", - nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - nfsfh = malloc(sizeof(struct nfsfh)); - if (nfsfh == NULL) { - nfs_set_error(nfs, "NFS: Failed to allocate nfsfh " - "structure"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - memset(nfsfh, 0, sizeof(struct nfsfh)); - - if (data->continue_int & O_SYNC) { - nfsfh->is_sync = 1; - } - if (data->continue_int & O_APPEND) { - nfsfh->is_append = 1; - } - - /* steal the filehandle */ - nfsfh->fh = data->fh; - data->fh.val = NULL; - - data->cb(0, nfs, nfsfh, data->private_data); - free_nfs_cb_data(data); -} - -static void -nfs3_open_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - ACCESS3res *res; - struct nfs_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *nfsfh; - unsigned int nfsmode = 0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs3_error(nfs, status, data, command_data)) { - free_nfs_cb_data(data); - return; - } - - res = command_data; - if (res->status != NFS3_OK) { - nfs_set_error(nfs, "NFS: ACCESS of %s failed with %s(%d)", - data->saved_path, nfsstat3_to_str(res->status), - nfsstat3_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - if (data->continue_int & O_WRONLY) { - nfsmode |= ACCESS3_MODIFY; - } - if (data->continue_int & O_RDWR) { - nfsmode |= ACCESS3_READ|ACCESS3_MODIFY; - } - if (!(data->continue_int & (O_WRONLY|O_RDWR))) { - nfsmode |= ACCESS3_READ; - } - - - if (res->ACCESS3res_u.resok.access != nfsmode) { - nfs_set_error(nfs, "NFS: ACCESS denied. Required " - "access %c%c%c. Allowed access %c%c%c", - nfsmode&ACCESS3_READ?'r':'-', - nfsmode&ACCESS3_MODIFY?'w':'-', - nfsmode&ACCESS3_EXECUTE?'x':'-', - res->ACCESS3res_u.resok.access&ACCESS3_READ ? 'r':'-', - res->ACCESS3res_u.resok.access&ACCESS3_MODIFY ?'w':'-', - res->ACCESS3res_u.resok.access&ACCESS3_EXECUTE ?'x':'-'); - data->cb(-EACCES, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - - /* Try to truncate it if we were requested to */ - if ((data->continue_int & O_TRUNC) && - (data->continue_int & (O_RDWR|O_WRONLY))) { - SETATTR3args args; - - memset(&args, 0, sizeof(SETATTR3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - args.new_attributes.size.set_it = 1; - args.new_attributes.size.set_size3_u.size = 0; - - if (rpc_nfs3_setattr_async(nfs->rpc, nfs3_open_trunc_cb, &args, - data) != 0) { - nfs_set_error(nfs, "RPC error: Failed to send " - "SETATTR call for %s", data->path); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return; - } - return; - } - - nfsfh = malloc(sizeof(struct nfsfh)); - if (nfsfh == NULL) { - nfs_set_error(nfs, "NFS: Failed to allocate nfsfh structure"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs_cb_data(data); - return; - } - memset(nfsfh, 0, sizeof(struct nfsfh)); - - if (data->continue_int & O_SYNC) { - nfsfh->is_sync = 1; - } - if (data->continue_int & O_APPEND) { - nfsfh->is_append = 1; - } - - /* init the pagecache */ - nfs_pagecache_init(nfs, nfsfh); - - /* steal the filehandle */ - nfsfh->fh = data->fh; - data->fh.val = NULL; - - data->cb(0, nfs, nfsfh, data->private_data); - free_nfs_cb_data(data); -} - -static int -nfs3_open_continue_internal(struct nfs_context *nfs, - struct nfs_attr *attr _U_, - struct nfs_cb_data *data) -{ - int nfsmode = 0; - ACCESS3args args; - - if (data->continue_int & O_WRONLY) { - nfsmode |= ACCESS3_MODIFY; - } - if (data->continue_int & O_RDWR) { - nfsmode |= ACCESS3_READ|ACCESS3_MODIFY; - } - if (!(data->continue_int & (O_WRONLY|O_RDWR))) { - nfsmode |= ACCESS3_READ; - } - - memset(&args, 0, sizeof(ACCESS3args)); - args.object.data.data_len = data->fh.len; - args.object.data.data_val = data->fh.val; - args.access = nfsmode; - - if (rpc_nfs3_access_async(nfs->rpc, nfs3_open_cb, &args, data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs_cb_data(data); - return -1; - } - return 0; -} - -/* TODO add the plumbing for mode */ -int -nfs3_open_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data) -{ - if (flags & O_CREAT) { - return nfs3_create_async(nfs, path, flags, mode, - cb, private_data); - } - - if (nfs3_lookuppath_async(nfs, path, 0, cb, private_data, - nfs3_open_continue_internal, - NULL, NULL, flags) != 0) { - return -1; - } - - return 0; -} diff --git a/source/liborbisNfs/nfs_v4.c b/source/liborbisNfs/nfs_v4.c deleted file mode 100644 index 200cfad..0000000 --- a/source/liborbisNfs/nfs_v4.c +++ /dev/null @@ -1,5079 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2017 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -/* - * High level api to nfsv4 filesystems - */ -#ifndef _GNU_SOURCE -#define _GNU_SOURCE -#endif - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef HAVE_INTTYPES_H -#include -#else -#define PRIu64 "llu" -#endif - -#ifdef HAVE_UTIME_H -#include -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#ifdef HAVE_SYS_VFS_H -#include -#endif - -#ifdef HAVE_SYS_STATVFS_H -#include -#endif - -#if defined(__ANDROID__) && !defined(HAVE_SYS_STATVFS_H) -#define statvfs statfs -#endif - -#ifdef HAVE_NETINET_IN_H -#include -#endif - -#ifdef HAVE_STRINGS_H -#include -#endif - -#ifdef MAJOR_IN_MKDEV -#include -#endif - -#ifdef HAVE_SYS_SYSMACROS_H -#include -#endif - -#ifdef HAVE_GETPWNAM -#include -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "libnfs-zdr.h" -#include "slist.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" - -#ifndef discard_const -#define discard_const(ptr) ((void *)((intptr_t)(ptr))) -#endif - -struct nfs4_cb_data; -typedef int (*op_filler)(struct nfs4_cb_data *data, nfs_argop4 *op); - -struct lookup_link_data { - unsigned int idx; -}; - -typedef void (*blob_free)(void *); - -struct nfs4_blob { - int len; - void *val; - blob_free free; -}; - -/* Function and arguments to append the requested operations we want - * for the resolved path. - */ -struct lookup_filler { - op_filler func; - int max_op; - int flags; - void *data; /* Freed by nfs4_cb_data destructor */ - - struct nfs4_blob blob0; - struct nfs4_blob blob1; - struct nfs4_blob blob2; - struct nfs4_blob blob3; -}; - -struct rw_data { - uint64_t offset; - int update_pos; -}; - -struct nfs4_cb_data { - struct nfs_context *nfs; -/* Do not follow symlinks for the final component on a lookup. - * I.e. stat vs lstat - */ -#define LOOKUP_FLAG_NO_FOLLOW 0x0001 -#define LOOKUP_FLAG_IS_STATVFS64 0x0002 - int flags; - - /* Internal callback for open-with-continuation use */ - rpc_cb open_cb; - - /* Application callback and data */ - nfs_cb cb; - void *private_data; - - /* internal callback */ - rpc_cb continue_cb; - - char *path; /* path to lookup */ - struct lookup_filler filler; - - /* Data we need when resolving a symlink in the path */ - struct lookup_link_data link; - - /* Data we need for updating offset in read/write */ - struct rw_data rw_data; -}; - -static uint32_t standard_attributes[2] = { - (1 << FATTR4_TYPE | - 1 << FATTR4_SIZE | - 1 << FATTR4_FILEID), - (1 << (FATTR4_MODE - 32) | - 1 << (FATTR4_NUMLINKS - 32) | - 1 << (FATTR4_OWNER - 32) | - 1 << (FATTR4_OWNER_GROUP - 32) | - 1 << (FATTR4_SPACE_USED - 32) | - 1 << (FATTR4_TIME_ACCESS - 32) | - 1 << (FATTR4_TIME_METADATA - 32) | - 1 << (FATTR4_TIME_MODIFY - 32)) -}; -static uint32_t statvfs_attributes[2] = { - (1 << FATTR4_FSID | - 1 << FATTR4_FILES_AVAIL | - 1 << FATTR4_FILES_FREE | - 1 << FATTR4_FILES_TOTAL | - 1 << FATTR4_MAXNAME), - (1 << (FATTR4_SPACE_AVAIL - 32) | - 1 << (FATTR4_SPACE_FREE - 32) | - 1 << (FATTR4_SPACE_TOTAL - 32)) -}; - -static int -nfs4_open_async_internal(struct nfs_context *nfs, struct nfs4_cb_data *data, - int flags, int mode); - -/* Caller will free the returned path. */ -static char * -nfs4_resolve_path(struct nfs_context *nfs, const char *path) -{ - char *new_path = NULL; - - /* Absolute paths we just use as is. - * Relateive paths have cwd prepended to them and then become - * absolute paths too. - */ - if (path[0] == '/') { - new_path = strdup(path); - } else { - new_path = malloc(strlen(path) + strlen(nfs->cwd) + 2); - if (new_path != NULL) { - sprintf(new_path, "%s/%s", nfs->cwd, path); - } - } - if (new_path == NULL) { - nfs_set_error(nfs, "Out of memory: failed to " - "allocate path string"); - return NULL; - } - - if (nfs_normalize_path(nfs, new_path)) { - nfs_set_error(nfs, "Failed to normalize real path. %s", - nfs_get_error(nfs)); - free(new_path); - return NULL; - } - - return new_path; -} - -static void -free_nfs4_cb_data(struct nfs4_cb_data *data) -{ - free(data->path); - free(data->filler.data); - if (data->filler.blob0.val && data->filler.blob0.free) { - data->filler.blob0.free(data->filler.blob0.val); - } - if (data->filler.blob1.val && data->filler.blob1.free) { - data->filler.blob1.free(data->filler.blob1.val); - } - if (data->filler.blob2.val && data->filler.blob2.free) { - data->filler.blob2.free(data->filler.blob2.val); - } - if (data->filler.blob3.val && data->filler.blob3.free) { - data->filler.blob3.free(data->filler.blob3.val); - } - free(data); -} - -static struct nfs4_cb_data * -init_cb_data_full_path(struct nfs_context *nfs, const char *path) -{ - struct nfs4_cb_data *data; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "cb data"); - return NULL; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->path = nfs4_resolve_path(nfs, path); - if (data->path == NULL) { - free_nfs4_cb_data(data); - return NULL; - } - - return data; -} - -static void -data_split_path(struct nfs4_cb_data *data) -{ - char *path; - path = strrchr(data->path, '/'); - if (path == data->path) { - char *ptr; - - for (ptr = data->path; *ptr; ptr++) { - *ptr = *(ptr + 1); - } - /* No path to lookup */ - data->filler.data = data->path; - data->path = strdup("/"); - } else { - *path++ = 0; - data->filler.data = strdup(path); - } -} - -static struct nfs4_cb_data * -init_cb_data_split_path(struct nfs_context *nfs, const char *orig_path) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_full_path(nfs, orig_path); - if (data == NULL) { - return NULL; - } - - data_split_path(data); - return data; -} - -static int -check_nfs4_error(struct nfs_context *nfs, int status, - struct nfs4_cb_data *data, void *command_data, - char *op_name) -{ - COMPOUND4res *res = command_data; - - if (status == RPC_STATUS_ERROR) { - data->cb(-EFAULT, nfs, res, data->private_data); - free_nfs4_cb_data(data); - return 1; - } - if (status == RPC_STATUS_CANCEL) { - data->cb(-EINTR, nfs, "Command was cancelled", - data->private_data); - free_nfs4_cb_data(data); - return 1; - } - if (status == RPC_STATUS_TIMEOUT) { - data->cb(-EINTR, nfs, "Command timed out", - data->private_data); - free_nfs4_cb_data(data); - return 1; - } - if (res && res->status != NFS4_OK) { - nfs_set_error(nfs, "NFS4: %s (path %s) failed with " - "%s(%d)", op_name, - data->path, - nfsstat4_to_str(res->status), - nfsstat4_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return 1; - } - - return 0; -} - -static int -nfs4_find_op(struct nfs_context *nfs, struct nfs4_cb_data *data, - COMPOUND4res *res, int op, const char *op_name) -{ - int i; - - for (i = 0; i < (int)res->resarray.resarray_len; i++) { - if (res->resarray.resarray_val[i].resop == op) { - break; - } - } - if (i == res->resarray.resarray_len) { - nfs_set_error(nfs, "No %s result.", op_name); - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return -1; - } - - return i; -} - -static uint64_t -nfs_hton64(uint64_t val) -{ - int i; - uint64_t res; - unsigned char *ptr = (void *)&res; - - for (i = 0; i < 8; i++) { - ptr[7 - i] = val & 0xff; - val >>= 8; - } - return res; -} - -static uint64_t -nfs_ntoh64(uint64_t val) -{ - int i; - uint64_t res; - unsigned char *ptr = (void *)&res; - - for (i = 0; i < 8; i++) { - ptr[7 - i] = val & 0xff; - val >>= 8; - } - return res; -} - -static uint64_t -nfs_pntoh64(const uint32_t *buf) -{ - uint64_t val; - - val = ntohl(*(uint32_t *)(void *)buf++); - val <<= 32; - val |= ntohl(*(uint32_t *)(void *)buf); - - return val; -} - -static int -nfs_get_ugid(struct nfs_context *nfs, const char *buf, int slen, int is_user) -{ - int ugid = 0; - const char *name = buf; - - while (slen) { - if (isdigit(*buf)) { - ugid *= 10; - ugid += *buf - '0'; - } else { -#ifdef HAVE_GETPWNAM - struct passwd *pwd = getpwnam(name); - if (pwd) { - if (is_user) { - return pwd->pw_uid; - } else { - return pwd->pw_gid; - } - } -#else - (void) name; // Let the compiler know that this variable is intentionally unused, build would fail with -Werror=unused-variable otherwise -#endif - return 65534; - } - buf++; - slen--; - } - return ugid; -} - -#define CHECK_GETATTR_BUF_SPACE(len, size) \ - if (len < size) { \ - nfs_set_error(nfs, "Not enough data in fattr4"); \ - return -1; \ - } - -static int -nfs_parse_attributes(struct nfs_context *nfs, struct nfs4_cb_data *data, - struct nfs_stat_64 *st, const char *buf, int len) -{ - int type, slen, pad; - - /* Type */ - CHECK_GETATTR_BUF_SPACE(len, 4); - type = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - /* Size */ - CHECK_GETATTR_BUF_SPACE(len, 8); - st->nfs_size = nfs_pntoh64((uint32_t *)(void *)buf); - buf += 8; - len -= 8; - /* Inode */ - CHECK_GETATTR_BUF_SPACE(len, 8); - st->nfs_ino = nfs_pntoh64((uint32_t *)(void *)buf); - buf += 8; - len -= 8; - /* Mode */ - CHECK_GETATTR_BUF_SPACE(len, 4); - st->nfs_mode = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - switch (type) { - case NF4REG: - st->nfs_mode |= S_IFREG; - break; - case NF4DIR: - st->nfs_mode |= S_IFDIR; - break; - case NF4BLK: - st->nfs_mode |= S_IFBLK; - break; - case NF4CHR: - st->nfs_mode |= S_IFCHR; - break; - case NF4LNK: - st->nfs_mode |= S_IFLNK; - break; - case NF4SOCK: - st->nfs_mode |= S_IFSOCK; - break; - case NF4FIFO: - st->nfs_mode |= S_IFIFO; - break; - default: - break; - } - /* Num Links */ - CHECK_GETATTR_BUF_SPACE(len, 4); - st->nfs_nlink = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - /* Owner */ - CHECK_GETATTR_BUF_SPACE(len, 4); - slen = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - pad = (4 - (slen & 0x03)) & 0x03; - CHECK_GETATTR_BUF_SPACE(len, slen); - st->nfs_uid = nfs_get_ugid(nfs, buf, slen, 1); - buf += slen; - CHECK_GETATTR_BUF_SPACE(len, pad); - buf += pad; - len -= pad; - /* Group */ - CHECK_GETATTR_BUF_SPACE(len, 4); - slen = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - pad = (4 - (slen & 0x03)) & 0x03; - CHECK_GETATTR_BUF_SPACE(len, slen); - st->nfs_gid = nfs_get_ugid(nfs, buf, slen, 0); - buf += slen; - CHECK_GETATTR_BUF_SPACE(len, pad); - buf += pad; - len -= pad; - /* Space Used */ - CHECK_GETATTR_BUF_SPACE(len, 8); - st->nfs_used = nfs_pntoh64((uint32_t *)(void *)buf); - buf += 8; - len -= 8; - /* ATime */ - CHECK_GETATTR_BUF_SPACE(len, 12); - st->nfs_atime = nfs_pntoh64((uint32_t *)(void *)buf); - buf += 8; - len -= 8; - st->nfs_atime_nsec = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - /* CTime */ - CHECK_GETATTR_BUF_SPACE(len, 12); - st->nfs_ctime = nfs_pntoh64((uint32_t *)(void *)buf); - buf += 8; - len -= 8; - st->nfs_ctime_nsec = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - /* MTime */ - CHECK_GETATTR_BUF_SPACE(len, 12); - st->nfs_mtime = nfs_pntoh64((uint32_t *)(void *)buf); - buf += 8; - len -= 8; - st->nfs_mtime_nsec = ntohl(*(uint32_t *)(void *)buf); - buf += 4; - len -= 4; - - st->nfs_blksize = NFS_BLKSIZE; - st->nfs_blocks = (st->nfs_used + NFS_BLKSIZE -1) / NFS_BLKSIZE; - - return 0; -} - -static int -nfs4_num_path_components(struct nfs_context *nfs, const char *path) -{ - int i; - - for (i = 0; (path = strchr(path, '/')); path++, i++) - ; - - return i; -} - -static int -nfs4_op_create(struct nfs_context *nfs, nfs_argop4 *op, const char *name, - nfs_ftype4 type, struct nfs4_blob *attrmask, - struct nfs4_blob *attr_vals, const char *linkdata, int dev) -{ - CREATE4args *cargs; - - op[0].argop = OP_CREATE; - cargs = &op[0].nfs_argop4_u.opcreate; - memset(cargs, 0, sizeof(*cargs)); - cargs->objtype.type = type; - cargs->objname.utf8string_len = strlen(name); - cargs->objname.utf8string_val = discard_const(name); - if (attrmask) { - cargs->createattrs.attrmask.bitmap4_len = attrmask->len; - cargs->createattrs.attrmask.bitmap4_val = attrmask->val; - } - if (attr_vals) { - cargs->createattrs.attr_vals.attrlist4_len = attr_vals->len; - cargs->createattrs.attr_vals.attrlist4_val = attr_vals->val; - } - if (linkdata) { - cargs->objtype.createtype4_u.linkdata.utf8string_len = - strlen(linkdata); - cargs->objtype.createtype4_u.linkdata.utf8string_val = - discard_const(linkdata); - } - switch (type) { - case NF4CHR: - cargs->objtype.type = NF4CHR; - cargs->objtype.createtype4_u.devdata.specdata1 = major(dev); - cargs->objtype.createtype4_u.devdata.specdata2 = minor(dev); - break; - case NF4BLK: - cargs->objtype.type = NF4BLK; - cargs->objtype.createtype4_u.devdata.specdata1 = major(dev); - cargs->objtype.createtype4_u.devdata.specdata2 = minor(dev); - break; - default: - ; - } - return 1; -} - -static int -nfs4_op_commit(struct nfs_context *nfs, nfs_argop4 *op) -{ - COMMIT4args *coargs; - - op[0].argop = OP_COMMIT; - coargs = &op[0].nfs_argop4_u.opcommit; - coargs->offset = 0; - coargs->count = 0; - - return 1; -} - -static int -nfs4_op_close(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh) -{ - CLOSE4args *clargs; - int i = 0; - - if (fh->is_dirty) { - i += nfs4_op_commit(nfs, &op[i]); - } - - op[i].argop = OP_CLOSE; - clargs = &op[i++].nfs_argop4_u.opclose; - clargs->seqid = nfs->seqid; - clargs->open_stateid.seqid = fh->stateid.seqid; - memcpy(clargs->open_stateid.other, fh->stateid.other, 12); - - return i; -} - -static int -nfs4_op_access(struct nfs_context *nfs, nfs_argop4 *op, uint32_t access_mask) -{ - ACCESS4args *aargs; - - op[0].argop = OP_ACCESS; - aargs = &op[0].nfs_argop4_u.opaccess; - memset(aargs, 0, sizeof(*aargs)); - aargs->access = access_mask; - - return 1; -} - -static int -nfs4_op_setclientid(struct nfs_context *nfs, nfs_argop4 *op, verifier4 verifier, - const char *client_name) -{ - SETCLIENTID4args *scidargs; - - op[0].argop = OP_SETCLIENTID; - scidargs = &op[0].nfs_argop4_u.opsetclientid; - memcpy(scidargs->client.verifier, verifier, sizeof(verifier4)); - scidargs->client.id.id_len = strlen(client_name); - scidargs->client.id.id_val = discard_const(client_name); - /* TODO: Decide what we should do here. As long as we only - * expose a single FD to the application we will not be able to - * do NFSv4 callbacks easily. - * Just give it garbage for now until we figure out how we should - * solve this. Until then we will just have to avoid doing things - * that require a callback. - * ( Clients (i.e. Linux) ignore this anyway and just call back to - * the originating address and program anyway. ) - */ - scidargs->callback.cb_program = 0; /* NFS4_CALLBACK */ - scidargs->callback.cb_location.r_netid = "tcp"; - scidargs->callback.cb_location.r_addr = "0.0.0.0.0.0"; - scidargs->callback_ident = 0x00000001; - - return 1; -} - -static int -nfs4_op_open_confirm(struct nfs_context *nfs, nfs_argop4 *op, uint32_t seqid, - struct nfsfh *fh) -{ - OPEN_CONFIRM4args *ocargs; - - op[0].argop = OP_OPEN_CONFIRM; - ocargs = &op[0].nfs_argop4_u.opopen_confirm; - ocargs->open_stateid.seqid = fh->stateid.seqid; - memcpy(&ocargs->open_stateid.other, fh->stateid.other, 12); - ocargs->seqid = seqid; - - return 1; -} - -static int -nfs4_op_truncate(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - void *sabuf) -{ - SETATTR4args *saargs; - static uint32_t mask[2] = {1 << (FATTR4_SIZE), - 1 << (FATTR4_TIME_MODIFY_SET - 32)}; - - op[0].argop = OP_SETATTR; - saargs = &op[0].nfs_argop4_u.opsetattr; - saargs->stateid.seqid = fh->stateid.seqid; - memcpy(saargs->stateid.other, fh->stateid.other, 12); - - saargs->obj_attributes.attrmask.bitmap4_len = 2; - saargs->obj_attributes.attrmask.bitmap4_val = mask; - - saargs->obj_attributes.attr_vals.attrlist4_len = 12; - saargs->obj_attributes.attr_vals.attrlist4_val = sabuf; - - return 1; -} - -static int -nfs4_op_chmod(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - void *sabuf) -{ - SETATTR4args *saargs; - static uint32_t mask[2] = {0, - 1 << (FATTR4_MODE - 32)}; - - op[0].argop = OP_SETATTR; - saargs = &op[0].nfs_argop4_u.opsetattr; - saargs->stateid.seqid = fh->stateid.seqid; - memcpy(saargs->stateid.other, fh->stateid.other, 12); - - saargs->obj_attributes.attrmask.bitmap4_len = 2; - saargs->obj_attributes.attrmask.bitmap4_val = mask; - - saargs->obj_attributes.attr_vals.attrlist4_len = 4; - saargs->obj_attributes.attr_vals.attrlist4_val = sabuf; - - return 1; -} - -static int -nfs4_op_chown(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - void *sabuf, int len) -{ - SETATTR4args *saargs; - static uint32_t mask[2] = {0, - 1 << (FATTR4_OWNER - 32) | - 1 << (FATTR4_OWNER_GROUP - 32)}; - - op[0].argop = OP_SETATTR; - saargs = &op[0].nfs_argop4_u.opsetattr; - saargs->stateid.seqid = fh->stateid.seqid; - memcpy(saargs->stateid.other, fh->stateid.other, 12); - - saargs->obj_attributes.attrmask.bitmap4_len = 2; - saargs->obj_attributes.attrmask.bitmap4_val = mask; - - saargs->obj_attributes.attr_vals.attrlist4_len = len; - saargs->obj_attributes.attr_vals.attrlist4_val = sabuf; - - return 1; -} - -static int -nfs4_op_utimes(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - void *sabuf, int len) -{ - SETATTR4args *saargs; - static uint32_t mask[2] = {0, - 1 << (FATTR4_TIME_ACCESS_SET - 32) | - 1 << (FATTR4_TIME_MODIFY_SET - 32)}; - - op[0].argop = OP_SETATTR; - saargs = &op[0].nfs_argop4_u.opsetattr; - saargs->stateid.seqid = fh->stateid.seqid; - memcpy(saargs->stateid.other, fh->stateid.other, 12); - - saargs->obj_attributes.attrmask.bitmap4_len = 2; - saargs->obj_attributes.attrmask.bitmap4_val = mask; - - saargs->obj_attributes.attr_vals.attrlist4_len = len; - saargs->obj_attributes.attr_vals.attrlist4_val = sabuf; - - return 1; -} - -static int -nfs4_op_readdir(struct nfs_context *nfs, nfs_argop4 *op, uint64_t cookie) -{ - READDIR4args *rdargs; - - op[0].argop = OP_READDIR; - rdargs = &op[0].nfs_argop4_u.opreaddir; - memset(rdargs, 0, sizeof(*rdargs)); - - rdargs->cookie = cookie; - rdargs->dircount = 8192; - rdargs->maxcount = 8192; - rdargs->attr_request.bitmap4_len = 2; - rdargs->attr_request.bitmap4_val = standard_attributes; - - return 1; -} - -static int -nfs4_op_rename(struct nfs_context *nfs, nfs_argop4 *op, const char *oldname, - const char *newname) -{ - RENAME4args *rargs; - - op[0].argop = OP_RENAME; - rargs = &op[0].nfs_argop4_u.oprename; - memset(rargs, 0, sizeof(*rargs)); - rargs->oldname.utf8string_len = strlen(oldname); - rargs->oldname.utf8string_val = discard_const(oldname); - rargs->newname.utf8string_len = strlen(newname); - rargs->newname.utf8string_val = discard_const(newname); - - return 1; -} - -static int -nfs4_op_read(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - uint64_t offset, size_t count) -{ - READ4args *rargs; - - op[0].argop = OP_READ; - rargs = &op[0].nfs_argop4_u.opread; - rargs->stateid.seqid = fh->stateid.seqid; - memcpy(rargs->stateid.other, fh->stateid.other, 12); - rargs->offset = offset; - rargs->count = count; - - return 1; -} - -static int -nfs4_op_write(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - uint64_t offset, size_t count, const char *buf) -{ - WRITE4args *wargs; - - op[0].argop = OP_WRITE; - wargs = &op[0].nfs_argop4_u.opwrite; - wargs->stateid.seqid = fh->stateid.seqid; - memcpy(wargs->stateid.other, fh->stateid.other, 12); - wargs->offset = offset; - if (fh->is_sync) { - wargs->stable = DATA_SYNC4; - } else { - wargs->stable = UNSTABLE4; - fh->is_dirty = 1; - } - wargs->data.data_len = count; - wargs->data.data_val = discard_const(buf); - - return 1; -} - -static int -nfs4_op_getfh(struct nfs_context *nfs, nfs_argop4 *op) -{ - op[0].argop = OP_GETFH; - - return 1; -} - -static int -nfs4_op_savefh(struct nfs_context *nfs, nfs_argop4 *op) -{ - op[0].argop = OP_SAVEFH; - - return 1; -} - -static int -nfs4_op_link(struct nfs_context *nfs, nfs_argop4 *op, const char *newname) -{ - LINK4args *largs; - - op[0].argop = OP_LINK; - largs = &op[0].nfs_argop4_u.oplink; - memset(largs, 0, sizeof(*largs)); - largs->newname.utf8string_len = strlen(newname); - largs->newname.utf8string_val = discard_const(newname); - - return 1; -} - -static int -nfs4_op_putfh(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *nfsfh) -{ - PUTFH4args *pfargs; - op[0].argop = OP_PUTFH; - - pfargs = &op[0].nfs_argop4_u.opputfh; - pfargs->object.nfs_fh4_len = nfsfh->fh.len; - pfargs->object.nfs_fh4_val = nfsfh->fh.val; - - return 1; -} - -static int -nfs4_op_lock(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - nfs_opnum4 cmd, nfs_lock_type4 locktype, - int reclaim, uint64_t offset, length4 length) -{ - LOCK4args *largs; - op[0].argop = cmd; - - largs = &op[0].nfs_argop4_u.oplock; - largs->locktype = locktype; - largs->reclaim = reclaim; - largs->offset = offset; - largs->length = length; - - if (nfs->has_lock_owner) { - largs->locker.new_lock_owner = 0; - largs->locker.locker4_u.lock_owner.lock_stateid.seqid = - fh->lock_stateid.seqid; - memcpy(largs->locker.locker4_u.lock_owner.lock_stateid.other, - fh->lock_stateid.other, 12); - largs->locker.locker4_u.lock_owner.lock_seqid = - fh->lock_seqid; - } else { - largs->locker.new_lock_owner = 1; - largs->locker.locker4_u.open_owner.open_seqid = - nfs->seqid; - largs->locker.locker4_u.open_owner.open_stateid.seqid = - fh->stateid.seqid; - memcpy(largs->locker.locker4_u.open_owner.open_stateid.other, - fh->stateid.other, 12); - largs->locker.locker4_u.open_owner.lock_owner.clientid = - nfs->clientid; - largs->locker.locker4_u.open_owner.lock_owner.owner.owner_len = - strlen(nfs->client_name); - largs->locker.locker4_u.open_owner.lock_owner.owner.owner_val = - nfs->client_name; - largs->locker.locker4_u.open_owner.lock_seqid = - fh->lock_seqid; - } - fh->lock_seqid++; - - return 1; -} - -static int -nfs4_op_locku(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - nfs_lock_type4 locktype, uint64_t offset, length4 length) -{ - LOCKU4args *luargs; - op[0].argop = OP_LOCKU; - - luargs = &op[0].nfs_argop4_u.oplocku; - luargs->locktype = locktype; - luargs->offset = offset; - luargs->length = length; - - luargs->seqid = fh->lock_seqid; - luargs->lock_stateid.seqid = fh->lock_stateid.seqid; - memcpy(luargs->lock_stateid.other, fh->lock_stateid.other, 12); - - fh->lock_seqid++; - - return 1; -} - -static int -nfs4_op_lockt(struct nfs_context *nfs, nfs_argop4 *op, struct nfsfh *fh, - nfs_lock_type4 locktype, uint64_t offset, length4 length) -{ - LOCKT4args *ltargs; - op[0].argop = OP_LOCKT; - - ltargs = &op[0].nfs_argop4_u.oplockt; - ltargs->locktype = locktype; - ltargs->offset = offset; - ltargs->length = length; - - ltargs->owner.clientid = nfs->clientid; - ltargs->owner.owner.owner_len = strlen(nfs->client_name); - ltargs->owner.owner.owner_val = nfs->client_name; - - return 1; -} - -static int -nfs4_op_lookup(struct nfs_context *nfs, nfs_argop4 *op, const char *path) -{ - LOOKUP4args *largs; - - op[0].argop = OP_LOOKUP; - largs = &op[0].nfs_argop4_u.oplookup; - largs->objname.utf8string_len = strlen(path); - largs->objname.utf8string_val = discard_const(path); - - return 1; -} - -static int -nfs4_op_setclientid_confirm(struct nfs_context *nfs, struct nfs_argop4 *op, - uint64_t clientid, verifier4 verifier) -{ - SETCLIENTID_CONFIRM4args *scidcargs; - - op[0].argop = OP_SETCLIENTID_CONFIRM; - scidcargs = &op[0].nfs_argop4_u.opsetclientid_confirm; - scidcargs->clientid = clientid; - memcpy(scidcargs->setclientid_confirm, verifier, NFS4_VERIFIER_SIZE); - - return 1; -} - -static int -nfs4_op_putrootfh(struct nfs_context *nfs, nfs_argop4 *op) -{ - op[0].argop = OP_PUTROOTFH; - - return 1; -} - -static int -nfs4_op_readlink(struct nfs_context *nfs, nfs_argop4 *op) -{ - op[0].argop = OP_READLINK; - - return 1; -} - -static int -nfs4_op_remove(struct nfs_context *nfs, nfs_argop4 *op, const char *name) -{ - REMOVE4args *rmargs; - - op[0].argop = OP_REMOVE; - rmargs = &op[0].nfs_argop4_u.opremove; - memset(rmargs, 0, sizeof(*rmargs)); - rmargs->target.utf8string_len = strlen(name); - rmargs->target.utf8string_val = discard_const(name); - - return 1; -} - -static int -nfs4_op_getattr(struct nfs_context *nfs, nfs_argop4 *op, - uint32_t *attributes, int count) -{ - GETATTR4args *gaargs; - - op[0].argop = OP_GETATTR; - gaargs = &op[0].nfs_argop4_u.opgetattr; - memset(gaargs, 0, sizeof(*gaargs)); - - gaargs->attr_request.bitmap4_val = attributes; - gaargs->attr_request.bitmap4_len = count; - - return 1; -} - -/* - * Allocate op and populate the path components. - * Will mutate path. - * - * Returns: - * -1 : On error. - * : On success. Idx represents the next free index in op. - * Caller must free op. - */ -static int -nfs4_allocate_op(struct nfs_context *nfs, nfs_argop4 **op, - char *path, int num_extra) -{ - char *ptr; - int i, count; - - *op = NULL; - - count = nfs4_num_path_components(nfs, path); - - *op = malloc(sizeof(**op) * (2 + 2 * count + num_extra)); - if (*op == NULL) { - nfs_set_error(nfs, "Failed to allocate op array"); - return -1; - } - - i = 0; - if (nfs->rootfh.len) { - struct nfsfh fh; - - fh.fh.len = nfs->rootfh.len; - fh.fh.val = nfs->rootfh.val; - i += nfs4_op_putfh(nfs, &(*op)[i], &fh); - } else { - i += nfs4_op_putrootfh(nfs, &(*op)[i]); - } - - ptr = &path[1]; - while (ptr && *ptr != 0) { - char *tmp; - - tmp = strchr(ptr, '/'); - if (tmp) { - *tmp = 0; - tmp = tmp + 1; - } - i += nfs4_op_lookup(nfs, &(*op)[i], ptr); - - ptr = tmp; - } - - i += nfs4_op_getattr(nfs, &(*op)[i], standard_attributes, 2); - - return i; -} - -static int -nfs4_lookup_path_async(struct nfs_context *nfs, - struct nfs4_cb_data *data, - rpc_cb cb); - -static void -nfs4_lookup_path_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - READLINK4res *rlres = NULL; - char *path, *tmp, *end; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "READLINK")) { - return; - } - - path = strdup(data->path); - if (path == NULL) { - nfs_set_error(nfs, "Out of memory duplicating path."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return; - } - - tmp = &path[0]; - while (data->link.idx-- > 1) { - tmp = strchr(tmp + 1, '/'); - } - *tmp++ = 0; - end = strchr(tmp, '/'); - if (end == NULL) { - /* Symlink was the last component. */ - end = ""; - } else { - *end++ = 0; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_READLINK, "READLINK")) < 0) { - free(path); - return; - } - rlres = &res->resarray.resarray_val[i].nfs_resop4_u.opreadlink; - - tmp = malloc(strlen(data->path) + 3 + strlen(rlres->READLINK4res_u.resok4.link.utf8string_val)); - if (tmp == NULL) { - nfs_set_error(nfs, "Out of memory duplicating path."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - free(path); - return; - } - - sprintf(tmp, "%s/%s/%s", path, rlres->READLINK4res_u.resok4.link.utf8string_val, end); - free(path); - free(data->path); - data->path = tmp; - - if (nfs4_lookup_path_async(nfs, data, data->continue_cb) < 0) { - data->cb(-ENOMEM, nfs, res, data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static int -nfs4_open_readlink(struct rpc_context *rpc, COMPOUND4res *res, - struct nfs4_cb_data *data); - -static void -nfs4_lookup_path_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4args args; - nfs_argop4 *op; - COMPOUND4res *res = command_data; - int i; - int resolve_link = 0; - char *path, *tmp; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status == RPC_STATUS_ERROR) { - data->cb(-EFAULT, nfs, res, data->private_data); - free_nfs4_cb_data(data); - return; - } - if (status == RPC_STATUS_CANCEL) { - data->cb(-EINTR, nfs, "Command was cancelled", - data->private_data); - free_nfs4_cb_data(data); - return; - } - if (status == RPC_STATUS_TIMEOUT) { - data->cb(-EINTR, nfs, "Command timed out", - data->private_data); - free_nfs4_cb_data(data); - return; - } - if (res->status != NFS4_OK && - res->status != NFS4ERR_SYMLINK) { - nfs_set_error(nfs, "NFS4: (path %s) failed with " - "%s(%d)", - data->path, - nfsstat4_to_str(res->status), - nfsstat4_to_errno(res->status)); - data->cb(nfsstat3_to_errno(res->status), nfs, - nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - - for (i = 0; i < (int)res->resarray.resarray_len; i++) { - if (res->resarray.resarray_val[i].resop == OP_GETATTR) { - GETATTR4resok *garesok; - struct nfs_stat_64 st; - - garesok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetattr.GETATTR4res_u.resok4; - - memset(&st, 0, sizeof(st)); - if (nfs_parse_attributes(nfs, data, &st, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len) < 0) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - if ((st.nfs_mode & S_IFMT) == S_IFLNK) { - /* The final component of the path was a - * symlink so we may need to resolve it. - */ - resolve_link = 1; - } - } - } - - /* Open/create is special since the final component for the file - * object is sent as part of the OP_OPEN command. So even if the - * directory path is all good and resolved, we still need to check - * the attributes for the final component and resolve it if it too - * is a symlink. - */ - if (!resolve_link) { - if (nfs4_open_readlink(rpc, res, data) < 0) { - /* It was a symlink and we have started trying to - * resolve it. Nothing more to do here. - */ - return; - } - } - - if (data->flags & LOOKUP_FLAG_NO_FOLLOW) { - /* Do not resolve the final component of the path - * if it is a symlink. - */ - resolve_link = 0; - } - - /* Everything is good so we can just pass it on to the next - * phase. - */ - if (res->status == NFS4_OK && !resolve_link) { - data->continue_cb(rpc, NFS4_OK, res, data); - return; - } - - /* Find the lookup that failed and the associated fh */ - data->link.idx = 0; - for (i = 0; i < (int)res->resarray.resarray_len; i++) { - if (res->resarray.resarray_val[i].resop == OP_LOOKUP) { - if (res->resarray.resarray_val[i].nfs_resop4_u.oplookup.status == NFS4ERR_SYMLINK) { - break; - } - data->link.idx++; - } - } - - if (!resolve_link && i == res->resarray.resarray_len) { - nfs_set_error(nfs, "Symlink not found during lookup."); - data->cb(-EFAULT, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - - /* Build a new path that strips of everything after the symlink. */ - path = strdup(data->path); - if (path == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to duplicate " - "path."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return; - } - - /* The symlink is not the last component, so find the '/' before - * the symlink and zero it out. - */ - if (!resolve_link) { - tmp = path; - for (i = 0; i < (int)data->link.idx; i++) { - tmp = strchr(tmp + 1, '/'); - } - *tmp = 0; - } - - /* We need to resolve the symlink */ - if ((i = nfs4_allocate_op(nfs, &op, path, 1)) < 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - free(path); - return; - } - - /* Append a READLINK command */ - i += nfs4_op_readlink(nfs, &op[i]); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_lookup_path_2_cb, &args, - data) != 0) { - nfs_set_error(nfs, "Failed to queue READLINK command. %s", - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - free(path); - return; - } - free(path); -} - -static int -nfs4_lookup_path_async(struct nfs_context *nfs, - struct nfs4_cb_data *data, - rpc_cb cb) -{ - COMPOUND4args args; - nfs_argop4 *op; - char *path; - int i, num_op; - - path = nfs4_resolve_path(nfs, data->path); - if (path == NULL) { - return -1; - } - free(data->path); - data->path = path; - - path = strdup(path); - if (path == NULL) { - return -1; - } - - if ((i = nfs4_allocate_op(nfs, &op, path, data->filler.max_op)) < 0) { - free(path); - return -1; - } - - num_op = data->filler.func(data, &op[i]); - data->continue_cb = cb; - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i + num_op; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_lookup_path_1_cb, &args, - data) != 0) { - nfs_set_error(nfs, "Failed to queue LOOKUP command. %s", - nfs_get_error(nfs)); - free(path); - free(op); - return -1; - } - - free(path); - free(op); - return 0; -} - -static int -nfs4_populate_getfh(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - return nfs4_op_getfh(data->nfs, op); -} - -static int -nfs4_populate_getattr(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - return nfs4_op_getfh(data->nfs, op); -} - -static int -nfs4_populate_access(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - uint32_t mode; - - memcpy(&mode, data->filler.blob3.val, sizeof(uint32_t)); - - return nfs4_op_access(data->nfs, op, mode); -} - -static void -nfs4_mount_4_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETFH4resok *gfhresok; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "GETFH")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETFH, "GETFH")) < 0) { - return; - } - gfhresok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetfh.GETFH4res_u.resok4; - - nfs->rootfh.len = gfhresok->object.nfs_fh4_len; - nfs->rootfh.val = malloc(nfs->rootfh.len); - if (nfs->rootfh.val == NULL) { - nfs_set_error(nfs, "%s: %s", __FUNCTION__, nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memcpy(nfs->rootfh.val, - gfhresok->object.nfs_fh4_val, - nfs->rootfh.len); - - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static void -nfs4_mount_3_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "SETCLIENTID_CONFIRM")) { - return; - } - - data->filler.func = nfs4_populate_getfh; - data->filler.max_op = 1; - data->filler.data = malloc(2 * sizeof(uint32_t)); - if (data->filler.data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "data structure."); - data->cb(-ENOMEM, nfs, res, data->private_data); - free_nfs4_cb_data(data); - return; - } - memset(data->filler.data, 0, 2 * sizeof(uint32_t)); - - - if (nfs4_lookup_path_async(nfs, data, nfs4_mount_4_cb) < 0) { - data->cb(-ENOMEM, nfs, res, data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static void -nfs4_mount_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[1]; - SETCLIENTID4resok *scidresok; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "SETCLIENTID")) { - return; - } - - scidresok = &res->resarray.resarray_val[0].nfs_resop4_u.opsetclientid.SETCLIENTID4res_u.resok4; - nfs->clientid = scidresok->clientid; - memcpy(nfs->setclientid_confirm, - scidresok->setclientid_confirm, - NFS4_VERIFIER_SIZE); - - memset(op, 0, sizeof(op)); - - i = nfs4_op_setclientid_confirm(nfs, &op[0], nfs->clientid, - nfs->setclientid_confirm); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(rpc, nfs4_mount_3_cb, &args, - private_data) != 0) { - nfs_set_error(nfs, "Failed to queue SETCLIENTID_CONFIRM. %s", - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static void -nfs4_mount_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4args args; - nfs_argop4 op[1]; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, NULL, "CONNECT")) { - return; - } - - memset(op, 0, sizeof(op)); - - i = nfs4_op_setclientid(nfs, &op[0], nfs->verifier, nfs->client_name); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(rpc, nfs4_mount_2_cb, &args, data) != 0) { - nfs_set_error(nfs, "Failed to queue SETCLIENTID. %s", - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -int -nfs4_mount_async(struct nfs_context *nfs, const char *server, - const char *export, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - char *new_server, *new_export; - int port; - - new_server = strdup(server); - free(nfs->server); - nfs->server = new_server; - - new_export = strdup(export); - if (nfs_normalize_path(nfs, new_export)) { - nfs_set_error(nfs, "Bad export path. %s", - nfs_get_error(nfs)); - free(new_export); - return -1; - } - free(nfs->export); - nfs->export = new_export; - - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "memory for nfs mount data"); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - data->path = strdup(new_export); - - port = nfs->nfsport ? nfs->nfsport : 2049; - if (rpc_connect_port_async(nfs->rpc, server, port, - NFS4_PROGRAM, NFS_V4, - nfs4_mount_1_cb, data) != 0) { - nfs_set_error(nfs, "Failed to start connection. %s", - nfs_get_error(nfs)); - free_nfs4_cb_data(data); - return -1; - } - return 0; -} - -static void -nfs4_chdir_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "CHDIR")) { - return; - } - - /* Ok, all good. Lets steal the path string. */ - free(nfs->cwd); - nfs->cwd = data->path; - data->path = NULL; - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -int nfs4_chdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_full_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_getattr; - data->filler.max_op = 1; - data->filler.data = malloc(2 * sizeof(uint32_t)); - if (data->filler.data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "data structure."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return -1; - } - memset(data->filler.data, 0, 2 * sizeof(uint32_t)); - - if (nfs4_lookup_path_async(nfs, data, nfs4_chdir_1_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_xstat64_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETATTR4resok *garesok; - struct nfs_stat_64 st; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "STAT64")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETATTR, "GETATTR")) < 0) { - return; - } - garesok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetattr.GETATTR4res_u.resok4; - - memset(&st, 0, sizeof(st)); - if (nfs_parse_attributes(nfs, data, &st, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len) < 0) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - } - - data->cb(0, nfs, &st, data->private_data); - free_nfs4_cb_data(data); -} - -int -nfs4_stat64_async(struct nfs_context *nfs, const char *path, - int no_follow, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_full_path(nfs, path); - if (data == NULL) { - return -1; - } - - if (no_follow) { - data->flags |= LOOKUP_FLAG_NO_FOLLOW; - } - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_getattr; - data->filler.max_op = 1; - data->filler.data = malloc(2 * sizeof(uint32_t)); - if (data->filler.data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "data structure."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return -1; - } - memset(data->filler.data, 0, 2 * sizeof(uint32_t)); - - if (nfs4_lookup_path_async(nfs, data, nfs4_xstat64_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -/* Takes object name as filler.data - * blob0 as the fattr4 attribute mask - * blob1 as the fattr4 attribute list - */ -static int -nfs4_populate_mkdir(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - - return nfs4_op_create(nfs, op, data->filler.data, NF4DIR, - &data->filler.blob0, &data->filler.blob1, - NULL, 0); -} - -static void -nfs4_mkdir_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "MKDIR")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -int -nfs4_mkdir2_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - uint32_t *u32ptr; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_mkdir; - data->filler.max_op = 1; - - /* attribute mask */ - u32ptr = malloc(2 * sizeof(uint32_t)); - if (u32ptr == NULL) { - nfs_set_error(nfs, "Out of memory allocating bitmap"); - free_nfs4_cb_data(data); - return -1; - } - u32ptr[0] = 0; - u32ptr[1] = 1 << (FATTR4_MODE - 32); - data->filler.blob0.len = 2; - data->filler.blob0.val = u32ptr; - data->filler.blob0.free = free; - - /* attribute values */ - u32ptr = malloc(1 * sizeof(uint32_t)); - if (u32ptr == NULL) { - nfs_set_error(nfs, "Out of memory allocating attributes"); - free_nfs4_cb_data(data); - return -1; - } - u32ptr[0] = htonl(mode); - data->filler.blob1.len = 4; - data->filler.blob1.val = u32ptr; - data->filler.blob1.free = free; - - if (nfs4_lookup_path_async(nfs, data, nfs4_mkdir_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -/* Takes object name as filler.data - */ -static int -nfs4_populate_remove(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - - return nfs4_op_remove(nfs, op, data->filler.data); -} - -static void -nfs4_remove_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "REMOVE")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static int -nfs4_remove_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_remove; - data->filler.max_op = 1; - - if (nfs4_lookup_path_async(nfs, data, nfs4_remove_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -int -nfs4_rmdir_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - return nfs4_remove_async(nfs, path, cb, private_data); -} - -static void -nfs_increment_seqid(struct nfs_context *nfs, uint32_t status) -{ - /* RFC3530 8.1.5 */ - switch (status) { - case NFS4ERR_STALE_CLIENTID: - case NFS4ERR_STALE_STATEID: - case NFS4ERR_BAD_STATEID: - case NFS4ERR_BAD_SEQID: - case NFS4ERR_BADZDR: - case NFS4ERR_RESOURCE: - case NFS4ERR_NOFILEHANDLE: - break; - default: - nfs->seqid++; - } -} - -static void -nfs4_open_setattr_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - struct nfsfh *fh; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "SETATTR")) { - return; - } - - fh = data->filler.blob0.val; - data->filler.blob0.val = NULL; - data->cb(0, nfs, fh, data->private_data); - free_nfs4_cb_data(data); -} - -static void -nfs4_open_truncate_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[2]; - int i; - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - i = nfs4_op_putfh(nfs, op, fh); - i += nfs4_op_truncate(nfs, &op[i], fh, data->filler.blob3.val); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_open_setattr_cb, &args, - data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static void -nfs4_open_chmod_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[2]; - int i; - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - i = nfs4_op_putfh(nfs, op, fh); - i += nfs4_op_chmod(nfs, &op[i], fh, data->filler.blob3.val); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_open_setattr_cb, &args, - data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static void -nfs4_open_confirm_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - OPEN_CONFIRM4resok *ocresok; - int i; - struct nfsfh *fh; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (res) { - nfs_increment_seqid(nfs, res->status); - } - - if (check_nfs4_error(nfs, status, data, res, "OPEN_CONFIRM")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_OPEN_CONFIRM, - "OPEN_CONFIRM")) < 0) { - return; - } - ocresok = &res->resarray.resarray_val[i].nfs_resop4_u.opopen_confirm.OPEN_CONFIRM4res_u.resok4; - - fh = data->filler.blob0.val; - - fh->stateid.seqid = ocresok->open_stateid.seqid; - memcpy(fh->stateid.other, ocresok->open_stateid.other, 12); - - if (data->open_cb) { - data->open_cb(rpc, status, command_data, private_data); - return; - } - data->filler.blob0.val = NULL; - data->cb(0, nfs, fh, data->private_data); - free_nfs4_cb_data(data); -} - -static void -nfs4_open_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - ACCESS4resok *aresok; - OPEN4resok *oresok; - GETFH4resok *gresok; - int i; - struct nfsfh *fh; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (res) { - nfs_increment_seqid(nfs, res->status); - } - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - /* Parse Access and check that we have the access that we need */ - if ((i = nfs4_find_op(nfs, data, res, OP_ACCESS, "ACCESS")) < 0) { - return; - } - aresok = &res->resarray.resarray_val[i].nfs_resop4_u.opaccess.ACCESS4res_u.resok4; - if (aresok->supported != aresok->access) { - nfs_set_error(nfs, "Insufficient ACCESS. Wanted %08x but " - "got %08x.", aresok->access, aresok->supported); - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - - /* Parse GetFH */ - if ((i = nfs4_find_op(nfs, data, res, OP_GETFH, "GETFH")) < 0) { - return; - } - gresok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetfh.GETFH4res_u.resok4; - - fh = malloc(sizeof(*fh)); - if (fh == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memset(fh, 0 , sizeof(*fh)); - - data->filler.blob0.val = fh; - data->filler.blob0.free = (blob_free)nfs_free_nfsfh; - - fh->fh.len = gresok->object.nfs_fh4_len; - fh->fh.val = malloc(fh->fh.len); - if (fh->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memcpy(fh->fh.val, gresok->object.nfs_fh4_val, fh->fh.len); - - if (data->filler.flags & O_SYNC) { - fh->is_sync = 1; - } - - if (data->filler.flags & O_APPEND) { - fh->is_append = 1; - } - - /* Parse Open */ - if ((i = nfs4_find_op(nfs, data, res, OP_OPEN, "OPEN")) < 0) { - return; - } - oresok = &res->resarray.resarray_val[i].nfs_resop4_u.opopen.OPEN4res_u.resok4; - fh->stateid.seqid = oresok->stateid.seqid; - memcpy(fh->stateid.other, oresok->stateid.other, 12); - - - if (oresok->rflags & OPEN4_RESULT_CONFIRM) { - COMPOUND4args args; - nfs_argop4 op[2]; - - memset(op, 0, sizeof(op)); - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_open_confirm(nfs, &op[i], nfs->seqid, fh); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(rpc, nfs4_open_confirm_cb, &args, - private_data) != 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return; - } - return; - } - - if (data->open_cb) { - data->open_cb(rpc, status, command_data, private_data); - return; - } - data->filler.blob0.val = NULL; - data->cb(0, nfs, fh, data->private_data); - free_nfs4_cb_data(data); -} - -static void -nfs4_init_random_verifier(char *verifier) -{ - static uint64_t seed = 0, v; - int i; - - if (seed == 0) { - seed = ~rpc_current_time() << 32 | getpid(); - } else { - seed *= 1337; - } - - v = seed; - for (i = 0; i < NFS4_VERIFIER_SIZE; i++) { - verifier[i] = v & 0xff; - v >>= 8; - } -} - -/* filler.flags are the open flags - * filler.data is the object name - */ -static int -nfs4_populate_open(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - OPEN4args *oargs; - uint32_t access_mask = 0; - verifier4 verifier; - int i; - - if (data->filler.flags & O_WRONLY) { - access_mask |= ACCESS4_MODIFY; - } - if (data->filler.flags & O_RDWR) { - access_mask |= ACCESS4_READ|ACCESS4_MODIFY; - } - if (!(data->filler.flags & O_WRONLY)) { - access_mask |= ACCESS4_READ; - } - - /* Access */ - i = nfs4_op_access(nfs, &op[0], access_mask); - - /* Open */ - op[i].argop = OP_OPEN; - oargs = &op[i++].nfs_argop4_u.opopen; - memset(oargs, 0, sizeof(*oargs)); - - oargs->seqid = nfs->seqid; - if (access_mask & ACCESS4_READ) { - oargs->share_access |= OPEN4_SHARE_ACCESS_READ; - } - if (access_mask & ACCESS4_MODIFY) { - oargs->share_access |= OPEN4_SHARE_ACCESS_WRITE; - } - oargs->share_deny = OPEN4_SHARE_DENY_NONE; - oargs->owner.clientid = nfs->clientid; - oargs->owner.owner.owner_len = strlen(nfs->client_name); - oargs->owner.owner.owner_val = nfs->client_name; - if (data->filler.flags & O_CREAT) { - createhow4 *ch; - fattr4 *fa; - - ch = &oargs->openhow.openflag4_u.how; - fa = &ch->createhow4_u.createattrs; - - oargs->openhow.opentype = OPEN4_CREATE; - if (data->filler.flags|O_EXCL) { - ch->mode = EXCLUSIVE4; - - nfs4_init_random_verifier(&verifier[0]); - memcpy(ch->createhow4_u.createverf, verifier, - sizeof(verifier4)); - } else { - ch->mode = UNCHECKED4; - fa->attrmask.bitmap4_len = data->filler.blob1.len; - fa->attrmask.bitmap4_val = data->filler.blob1.val; - - fa->attr_vals.attrlist4_len = data->filler.blob2.len; - fa->attr_vals.attrlist4_val = data->filler.blob2.val; - } - } else { - oargs->openhow.opentype = OPEN4_NOCREATE; - } - oargs->claim.claim = CLAIM_NULL; - oargs->claim.open_claim4_u.file.utf8string_len = - strlen(data->filler.data); - oargs->claim.open_claim4_u.file.utf8string_val = - data->filler.data; - - /* GetFH */ - i += nfs4_op_getfh(nfs, &op[i]); - - return i; -} - -static void -nfs4_open_readlink_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - READLINK4resok *rlresok; - int i; - char *path; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "READLINK")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_READLINK, "READLINK")) < 0) { - return; - } - - rlresok = &res->resarray.resarray_val[i].nfs_resop4_u.opreadlink.READLINK4res_u.resok4; - - path = malloc(2 + strlen(data->path) + - strlen(rlresok->link.utf8string_val)); - if (path == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "path"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return; - } - sprintf(path, "%s/%s", data->path, rlresok->link.utf8string_val); - - - - free(data->path); - data->path = NULL; - free(data->filler.data); - data->filler.data = NULL; - - data->path = nfs4_resolve_path(nfs, path); - free(path); - if (data->path == NULL) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return; - } - - data_split_path(data); - - data->filler.func = nfs4_populate_open; - data->filler.max_op = 3; - - if (nfs4_lookup_path_async(nfs, data, nfs4_open_cb) < 0) { - data->cb(-ENOMEM, nfs, res, data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static int -nfs4_populate_lookup_readlink(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - int i; - - i = nfs4_op_lookup(nfs, &op[0], data->filler.data); - i += nfs4_op_readlink(nfs, &op[i]); - - return i; -} - -/* If the final component in the open was a symlink we need to resolve it and - * re-try the nfs4_open_async() - */ -static int -nfs4_open_readlink(struct rpc_context *rpc, COMPOUND4res *res, - struct nfs4_cb_data *data) -{ - struct nfs_context *nfs = data->nfs; - int i; - - for (i = 0; i < (int)res->resarray.resarray_len; i++) { - OPEN4res *ores; - - if (res->resarray.resarray_val[i].resop != OP_OPEN) { - continue; - } - ores = &res->resarray.resarray_val[i].nfs_resop4_u.opopen; - - if (ores->status != NFS4ERR_SYMLINK) { - continue; - } - - if (data->filler.flags & O_NOFOLLOW) { - nfs_set_error(nfs, "Symlink encountered during " - "open(O_NOFOLLOW)"); - data->cb(-ELOOP, nfs, nfs_get_error(nfs), - data->private_data); - return -1; - } - - /* The object we need to do readlink on is already stored in - * data->filler.data so *populate* can just grab it from there. - */ - data->filler.func = nfs4_populate_lookup_readlink; - data->filler.max_op = 2; - - if (nfs4_lookup_path_async(nfs, data, - nfs4_open_readlink_cb) < 0) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return -1; - } - return -1; - } - - return 0; -} - -/* - * data.blob0 is used for nfsfh - * data.blob1 is used for the attribute mask in case on O_CREAT - * data.blob2 is the attribute value in case of O_CREAT - */ -static int -nfs4_open_async_internal(struct nfs_context *nfs, struct nfs4_cb_data *data, - int flags, int mode) -{ - if (flags & O_APPEND && !(flags & (O_RDWR|O_WRONLY))) { - flags &= ~O_APPEND; - } - - if (flags & O_CREAT) { - uint32_t *d; - - /* Attribute mask */ - d = malloc(2 * sizeof(uint32_t)); - if (d == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - d[0] = 0; - d[1] = 1 << (FATTR4_MODE - 32); - - data->filler.blob1.val = d; - data->filler.blob1.len = 2; - data->filler.blob1.free = free; - - /* Attribute value */ - d = malloc(sizeof(uint32_t)); - if (d == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - - *d = htonl(mode); - - data->filler.blob2.val = d; - data->filler.blob2.len = 4; - data->filler.blob2.free = free; - } - - data->filler.func = nfs4_populate_open; - data->filler.max_op = 3; - data->filler.flags = flags; - - if (nfs4_lookup_path_async(nfs, data, nfs4_open_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -int -nfs4_open_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - uint32_t m; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - - /* O_TRUNC is only valid for O_RDWR or O_WRONLY */ - if (flags & O_TRUNC && !(flags & (O_RDWR|O_WRONLY))) { - flags &= ~O_TRUNC; - } - /* Successful O_EXCL means the file is 0 size already. */ - if (flags & O_EXCL) { - flags &= ~O_TRUNC; - } - - if (flags & O_TRUNC) { - data->open_cb = nfs4_open_truncate_cb; - - data->filler.blob3.val = malloc(12); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob3.free = free; - - memset(data->filler.blob3.val, 0, 12); - } - if (flags & O_EXCL) { - data->open_cb = nfs4_open_chmod_cb; - - data->filler.blob3.val = malloc(4); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob3.free = free; - - m = htonl(mode); - memcpy(data->filler.blob3.val, &m, sizeof(uint32_t)); - } - - return nfs4_open_async_internal(nfs, data, flags, mode); -} - -int -nfs4_fstat64_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "cb data"); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - i = nfs4_op_putfh(nfs, &op[0], nfsfh); - i += nfs4_op_getattr(nfs, &op[i], standard_attributes, 2); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_xstat64_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_close_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (res) { - nfs_increment_seqid(nfs, res->status); - } - - if (check_nfs4_error(nfs, status, data, res, "CLOSE")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -int -nfs4_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, - void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[3]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "cb data"); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], nfsfh); - i += nfs4_op_close(nfs, &op[i], nfsfh); - - data->filler.blob0.val = nfsfh; - data->filler.blob0.free = (blob_free)nfs_free_nfsfh; - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_close_cb, &args, - data) != 0) { - data->filler.blob0.val = NULL; - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_pread_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - READ4resok *rres = NULL; - struct nfsfh *nfsfh; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - nfsfh = data->filler.blob0.val; - - if (check_nfs4_error(nfs, status, data, res, "READ")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_READ, "READ")) < 0) { - return; - } - rres = &res->resarray.resarray_val[i].nfs_resop4_u.opread.READ4res_u.resok4; - - if (data->rw_data.update_pos) { - nfsfh->offset = data->rw_data.offset + rres->data.data_len; - } - - data->cb(rres->data.data_len, nfs, rres->data.data_val, - data->private_data); - free_nfs4_cb_data(data); -} - -int -nfs4_pread_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, nfs_cb cb, - void *private_data, int update_pos) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "cb data"); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob0.val = nfsfh; - data->filler.blob0.free = NULL; - data->rw_data.offset = offset; - data->rw_data.update_pos = update_pos; - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], nfsfh); - i += nfs4_op_read(nfs, &op[i], nfsfh, offset, count); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_pread_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_symlink_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "SYMLINK")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -/* Takes object name as filler.data - * blob0 as the target - */ -static int -nfs4_populate_symlink(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - - return nfs4_op_create(nfs, op, data->filler.data, NF4LNK, - NULL, NULL, data->filler.blob0.val, 0); - - return 1; -} - -int -nfs4_symlink_async(struct nfs_context *nfs, const char *target, - const char *linkname, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_split_path(nfs, linkname); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_symlink; - data->filler.max_op = 1; - - data->filler.blob0.val = strdup(target); - data->filler.blob0.free = free; - - if (nfs4_lookup_path_async(nfs, data, nfs4_symlink_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_readlink_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - READLINK4resok *rlresok; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "READLINK")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_READLINK, "READLINK")) < 0) { - return; - } - - rlresok = &res->resarray.resarray_val[i].nfs_resop4_u.opreadlink.READLINK4res_u.resok4; - - data->cb(0, nfs, rlresok->link.utf8string_val, data->private_data); - free_nfs4_cb_data(data); -} - -static int -nfs4_populate_readlink(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - int i; - - i = nfs4_op_readlink(nfs, &op[0]); - - return i; -} - -int -nfs4_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_full_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_readlink; - data->filler.max_op = 1; - data->flags |= LOOKUP_FLAG_NO_FOLLOW; - - if (nfs4_lookup_path_async(nfs, data, nfs4_readlink_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_pwrite_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - WRITE4resok *wres = NULL; - struct nfsfh *nfsfh; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - nfsfh = data->filler.blob0.val; - - if (check_nfs4_error(nfs, status, data, res, "WRITE")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_WRITE, "WRITE")) < 0) { - return; - } - wres = &res->resarray.resarray_val[i].nfs_resop4_u.opwrite.WRITE4res_u.resok4; - - if (data->rw_data.update_pos) { - nfsfh->offset = data->rw_data.offset + wres->count; - } - - data->cb(wres->count, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -int -nfs4_pwrite_async_internal(struct nfs_context *nfs, struct nfsfh *nfsfh, - uint64_t offset, size_t count, const char *buf, - nfs_cb cb, void *private_data, int update_pos) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "cb data"); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob0.val = nfsfh; - data->filler.blob0.free = NULL; - data->rw_data.offset = offset; - data->rw_data.update_pos = update_pos; - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], nfsfh); - i += nfs4_op_write(nfs, &op[i], nfsfh, offset, count, buf); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_pwrite_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_write_append_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETATTR4resok *garesok = NULL; - struct nfsfh *nfsfh; - int i; - uint64_t offset; - char *buf; - uint32_t count; - struct nfs_stat_64 st; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - nfsfh = data->filler.blob0.val; - - buf = data->filler.blob1.val; - count = data->filler.blob1.len; - - if (check_nfs4_error(nfs, status, data, res, "GETATTR")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETATTR, "GETATTR")) < 0) { - return; - } - - - garesok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetattr.GETATTR4res_u.resok4; - if (garesok->obj_attributes.attr_vals.attrlist4_len < 8) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - - memset(&st, 0, sizeof(st)); - nfs_parse_attributes(nfs, data, &st, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len); - offset = st.nfs_size; - - if (nfs4_pwrite_async_internal(nfs, nfsfh, offset, - (size_t)count, buf, - data->cb, data->private_data, 1) < 0) { - free_nfs4_cb_data(data); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - return; - } - - free_nfs4_cb_data(data); -} - -int -nfs4_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, uint64_t count, - const void *buf, nfs_cb cb, void *private_data) -{ - if (nfsfh->is_append) { - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "cb data"); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob0.val = nfsfh; - data->filler.blob0.free = NULL; - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], nfsfh); - i += nfs4_op_getattr(nfs, &op[i], standard_attributes, 2); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - data->filler.blob0.val = nfsfh; - data->filler.blob0.free = NULL; - - data->filler.blob1.val = discard_const(buf); - data->filler.blob1.len = (int)count; - data->filler.blob1.free = NULL; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_write_append_cb, - &args, data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; - } - - return nfs4_pwrite_async_internal(nfs, nfsfh, nfsfh->offset, - (size_t)count, buf, - cb, private_data, 1); -} - -int -nfs4_create_async(struct nfs_context *nfs, const char *path, int flags, - int mode, nfs_cb cb, void *private_data) -{ - return nfs4_open_async(nfs, path, O_CREAT | flags, mode, - cb, private_data); -} - -int -nfs4_unlink_async(struct nfs_context *nfs, const char *path, - nfs_cb cb, void *private_data) -{ - return nfs4_remove_async(nfs, path, cb, private_data); -} - -static void -nfs4_link_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "LINK")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static int -nfs4_populate_link(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - struct nfsfh *nfsfh = data->filler.blob0.val; - - int i; - - i = nfs4_op_savefh(nfs, &op[0]); - i += nfs4_op_putfh(nfs, &op[i], nfsfh); - i += nfs4_op_link(nfs, &op[i], data->filler.data); - - return i; -} - -static void -nfs4_link_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETFH4resok *gfhresok; - int i; - struct nfsfh *fh; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "LINK")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETFH, "GETFH")) < 0) { - return; - } - gfhresok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetfh.GETFH4res_u.resok4; - - /* oldpath fh */ - fh = malloc(sizeof(*fh)); - if (fh == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memset(fh, 0 , sizeof(*fh)); - data->filler.blob0.val = fh; - data->filler.blob0.free = (blob_free)nfs_free_nfsfh; - - fh->fh.len = gfhresok->object.nfs_fh4_len; - fh->fh.val = malloc(fh->fh.len); - if (fh->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memcpy(fh->fh.val, gfhresok->object.nfs_fh4_val, fh->fh.len); - - - data->filler.func = nfs4_populate_link; - data->filler.max_op = 3; - - free(data->path); - data->path = data->filler.blob1.val; - data->filler.blob1.val = NULL; - data->filler.blob1.free = NULL; - - if (nfs4_lookup_path_async(nfs, data, nfs4_link_2_cb) < 0) { - data->cb(-EFAULT, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -/* - * filler.data is the name of the new object - * blob0 is the filehandle for newpath parent directory. - * blob1 is oldpath. - */ -int -nfs4_link_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_split_path(nfs, newpath); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_getfh; - data->filler.max_op = 1; - - /* oldpath */ - data->filler.blob1.val = strdup(oldpath); - if (data->filler.blob1.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob1.free = free; - - if (nfs4_lookup_path_async(nfs, data, nfs4_link_1_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_rename_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "RENAME")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static int -nfs4_populate_rename(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - struct nfsfh *nfsfh = data->filler.blob0.val; - int i; - - i = nfs4_op_savefh(nfs, &op[0]); - i += nfs4_op_putfh(nfs, &op[i], nfsfh); - i += nfs4_op_rename(nfs, &op[i], data->filler.data, - data->filler.blob1.val); - - return i; -} - -static void -nfs4_rename_1_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETFH4resok *gfhresok; - int i; - struct nfsfh *fh; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "RENAME")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETFH, "GETFH")) < 0) { - return; - } - gfhresok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetfh.GETFH4res_u.resok4; - - /* newpath fh */ - fh = malloc(sizeof(*fh)); - if (fh == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memset(fh, 0 , sizeof(*fh)); - data->filler.blob0.val = fh; - data->filler.blob0.free = (blob_free)nfs_free_nfsfh; - - fh->fh.len = gfhresok->object.nfs_fh4_len; - fh->fh.val = malloc(fh->fh.len); - if (fh->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memcpy(fh->fh.val, gfhresok->object.nfs_fh4_val, fh->fh.len); - - data->filler.blob1.val = data->filler.data; - data->filler.blob1.free = free; - data->filler.data = NULL; - - /* Update path and data to point to the old path/name */ - free(data->path); - data->path = nfs4_resolve_path(nfs, data->filler.blob2.val); - if (data->path == NULL) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - data_split_path(data); - - data->filler.func = nfs4_populate_rename; - data->filler.max_op = 3; - - if (nfs4_lookup_path_async(nfs, data, nfs4_rename_2_cb) < 0) { - nfs_set_error(nfs, "Out of memory."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -/* - * blob0 is the filehandle for newpath parent directory. - * blob1 is the new name - * blob2 is oldpath. - */ -int -nfs4_rename_async(struct nfs_context *nfs, const char *oldpath, - const char *newpath, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_split_path(nfs, newpath); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_getfh; - data->filler.max_op = 1; - - /* oldpath */ - data->filler.blob2.val = strdup(oldpath); - if (data->filler.blob2.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob2.free = free; - - if (nfs4_lookup_path_async(nfs, data, nfs4_rename_1_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_mknod_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "MKNOD")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static int -nfs4_populate_mknod(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - uint32_t mode, *ptr; - int dev; - - /* Strip off the file type before we marshall it */ - ptr = (void *)data->filler.blob1.val; - mode = *ptr; - *ptr = htonl(mode & ~S_IFMT); - - dev = data->filler.blob2.len; - - switch (mode & S_IFMT) { - case S_IFBLK: - return nfs4_op_create(nfs, op, data->filler.data, NF4BLK, - &data->filler.blob0, &data->filler.blob1, - NULL, dev); - case S_IFCHR: - return nfs4_op_create(nfs, op, data->filler.data, NF4CHR, - &data->filler.blob0, &data->filler.blob1, - NULL, dev); - } - - return 1; -} - -/* Takes object name as filler.data - * blob0 as attribute mask - * blob1 as attribute value - * blob2.len as dev - */ -int -nfs4_mknod_async(struct nfs_context *nfs, const char *path, int mode, int dev, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - uint32_t *u32ptr; - - switch (mode & S_IFMT) { - case S_IFCHR: - case S_IFBLK: - break; - default: - nfs_set_error(nfs, "Invalid file type for " - "MKNOD call"); - return -1; - } - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_mknod; - data->filler.max_op = 1; - - /* attribute mask */ - u32ptr = malloc(2 * sizeof(uint32_t)); - if (u32ptr == NULL) { - nfs_set_error(nfs, "Out of memory allocating bitmap"); - return 0; - } - u32ptr[0] = 0; - u32ptr[1] = 1 << (FATTR4_MODE - 32); - data->filler.blob0.len = 2; - data->filler.blob0.val = u32ptr; - data->filler.blob0.free = free; - - /* attribute values */ - u32ptr = malloc(1 * sizeof(uint32_t)); - if (u32ptr == NULL) { - nfs_set_error(nfs, "Out of memory allocating attributes"); - free_nfs4_cb_data(data); - return -1; - } - u32ptr[0] = mode; - data->filler.blob1.len = 4; - data->filler.blob1.val = u32ptr; - data->filler.blob1.free = free; - - data->filler.blob2.len = dev; - - if (nfs4_lookup_path_async(nfs, data, nfs4_mknod_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_parse_readdir(struct nfs_context *nfs, struct nfs4_cb_data *data, - READDIR4resok *res); - -static void -nfs4_opendir_2_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - READDIR4resok *rdresok; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "READDIR")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_READDIR, "READDIR")) < 0) { - return; - } - rdresok = &res->resarray.resarray_val[i].nfs_resop4_u.opreaddir.READDIR4res_u.resok4; - nfs4_parse_readdir(nfs, data, rdresok); -} - -static void -nfs4_opendir_continue(struct nfs_context *nfs, struct nfs4_cb_data *data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfsfh *fh = data->filler.blob0.val; - uint64_t cookie; - int i; - - memcpy(&cookie, data->filler.blob2.val, sizeof(uint64_t)); - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_readdir(nfs, &op[i], cookie); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_opendir_2_cb, &args, - data) != 0) { - nfs_set_error(nfs, "Failed to queue READDIR command. %s", - nfs_get_error(nfs)); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -static void -nfs4_parse_readdir(struct nfs_context *nfs, struct nfs4_cb_data *data, - READDIR4resok *res) -{ - struct nfsdir *nfsdir = data->filler.blob1.val; - struct entry4 *e; - - e = res->reply.entries; - while (e) { - struct nfsdirent *nfsdirent; - struct nfs_stat_64 st; - - memcpy(data->filler.blob2.val, &e->cookie, sizeof(uint64_t)); - - nfsdirent = malloc(sizeof(struct nfsdirent)); - if (nfsdirent == NULL) { - nfs_set_error(nfs, "Out of memory."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - return; - } - nfsdirent->name = strdup(e->name.utf8string_val); - if (nfsdirent->name == NULL) { - nfs_set_error(nfs, "Out of memory."); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - free(nfsdirent); - return; - } - - memset(&st, 0, sizeof(st)); - if (nfs_parse_attributes(nfs, data, &st, - e->attrs.attr_vals.attrlist4_val, - e->attrs.attr_vals.attrlist4_len) < 0) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - free(nfsdirent->name); - free(nfsdirent); - return; - } - - nfsdirent->mode = (uint32_t)st.nfs_mode; - switch (st.nfs_mode & S_IFMT) { - case S_IFREG: - nfsdirent->type = NF4REG; - break; - case S_IFDIR: - nfsdirent->type = NF4DIR; - break; - case S_IFBLK: - nfsdirent->type = NF4BLK; - break; - case S_IFCHR: - nfsdirent->type = NF4CHR; - break; - case S_IFLNK: - nfsdirent->type = NF4LNK; - break; - case S_IFSOCK: - nfsdirent->type = NF4SOCK; - break; - case S_IFIFO: - nfsdirent->type = NF4FIFO; - break; - } - nfsdirent->size = st.nfs_size; - nfsdirent->atime.tv_sec = (long)st.nfs_atime; - nfsdirent->atime.tv_usec = (long)(st.nfs_atime_nsec/1000); - nfsdirent->atime_nsec = (uint32_t)st.nfs_atime_nsec; - nfsdirent->mtime.tv_sec = (long)st.nfs_mtime; - nfsdirent->mtime.tv_usec = (long)(st.nfs_mtime_nsec/1000); - nfsdirent->mtime_nsec = (uint32_t)st.nfs_mtime_nsec; - nfsdirent->ctime.tv_sec = (long)st.nfs_ctime; - nfsdirent->ctime.tv_usec = (long)(st.nfs_ctime_nsec/1000); - nfsdirent->ctime_nsec = (uint32_t)st.nfs_ctime_nsec; - nfsdirent->uid = (uint32_t)st.nfs_uid; - nfsdirent->gid = (uint32_t)st.nfs_gid; - nfsdirent->nlink = (uint32_t)st.nfs_nlink; - nfsdirent->dev = st.nfs_dev; - nfsdirent->rdev = st.nfs_rdev; - nfsdirent->blksize = NFS_BLKSIZE; - nfsdirent->blocks = st.nfs_blocks; - nfsdirent->used = st.nfs_used; - - nfsdirent->next = nfsdir->entries; - nfsdir->entries = nfsdirent; - e = e->nextentry; - } - - if (res->reply.eof == 0) { - nfs4_opendir_continue(nfs, data); - return; - } - - nfsdir->current = nfsdir->entries; - data->filler.blob1.val = NULL; - data->cb(0, nfs, nfsdir, data->private_data); - free_nfs4_cb_data(data); -} - -static void -nfs4_opendir_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - struct nfsfh *fh; - GETFH4resok *gresok; - READDIR4resok *rdresok; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "READDIR")) { - return; - } - - /* Parse GetFH */ - if ((i = nfs4_find_op(nfs, data, res, OP_GETFH, "GETFH")) < 0) { - return; - } - gresok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetfh.GETFH4res_u.resok4; - - fh = malloc(sizeof(*fh)); - if (fh == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memset(fh, 0 , sizeof(*fh)); - - data->filler.blob0.val = fh; - data->filler.blob0.free = (blob_free)nfs_free_nfsfh; - - fh->fh.len = gresok->object.nfs_fh4_len; - fh->fh.val = malloc(fh->fh.len); - if (fh->fh.val == NULL) { - nfs_set_error(nfs, "Out of memory. Failed to allocate " - "nfsfh"); - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - memcpy(fh->fh.val, gresok->object.nfs_fh4_val, fh->fh.len); - - if ((i = nfs4_find_op(nfs, data, res, OP_READDIR, "READDIR")) < 0) { - return; - } - rdresok = &res->resarray.resarray_val[i].nfs_resop4_u.opreaddir.READDIR4res_u.resok4; - nfs4_parse_readdir(nfs, data, rdresok); -} - -static int -nfs4_populate_readdir(struct nfs4_cb_data *data, nfs_argop4 *op) -{ - struct nfs_context *nfs = data->nfs; - uint64_t cookie; - int i; - - memcpy(&cookie, data->filler.blob2.val, sizeof(uint64_t)); - - i = nfs4_op_getfh(nfs, &op[0]); - i += nfs4_op_readdir(nfs, &op[i], cookie); - - return i; -} - - -/* blob0 is the directory filehandle - * blob1 is nfsdir - * blob2 is the cookie - */ -int -nfs4_opendir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - struct nfs4_cb_data *data; - struct nfsdir *nfsdir; - - data = init_cb_data_full_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_readdir; - data->filler.max_op = 2; - - nfsdir = malloc(sizeof(struct nfsdir)); - if (nfsdir == NULL) { - free_nfs4_cb_data(data); - nfs_set_error(nfs, "failed to allocate buffer for nfsdir"); - return -1; - } - memset(nfsdir, 0, sizeof(struct nfsdir)); - - data->filler.blob1.val = nfsdir; - data->filler.blob1.free = (blob_free)nfs_free_nfsdir; - - data->filler.blob2.val = malloc(sizeof(uint64_t)); - if (data->filler.blob2.val == NULL) { - free_nfs4_cb_data(data); - nfs_set_error(nfs, "failed to allocate buffer for cookie"); - return -1; - } - memset(data->filler.blob2.val, 0, sizeof(uint64_t)); - data->filler.blob2.free = (blob_free)free; - - if (nfs4_lookup_path_async(nfs, data, nfs4_opendir_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_truncate_close_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (res) { - nfs_increment_seqid(nfs, res->status); - } - - if (check_nfs4_error(nfs, status, data, res, "CLOSE")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static void -nfs4_truncate_open_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[4]; - int i; - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_truncate(nfs, &op[i], fh, data->filler.blob3.val); - i += nfs4_op_close(nfs, &op[i], fh); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_truncate_close_cb, &args, - data) != 0) { - /* Not much we can do but leak one fd on the server :( */ - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -/* - * data.blob3.val is a 12 byte SETATTR buffer for length+update_mtime - */ -int -nfs4_truncate_async(struct nfs_context *nfs, const char *path, uint64_t length, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->open_cb = nfs4_truncate_open_cb; - - data->filler.blob3.val = malloc(12); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob3.free = free; - - memset(data->filler.blob3.val, 0, 12); - length = nfs_hton64(length); - memcpy(data->filler.blob3.val, &length, sizeof(uint64_t)); - - if (nfs4_open_async_internal(nfs, data, O_WRONLY, 0) < 0) { - return -1; - } - - return 0; -} - -static void -nfs4_fsync_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "FSYNC")) { - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -int -nfs4_fsync_async(struct nfs_context *nfs, struct nfsfh *fh, nfs_cb cb, - void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_commit(nfs, &op[i]); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_fsync_cb, &args, - data) != 0) { - data->filler.blob0.val = NULL; - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -int -nfs4_ftruncate_async(struct nfs_context *nfs, struct nfsfh *fh, - uint64_t length, nfs_cb cb, void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob3.val = malloc(12); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob3.free = free; - - memset(data->filler.blob3.val, 0, 12); - length = nfs_hton64(length); - memcpy(data->filler.blob3.val, &length, sizeof(uint64_t)); - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_truncate(nfs, &op[i], fh, data->filler.blob3.val); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_fsync_cb, &args, - data) != 0) { - data->filler.blob0.val = NULL; - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_lseek_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETATTR4resok *garesok = NULL; - struct nfsfh *fh = data->filler.blob0.val; - struct nfs_stat_64 st; - int64_t offset; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - memcpy(&offset, data->filler.blob1.val, sizeof(int64_t)); - - if (check_nfs4_error(nfs, status, data, res, "LSEEK")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETATTR, "GETATTR")) < 0) { - return; - } - garesok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetattr.GETATTR4res_u.resok4; - - memset(&st, 0, sizeof(st)); - nfs_parse_attributes(nfs, data, &st, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len); - - if (offset < 0 && - -offset > (int64_t)st.nfs_size) { - nfs_set_error(nfs, "Negative offset for lseek(" - "SEET_END)"); - data->cb(-EINVAL, nfs, &fh->offset, - data->private_data); - } else { - fh->offset = offset + st.nfs_size; - data->cb(0, nfs, &fh->offset, data->private_data); - } - - free_nfs4_cb_data(data); -} - -/* blob0.val is nfsfh - * blob1.val is offset - */ -int -nfs4_lseek_async(struct nfs_context *nfs, struct nfsfh *fh, int64_t offset, - int whence, nfs_cb cb, void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - if (whence == SEEK_SET) { - if (offset < 0) { - nfs_set_error(nfs, "Negative offset for lseek(" - "SEET_SET)"); - cb(-EINVAL, nfs, &fh->offset, private_data); - } else { - fh->offset = offset; - cb(0, nfs, &fh->offset, private_data); - } - return 0; - } - if (whence == SEEK_CUR) { - if (offset < 0 && - fh->offset < (uint64_t)(-offset)) { - nfs_set_error(nfs, "Negative offset for lseek(" - "SEET_CUR)"); - cb(-EINVAL, nfs, &fh->offset, private_data); - } else { - fh->offset += offset; - cb(0, nfs, &fh->offset, private_data); - } - return 0; - } - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob0.val = fh; - data->filler.blob0.free = NULL; - - data->filler.blob1.val = malloc(sizeof(uint64_t)); - if (data->filler.blob1.val == NULL) { - nfs_set_error(nfs, "Out of memory."); - free_nfs4_cb_data(data); - return -1; - } - memcpy(data->filler.blob1.val, &offset, sizeof(uint64_t)); - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_getattr(nfs, &op[i], standard_attributes, 2); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_lseek_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_lockf_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - LOCK4resok *lresok = NULL; - LOCKU4res *lures = NULL; - struct nfsfh *fh = data->filler.blob0.val; - enum nfs4_lock_op cmd; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - cmd = data->filler.blob1.len; - - if (check_nfs4_error(nfs, status, data, res, "LOCKF")) { - return; - } - - switch (cmd) { - case NFS4_F_LOCK: - case NFS4_F_TLOCK: - if ((i = nfs4_find_op(nfs, data, res, OP_LOCK, "LOCK")) < 0) { - return; - } - - lresok = &res->resarray.resarray_val[i].nfs_resop4_u.oplock.LOCK4res_u.resok4; - nfs->has_lock_owner = 1; - fh->lock_stateid.seqid = lresok->lock_stateid.seqid; - memcpy(fh->lock_stateid.other, lresok->lock_stateid.other, 12); - break; - case NFS4_F_ULOCK: - if ((i = nfs4_find_op(nfs, data, res, OP_LOCKU, "LOCKU")) < 0) { - return; - } - lures = &res->resarray.resarray_val[i].nfs_resop4_u.oplocku; - fh->lock_stateid.seqid = lures->LOCKU4res_u.lock_stateid.seqid; - memcpy(fh->lock_stateid.other, - lures->LOCKU4res_u.lock_stateid.other, 12); - break; - case NFS4_F_TEST: - break; - } - - data->cb(0, nfs, NULL, data->private_data); - - free_nfs4_cb_data(data); -} - -/* blob0.val is nfsfh - * blob1.len is cmd - */ -int -nfs4_lockf_async(struct nfs_context *nfs, struct nfsfh *fh, - enum nfs4_lock_op cmd, uint64_t count, - nfs_cb cb, void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob0.val = fh; - data->filler.blob0.free = NULL; - - data->filler.blob1.len = cmd; - - i = nfs4_op_putfh(nfs, &op[0], fh); - switch (cmd) { - case NFS4_F_LOCK: - i += nfs4_op_lock(nfs, &op[i], fh, OP_LOCK, WRITEW_LT, - 0, fh->offset, count); - break; - case NFS4_F_TLOCK: - i += nfs4_op_lock(nfs, &op[i], fh, OP_LOCK, WRITE_LT, - 0, fh->offset, count); - break; - case NFS4_F_ULOCK: - i += nfs4_op_locku(nfs, &op[i], fh, WRITE_LT, - fh->offset, count); - break; - case NFS4_F_TEST: - i += nfs4_op_lockt(nfs, &op[i], fh, WRITEW_LT, - fh->offset, count); - break; - } - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_lockf_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_fcntl_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - LOCK4resok *lresok = NULL; - struct nfsfh *fh = data->filler.blob0.val; - enum nfs4_fcntl_op cmd; - struct nfs4_flock *fl; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - cmd = data->filler.blob1.len; - - if (check_nfs4_error(nfs, status, data, res, "FCNTL")) { - return; - } - - switch (cmd) { - case NFS4_F_SETLK: - case NFS4_F_SETLKW: - fl = (struct nfs4_flock *)data->filler.blob1.val; - - switch (fl->l_type) { - case F_RDLCK: - case F_WRLCK: - if ((i = nfs4_find_op(nfs, data, res, OP_LOCK, - "LOCK")) < 0) { - return; - } - - lresok = &res->resarray.resarray_val[i].nfs_resop4_u.oplock.LOCK4res_u.resok4; - nfs->has_lock_owner = 1; - fh->lock_stateid.seqid = lresok->lock_stateid.seqid; - memcpy(fh->lock_stateid.other, - lresok->lock_stateid.other, 12); - break; - case F_UNLCK: - if ((i = nfs4_find_op(nfs, data, res, OP_LOCKU, - "UNLOCK")) < 0) { - return; - } - break; - } - break; - } - - data->cb(0, nfs, NULL, data->private_data); - - free_nfs4_cb_data(data); -} - -static int -nfs4_fcntl_async_internal(struct nfs_context *nfs, struct nfsfh *fh, - struct nfs4_cb_data *data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_flock *fl; - enum nfs4_fcntl_op cmd; - int i, lock_type; - - cmd = data->filler.blob1.len; - - i = nfs4_op_putfh(nfs, &op[0], fh); - switch (cmd) { - case NFS4_F_SETLK: - case NFS4_F_SETLKW: - fl = data->filler.blob1.val; - - switch (fl->l_type) { - case F_RDLCK: - lock_type = cmd == NFS4_F_SETLK ? READ_LT : READW_LT; - i += nfs4_op_lock(nfs, &op[i], fh, OP_LOCK, lock_type, - 0, fl->l_start, fl->l_len); - break; - case F_WRLCK: - lock_type = cmd == NFS4_F_SETLK ? WRITE_LT : WRITEW_LT; - i += nfs4_op_lock(nfs, &op[i], fh, OP_LOCK, lock_type, - 0, fl->l_start, fl->l_len); - break; - case F_UNLCK: - i += nfs4_op_locku(nfs, &op[i], fh, WRITE_LT, - fl->l_start, fl->l_len); - break; - } - break; - } - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_fcntl_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_fcntl_stat_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - enum nfs4_fcntl_op cmd = data->filler.blob1.len; - COMPOUND4res *res = command_data; - GETATTR4resok *garesok; - struct nfs4_flock *fl; - struct nfs_stat_64 st; - int i; - - if (check_nfs4_error(nfs, status, data, res, "STAT64")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_GETATTR, "GETATTR")) < 0) { - return; - } - garesok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetattr.GETATTR4res_u.resok4; - memset(&st, 0, sizeof(st)); - if (nfs_parse_attributes(nfs, data, &st, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len) < 0) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - } - - switch (cmd) { - case NFS4_F_SETLK: - case NFS4_F_SETLKW: - fl = data->filler.blob1.val; - - fl->l_whence = SEEK_SET; - fl->l_start = st.nfs_size + fl->l_start; - if (nfs4_fcntl_async_internal(nfs, fh, data)) { - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), - data->private_data); - free_nfs4_cb_data(data); - } - } -} - -/* blob0.val is nfsfh - * blob1.len is cmd - * blob1.val is arg - */ -int -nfs4_fcntl_async(struct nfs_context *nfs, struct nfsfh *fh, - enum nfs4_fcntl_op cmd, void *arg, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - struct nfs4_flock *fl; - COMPOUND4args args; - nfs_argop4 op[2]; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob0.val = fh; - data->filler.blob0.free = NULL; - - data->filler.blob1.len = cmd; - data->filler.blob1.val = arg; - data->filler.blob1.free = NULL; - - switch (cmd) { - case NFS4_F_SETLK: - case NFS4_F_SETLKW: - fl = arg; - switch (fl->l_whence) { - case SEEK_SET: - return nfs4_fcntl_async_internal(nfs, fh, data); - case SEEK_CUR: - fl->l_whence = SEEK_SET; - fl->l_start = fh->offset + fl->l_start; - return nfs4_fcntl_async_internal(nfs, fh, data); - case SEEK_END: - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_getattr(nfs, &op[i], standard_attributes, - 2); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, - nfs4_fcntl_stat_cb, - &args, data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - return 0; - } - nfs_set_error(nfs, "fcntl: unknown fl->whence:%d\n", - fl->l_whence); - free_nfs4_cb_data(data); - return -1; - } - nfs_set_error(nfs, "fcntl: unknown cmd:%d\n", cmd); - free_nfs4_cb_data(data); - return -1; -} - -static int -nfs_parse_statvfs(struct nfs_context *nfs, struct nfs4_cb_data *data, - struct statvfs *svfs, const char *buf, int len) -{ - uint64_t u64; - uint32_t u32; - - svfs->f_bsize = NFS_BLKSIZE; - svfs->f_frsize = NFS_BLKSIZE; - -#if !defined(__ANDROID__) - svfs->f_flag = 0; -#endif - - /* FSID - * NFSv4 FSID is 2*64 bit but statvfs fsid is just an - * unsigmed long. Mix the 2*64 bits and hope for the best. - */ - CHECK_GETATTR_BUF_SPACE(len, 16); - memcpy(&u64, buf, 8); - svfs->f_fsid = (unsigned long)nfs_ntoh64(u64); - buf += 8; - len -= 8; - memcpy(&u64, buf, 8); - svfs->f_fsid |= (unsigned long)nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Files Avail */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); -#if !defined(__ANDROID__) - svfs->f_favail = (fsfilcnt_t)nfs_ntoh64(u64); -#endif - buf += 8; - len -= 8; - - /* Files Free */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs->f_ffree = (fsfilcnt_t)nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Files Total */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs->f_files = (fsfilcnt_t)nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Max Name */ - CHECK_GETATTR_BUF_SPACE(len, 4); - memcpy(&u32, buf, 4); -#if !defined(__ANDROID__) - svfs->f_namemax = ntohl(u32); -#endif - buf += 4; - len -= 4; - - /* Space Avail */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs->f_bavail = (fsblkcnt_t)(nfs_ntoh64(u64) / svfs->f_frsize); - buf += 8; - len -= 8; - - /* Space Free */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs->f_bfree = (fsblkcnt_t)(nfs_ntoh64(u64) / svfs->f_frsize); - buf += 8; - len -= 8; - - /* Space Total */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs->f_blocks = (fsblkcnt_t)(nfs_ntoh64(u64) / svfs->f_frsize); - buf += 8; - len -= 8; - - return 0; -} - -static int -nfs_parse_statvfs64(struct nfs_context *nfs, struct nfs4_cb_data *data, - struct nfs_statvfs_64 *svfs64, const char *buf, int len) -{ - uint64_t u64; - uint32_t u32; - - svfs64->f_bsize = NFS_BLKSIZE; - svfs64->f_frsize = NFS_BLKSIZE; - svfs64->f_flag = 0; - - /* FSID - * NFSv4 FSID is 2*64 bit but statvfs fsid is just an - * unsigmed long. Mix the 2*64 bits and hope for the best. - */ - CHECK_GETATTR_BUF_SPACE(len, 16); - memcpy(&u64, buf, 8); - svfs64->f_fsid = nfs_ntoh64(u64); - buf += 8; - len -= 8; - memcpy(&u64, buf, 8); - svfs64->f_fsid |= nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Files Avail */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs64->f_favail = nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Files Free */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs64->f_ffree = nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Files Total */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs64->f_files = nfs_ntoh64(u64); - buf += 8; - len -= 8; - - /* Max Name */ - CHECK_GETATTR_BUF_SPACE(len, 4); - memcpy(&u32, buf, 4); - svfs64->f_namemax = ntohl(u32); - buf += 4; - len -= 4; - - /* Space Avail */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs64->f_bavail = nfs_ntoh64(u64) / svfs64->f_frsize; - buf += 8; - len -= 8; - - /* Space Free */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs64->f_bfree = nfs_ntoh64(u64) / svfs64->f_frsize; - buf += 8; - len -= 8; - - /* Space Total */ - CHECK_GETATTR_BUF_SPACE(len, 8); - memcpy(&u64, buf, 8); - svfs64->f_blocks = nfs_ntoh64(u64) / svfs64->f_frsize; - buf += 8; - len -= 8; - - return 0; -} - -static void -nfs4_statvfs_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - GETATTR4resok *garesok; - struct statvfs svfs; - struct nfs_statvfs_64 svfs64; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "STATVFS")) { - return; - } - - memset(&svfs, 0, sizeof(svfs)); - memset(&svfs64, 0, sizeof(svfs64)); - - if ((i = nfs4_find_op(nfs, data, res, OP_GETATTR, "GETATTR")) < 0) { - return; - } - garesok = &res->resarray.resarray_val[i].nfs_resop4_u.opgetattr.GETATTR4res_u.resok4; - - if (data->flags & LOOKUP_FLAG_IS_STATVFS64) { - /* statvfs64 */ - if (nfs_parse_statvfs64(nfs, data, &svfs64, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len) < 0) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - - data->cb(0, nfs, &svfs64, data->private_data); - } else { - /* statvfs */ - if (nfs_parse_statvfs(nfs, data, &svfs, - garesok->obj_attributes.attr_vals.attrlist4_val, - garesok->obj_attributes.attr_vals.attrlist4_len) < 0) { - data->cb(-EINVAL, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } - - data->cb(0, nfs, &svfs, data->private_data); - } - - free_nfs4_cb_data(data); -} - -static int -nfs4_statvfs_async_internal(struct nfs_context *nfs, const char *path, - int is_statvfs64, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - COMPOUND4args args; - struct nfsfh fh; - nfs_argop4 op[2]; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - if (is_statvfs64) { - data->flags |= LOOKUP_FLAG_IS_STATVFS64; - } - - fh.fh.len = nfs->rootfh.len; - fh.fh.val = nfs->rootfh.val; - - i = nfs4_op_putfh(nfs, &op[0], &fh); - i += nfs4_op_getattr(nfs, &op[i], statvfs_attributes, 2); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_statvfs_cb, &args, - data) != 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -int -nfs4_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - return nfs4_statvfs_async_internal(nfs, path, 0, - cb, private_data); -} - -int -nfs4_statvfs64_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - return nfs4_statvfs_async_internal(nfs, path, 1, - cb, private_data); -} - -static void -nfs4_chmod_open_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[4]; - int i; - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_chmod(nfs, &op[i], fh, data->filler.blob3.val); - i += nfs4_op_close(nfs, &op[i], fh); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_close_cb, &args, - data) != 0) { - /* Not much we can do but leak one fd on the server :( */ - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -int -nfs4_chmod_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int mode, nfs_cb cb, - void *private_data) -{ - struct nfs4_cb_data *data; - uint32_t m; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->open_cb = nfs4_chmod_open_cb; - - if (no_follow) { - data->flags |= LOOKUP_FLAG_NO_FOLLOW; - } - - data->filler.blob3.val = malloc(sizeof(uint32_t)); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob3.free = free; - - m = htonl(mode); - memcpy(data->filler.blob3.val, &m, sizeof(uint32_t)); - - if (nfs4_open_async_internal(nfs, data, O_WRONLY, 0) < 0) { - return -1; - } - - return 0; -} - -int -nfs4_fchmod_async(struct nfs_context *nfs, struct nfsfh *fh, int mode, - nfs_cb cb, void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - uint32_t m; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - data->filler.blob3.val = malloc(sizeof(uint32_t)); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - free_nfs4_cb_data(data); - return -1; - } - data->filler.blob3.free = free; - - m = htonl(mode); - memcpy(data->filler.blob3.val, &m, sizeof(uint32_t)); - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_chmod(nfs, &op[i], fh, data->filler.blob3.val); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_fsync_cb, &args, - data) != 0) { - data->filler.blob0.val = NULL; - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -#define CHOWN_BLOB_SIZE 64 -static int -nfs4_create_chown_buffer(struct nfs_context *nfs, struct nfs4_cb_data *data, - int uid, int gid) -{ - char *str; - int i, l; - uint32_t len; - - data->filler.blob3.val = malloc(CHOWN_BLOB_SIZE); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - return -1; - } - data->filler.blob3.free = free; - memset(data->filler.blob3.val, 0, CHOWN_BLOB_SIZE); - - i = 0; - str = data->filler.blob3.val; - /* UID */ - l = snprintf(&str[i + 4], CHOWN_BLOB_SIZE - 4 - i, - "%d", uid); - if (l < 0) { - nfs_set_error(nfs, "snprintf failed"); - return -1; - } - len = htonl(l); - /* UID length prefix */ - memcpy(&str[i], &len, sizeof(uint32_t)); - i += 4 + l; - i = (i + 3) & ~0x03; - - /* GID */ - l = snprintf(&str[i + 4], CHOWN_BLOB_SIZE - 4 - i, - "%d", gid); - if (l < 0) { - nfs_set_error(nfs, "snprintf failed"); - return -1; - } - len = htonl(l); - /* GID length prefix */ - memcpy(&str[i], &len, sizeof(uint32_t)); - i += 4 + l; - i = (i + 3) & ~0x03; - - data->filler.blob3.len = i; - - return 0; -} - -static void -nfs4_chown_open_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[4]; - int i; - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_chown(nfs, &op[i], fh, data->filler.blob3.val, - data->filler.blob3.len); - i += nfs4_op_close(nfs, &op[i], fh); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_close_cb, &args, - data) != 0) { - /* Not much we can do but leak one fd on the server :( */ - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -int -nfs4_chown_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, int uid, int gid, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->open_cb = nfs4_chown_open_cb; - - if (no_follow) { - data->flags |= LOOKUP_FLAG_NO_FOLLOW; - } - - if (nfs4_create_chown_buffer(nfs, data, uid, gid) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - if (nfs4_open_async_internal(nfs, data, O_WRONLY, 0) < 0) { - return -1; - } - - return 0; -} - -int -nfs4_fchown_async(struct nfs_context *nfs, struct nfsfh *fh, int uid, int gid, - nfs_cb cb, void *private_data) -{ - COMPOUND4args args; - nfs_argop4 op[2]; - struct nfs4_cb_data *data; - int i; - - data = malloc(sizeof(*data)); - if (data == NULL) { - nfs_set_error(nfs, "Out of memory."); - return -1; - } - memset(data, 0, sizeof(*data)); - - data->nfs = nfs; - data->cb = cb; - data->private_data = private_data; - - if (nfs4_create_chown_buffer(nfs, data, uid, gid) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - memset(op, 0, sizeof(op)); - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_chown(nfs, &op[i], fh, data->filler.blob3.val, - data->filler.blob3.len); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_fsync_cb, &args, - data) != 0) { - data->filler.blob0.val = NULL; - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -static void -nfs4_access_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - COMPOUND4res *res = command_data; - ACCESS4resok *aresok; - int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (check_nfs4_error(nfs, status, data, res, "ACCESS")) { - return; - } - - if ((i = nfs4_find_op(nfs, data, res, OP_ACCESS, "ACCESS")) < 0) { - return; - } - - aresok = &res->resarray.resarray_val[i].nfs_resop4_u.opaccess.ACCESS4res_u.resok4; - - /* access2 */ - if (data->filler.flags) { - int mode = 0; - - if (aresok->access & ACCESS4_READ) { - mode |= R_OK; - } - if (aresok->access & ACCESS4_MODIFY) { - mode |= W_OK; - } - if (aresok->access & ACCESS4_EXECUTE) { - mode |= X_OK; - } - data->cb(mode, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); - return; - } - - if (aresok->supported != aresok->access) { - data->cb(-EACCES, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); - return; - } - - data->cb(0, nfs, NULL, data->private_data); - free_nfs4_cb_data(data); -} - -static int -nfs4_access_internal(struct nfs_context *nfs, const char *path, int mode, - int is_access2, nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - uint32_t m; - - data = init_cb_data_full_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->filler.func = nfs4_populate_access; - data->filler.max_op = 1; - data->filler.flags = is_access2; - - data->filler.blob3.val = malloc(sizeof(uint32_t)); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - return -1; - } - data->filler.blob3.free = free; - - m = 0; - if (mode & R_OK) { - m |= ACCESS4_READ; - } - if (mode & W_OK) { - m |= ACCESS4_MODIFY; - } - if (mode & X_OK) { - m |= ACCESS4_EXECUTE; - } - memcpy(data->filler.blob3.val, &m, sizeof(uint32_t)); - - if (nfs4_lookup_path_async(nfs, data, nfs4_access_cb) < 0) { - free_nfs4_cb_data(data); - return -1; - } - - return 0; -} - -int -nfs4_access_async(struct nfs_context *nfs, const char *path, int mode, - nfs_cb cb, void *private_data) -{ - return nfs4_access_internal(nfs, path, mode, 0, - cb, private_data); -} - -int -nfs4_access2_async(struct nfs_context *nfs, const char *path, nfs_cb cb, - void *private_data) -{ - return nfs4_access_internal(nfs, path, R_OK|W_OK|X_OK, 1, - cb, private_data); -} - -static void -nfs4_utimes_open_cb(struct rpc_context *rpc, int status, void *command_data, - void *private_data) -{ - struct nfs4_cb_data *data = private_data; - struct nfs_context *nfs = data->nfs; - struct nfsfh *fh = data->filler.blob0.val; - COMPOUND4res *res = command_data; - COMPOUND4args args; - nfs_argop4 op[4]; - int i; - - if (check_nfs4_error(nfs, status, data, res, "OPEN")) { - return; - } - - i = nfs4_op_putfh(nfs, &op[0], fh); - i += nfs4_op_utimes(nfs, &op[i], fh, data->filler.blob3.val, - data->filler.blob3.len); - i += nfs4_op_close(nfs, &op[i], fh); - - memset(&args, 0, sizeof(args)); - args.argarray.argarray_len = i; - args.argarray.argarray_val = op; - - if (rpc_nfs4_compound_async(nfs->rpc, nfs4_close_cb, &args, - data) != 0) { - /* Not much we can do but leak one fd on the server :( */ - data->cb(-ENOMEM, nfs, nfs_get_error(nfs), data->private_data); - free_nfs4_cb_data(data); - return; - } -} - -int -nfs4_utimes_async_internal(struct nfs_context *nfs, const char *path, - int no_follow, struct timeval *times, - nfs_cb cb, void *private_data) -{ - struct nfs4_cb_data *data; - char *buf; - uint32_t u32; - uint64_t u64; - - data = init_cb_data_split_path(nfs, path); - if (data == NULL) { - return -1; - } - - data->cb = cb; - data->private_data = private_data; - data->open_cb = nfs4_utimes_open_cb; - - if (no_follow) { - data->flags |= LOOKUP_FLAG_NO_FOLLOW; - } - - data->filler.blob3.len = 2 * (4 + 8 + 4); - buf = data->filler.blob3.val = malloc(data->filler.blob3.len); - if (data->filler.blob3.val == NULL) { - nfs_set_error(nfs, "Out of memory"); - return -1; - } - data->filler.blob3.free = free; - - /* atime */ - u32 = htonl(SET_TO_CLIENT_TIME4); - memcpy(buf, &u32, sizeof(uint32_t)); - u64 = nfs_hton64(times[0].tv_sec); - memcpy(buf + 4, &u64, sizeof(uint64_t)); - u32 = htonl(times[0].tv_usec * 1000); - memcpy(buf + 12, &u32, sizeof(uint32_t)); - buf += 16; - /* mtime */ - u32 = htonl(SET_TO_CLIENT_TIME4); - memcpy(buf, &u32, sizeof(uint32_t)); - u64 = nfs_hton64(times[1].tv_sec); - memcpy(buf + 4, &u64, sizeof(uint64_t)); - u32 = htonl(times[1].tv_usec * 1000); - memcpy(buf + 12, &u32, sizeof(uint32_t)); - - if (nfs4_open_async_internal(nfs, data, O_WRONLY, 0) < 0) { - return -1; - } - - return 0; -} - -int -nfs4_utime_async(struct nfs_context *nfs, const char *path, - struct utimbuf *times, nfs_cb cb, void *private_data) -{ - struct timeval new_times[2]; - - new_times[0].tv_sec = times->actime; - new_times[0].tv_usec = 0; - new_times[1].tv_sec = times->modtime; - new_times[1].tv_usec = 0; - - return nfs4_utimes_async_internal(nfs, path, 0, new_times, - cb, private_data); -} diff --git a/source/liborbisNfs/nfsacl.c b/source/liborbisNfs/nfsacl.c deleted file mode 100644 index 81f6c20..0000000 --- a/source/liborbisNfs/nfsacl.c +++ /dev/null @@ -1,98 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -#ifdef WIN32 -#include -#else -#include -#endif/*WIN32*/ - -#include -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-nfs.h" - - -int rpc_nfsacl_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFSACL_PROGRAM, NFSACL_V3, NFSACL3_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfsacl/null call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfsacl/null call"); - return -2; - } - - return 0; -} - - -int rpc_nfsacl_getacl_async(struct rpc_context *rpc, rpc_cb cb, struct GETACL3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFSACL_PROGRAM, NFSACL_V3, NFSACL3_GETACL, cb, private_data, (zdrproc_t)zdr_GETACL3res, sizeof(GETACL3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfsacl/getacl call"); - return -1; - } - - if (zdr_GETACL3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETACL3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfsacl/getacl call"); - return -2; - } - - return 0; -} - -int rpc_nfsacl_setacl_async(struct rpc_context *rpc, rpc_cb cb, struct SETACL3args *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NFSACL_PROGRAM, NFSACL_V3, NFSACL3_SETACL, cb, private_data, (zdrproc_t)zdr_SETACL3res, sizeof(SETACL3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfsacl/setacl call"); - return -1; - } - - if (zdr_SETACL3args(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode SETACL3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfsacl/setacl call"); - return -2; - } - - return 0; -} diff --git a/source/liborbisNfs/nlm.c b/source/liborbisNfs/nlm.c deleted file mode 100644 index efa34b8..0000000 --- a/source/liborbisNfs/nlm.c +++ /dev/null @@ -1,166 +0,0 @@ -/* - Copyright (C) 2012 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifdef WIN32 -#include -#endif/*WIN32*/ - -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-nlm.h" - -int rpc_nlm4_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NLM_PROGRAM, NLM_V4, NLM4_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nlm/null call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nlm/null call"); - return -1; - } - - return 0; -} - -int rpc_nlm4_test_async(struct rpc_context *rpc, rpc_cb cb, struct NLM4_TESTargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NLM_PROGRAM, NLM_V4, NLM4_TEST, cb, private_data, (zdrproc_t)zdr_NLM4_TESTres, sizeof(NLM4_TESTres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nlm/test call"); - return -1; - } - - if (zdr_NLM4_TESTargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NLM4_TESTargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nlm/test call"); - return -1; - } - - return 0; -} - -int rpc_nlm4_lock_async(struct rpc_context *rpc, rpc_cb cb, struct NLM4_LOCKargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NLM_PROGRAM, NLM_V4, NLM4_LOCK, cb, private_data, (zdrproc_t)zdr_NLM4_LOCKres, sizeof(NLM4_LOCKres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nlm/lock call"); - return -1; - } - - if (zdr_NLM4_LOCKargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NLM4_LOCKargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nlm/lock call"); - return -1; - } - - return 0; -} - -int rpc_nlm4_cancel_async(struct rpc_context *rpc, rpc_cb cb, struct NLM4_CANCargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NLM_PROGRAM, NLM_V4, NLM4_CANCEL, cb, private_data, (zdrproc_t)zdr_NLM4_CANCres, sizeof(NLM4_CANCres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nlm/cancel call"); - return -1; - } - - if (zdr_NLM4_CANCargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NLM4_CANCargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nlm/cancel call"); - return -1; - } - - return 0; -} - -int rpc_nlm4_unlock_async(struct rpc_context *rpc, rpc_cb cb, struct NLM4_UNLOCKargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NLM_PROGRAM, NLM_V4, NLM4_UNLOCK, cb, private_data, (zdrproc_t)zdr_NLM4_UNLOCKres, sizeof(NLM4_UNLOCKres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nlm/unlock call"); - return -1; - } - - if (zdr_NLM4_UNLOCKargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NLM4_UNLOCKargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nlm/unlock call"); - return -1; - } - - return 0; -} - -char *nlmstat4_to_str(int st) -{ - enum nlmstat4 stat = st; - - char *str = "unknown nlm stat"; - switch (stat) { - case NLM4_GRANTED: str="NLM4_GRANTED";break; - case NLM4_DENIED: str="NLM4_DENIED";break; - case NLM4_DENIED_NOLOCKS: str="NLM4_DENIED_NOLOCKS";break; - case NLM4_BLOCKED: str="NLM4_BLOCKED";break; - case NLM4_DENIED_GRACE_PERIOD: str="NLM4_DENIED_GRACE_PERIOD";break; - case NLM4_DEADLCK: str="NLM4_DEADLCK";break; - case NLM4_ROFS: str="NLM4_ROFS";break; - case NLM4_STALE_FH: str="NLM4_STALE_FH";break; - case NLM4_FBIG: str="NLM4_FBIG";break; - case NLM4_FAILED: str="NLM4_FAILED";break; - } - return str; -} - - - - diff --git a/source/liborbisNfs/nsm.c b/source/liborbisNfs/nsm.c deleted file mode 100644 index a7e019a..0000000 --- a/source/liborbisNfs/nsm.c +++ /dev/null @@ -1,196 +0,0 @@ -/* - Copyright (C) 2013 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ - -#ifdef WIN32 -#include -#endif/*WIN32*/ - -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-nsm.h" - -int rpc_nsm1_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/null call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/null call"); - return -1; - } - - return 0; -} - -int rpc_nsm1_stat_async(struct rpc_context *rpc, rpc_cb cb, struct NSM1_STATargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_STAT, cb, private_data, (zdrproc_t)zdr_NSM1_STATres, sizeof(NSM1_STATres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/stat call"); - return -1; - } - - if (zdr_NSM1_STATargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NSM1_STATargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/stat call"); - return -1; - } - - return 0; -} - -int rpc_nsm1_mon_async(struct rpc_context *rpc, rpc_cb cb, struct NSM1_MONargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_MON, cb, private_data, (zdrproc_t)zdr_NSM1_MONres, sizeof(NSM1_MONres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/mon call"); - return -1; - } - - if (zdr_NSM1_MONargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NSM1_MONargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/mon call"); - return -1; - } - - return 0; -} - -int rpc_nsm1_unmon_async(struct rpc_context *rpc, rpc_cb cb, struct NSM1_UNMONargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_UNMON, cb, private_data, (zdrproc_t)zdr_NSM1_UNMONres, sizeof(NSM1_UNMONres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/unmon call"); - return -1; - } - - if (zdr_NSM1_UNMONargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NSM1_UNMONargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/unmon call"); - return -1; - } - - return 0; -} - -int rpc_nsm1_unmonall_async(struct rpc_context *rpc, rpc_cb cb, struct NSM1_UNMONALLargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_UNMON_ALL, cb, private_data, (zdrproc_t)zdr_NSM1_UNMONALLres, sizeof(NSM1_UNMONALLres)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/unmonall call"); - return -1; - } - - if (zdr_NSM1_UNMONALLargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NSM1_UNMONALLargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/unmonall call"); - return -1; - } - - return 0; -} - -int rpc_nsm1_simucrash_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_SIMU_CRASH, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/simucrash call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/simucrash call"); - return -1; - } - - return 0; -} - -int rpc_nsm1_notify_async(struct rpc_context *rpc, rpc_cb cb, struct NSM1_NOTIFYargs *args, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, NSM_PROGRAM, NSM_V1, NSM1_NOTIFY, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nsm/notify call"); - return -1; - } - - if (zdr_NSM1_NOTIFYargs(&pdu->zdr, args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode NSM1_NOTIFYargs"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nsm/notify call"); - return -1; - } - - return 0; -} - -char *nsmstat1_to_str(int st) -{ - enum nsmstat1 stat = st; - - char *str = "unknown n1m stat"; - switch (stat) { - case NSM_STAT_SUCC: str="NSM_STAT_SUCC";break; - case NSM_STAT_FAIL: str="NSM_STAT_FAIL";break; - } - return str; -} diff --git a/source/liborbisNfs/orbisNfs.c b/source/liborbisNfs/orbisNfs.c deleted file mode 100644 index 7e68b16..0000000 --- a/source/liborbisNfs/orbisNfs.c +++ /dev/null @@ -1,1136 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#define DEBUG DEBUGNET_DEBUG -#define ERROR DEBUGNET_ERROR - -OrbisNfsConfig *orbisNfsConf=NULL; - -int orbisnfs_external_conf=-1; - -size_t _orbisNfs_lastopenFile_size; - -ExtensionTypes myextensionTypes[] = { - { ".ROM", FILE_TYPE_ROM }, - { ".DSK", FILE_TYPE_DSK }, - { ".CAS", FILE_TYPE_CAS }, - -}; -char *mydevices[] = { - "nfs:", -}; -int orbisNfsCheckSlotByFd(int fd) -{ - if(fd<0 || !orbisNfsConf) - { - return -1; - } - int i = 0; - int slot = -1; - - // search slot - for(i=0;iopenDescriptors[i]==fd) - { - slot=i; - break; - } - } - return slot; -} - -int orbisNfsCheckFreeDescriptor() -{ - int i=0; - int slot=-1; - // search slot - for (i=0;iopenDescriptors[i]==-1) - { - slot = i; - break; - } - } - return slot; -} - -int orbisNfsOpen(const char *file, int flags, int mode) -{ - int ret; - int slot; - debugNetPrintf(DEBUG,"[ORBISNFS] %s opening file %s\n",__FUNCTION__,file); - - if(!file || !orbisNfsConf) - { - return 0x80020016; - } - - slot=orbisNfsCheckFreeDescriptor(); - if(slot>=0) - { - if(orbisNfsConf && orbisNfsConf->openEntries[slot]) - { - ret=nfs_open2(orbisNfsConf->nfsHandle,file,flags,mode,&orbisNfsConf->openEntries[slot]->fileHandle); - if(ret==0) - { - orbisNfsConf->openDescriptors[slot]=orbisNfsConf->openEntries[slot]->fd; - strncpy(orbisNfsConf->openEntries[slot]->path,file,strlen(file)); - debugNetPrintf(DEBUG,"[ORBISNFS] %s %s opened fd=%d\n",__FUNCTION__,orbisNfsConf->openEntries[slot]->path,orbisNfsConf->openEntries[slot]->fd); - return orbisNfsConf->openEntries[slot]->fd; - } - else - { - if(orbisNfsConf->openEntries[slot]->fileHandle) - { - free(orbisNfsConf->openEntries[slot]->fileHandle); - orbisNfsConf->openEntries[slot]->fileHandle=NULL; - } - debugNetPrintf(ERROR,"[ORBISNFS] %s unable to open file %s ret=%d %s\n",__FUNCTION__,file,ret,nfs_get_error(orbisNfsConf->nfsHandle)); - return 0x80020016; - } - } - } - debugNetPrintf(ERROR,"[ORBISNFS] %s no free slot available\n",__FUNCTION__); - return 0x80020016; - -} -int orbisNfsClose(int fd) -{ - int ret=0; - int slot=-1; - debugNetPrintf(DEBUG,"[ORBISNFS] %s closing fd %d\n",__FUNCTION__,fd); - - if(fd<0) - { - return 0x80020009; - } - slot=orbisNfsCheckSlotByFd(fd); - if(slot>=0) - { - //debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d\n",__FUNCTION__,slot,fd); - if(orbisNfsConf->nfsHandle && orbisNfsConf->openEntries[slot]->fileHandle) - { - ret=nfs_close(orbisNfsConf->nfsHandle,orbisNfsConf->openEntries[slot]->fileHandle); - if(ret==0) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d %s closed\n",__FUNCTION__,slot,fd,orbisNfsConf->openEntries[slot]->path); - } - else - { - debugNetPrintf(ERROR,"[ORBISNFS] %s slot=%d fd=%d closing file %s ret=%d %s\n",__FUNCTION__,slot,fd,orbisNfsConf->openEntries[slot]->path,ret,nfs_get_error(orbisNfsConf->nfsHandle)); - } - - orbisNfsConf->openEntries[slot]->fileHandle=NULL; - - orbisNfsConf->openDescriptors[slot]=-1; - memset(orbisNfsConf->openEntries[slot]->path,0,255); - - return 0; - } - } - return 0x80020009; -} - -int orbisNfsRead(int fd,void *data,size_t size) -{ - int ret; - int slot=-1; - debugNetPrintf(DEBUG,"[ORBISNFS] %s fd=%d size=%d\n",__FUNCTION__,fd,size); - - if(fd<0 || !orbisNfsConf) - { - return 0x80020009; - } - if(!data) - { - return 0x8002000e; - } - slot=orbisNfsCheckSlotByFd(fd); - if(slot>=0) - { - if(orbisNfsConf->nfsHandle && orbisNfsConf->openEntries[slot]->fileHandle) - { - ret=nfs_read(orbisNfsConf->nfsHandle,orbisNfsConf->openEntries[slot]->fileHandle,size,(unsigned char *)data); - if(ret>=0) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d bytereads=%d\n",__FUNCTION__,slot,fd,ret); - return ret; - } - else - { - debugNetPrintf(ERROR,"[ORBISNFS] %s slot=%d fd=%d error=%d %s\n",__FUNCTION__,slot,fd,ret,nfs_get_error(orbisNfsConf->nfsHandle)); - } - return 0x80020005; - } - } - return 0x80020009; -} - -int orbisNfsWrite(int fd, const void *data, size_t size) -{ - int slot=-1; - debugNetPrintf(DEBUG,"[ORBISNFS] %s fd=%d size=%d\n",__FUNCTION__,fd,size); - ssize_t numberOfBytesWritten = 0; - ssize_t writtenBytes = 0; - size_t leftBytes = size; - if(fd<0 || !orbisNfsConf) - { - return 0x80020009; - } - if(!data) - { - return 0x8002000e; - } - slot=orbisNfsCheckSlotByFd(fd); - if(slot>=0) - { - - if(orbisNfsConf->nfsHandle && orbisNfsConf->openEntries[slot]->fileHandle) - { - size_t chunkSize = orbisNfsConf->writeChunkSize > 32768 ? 32768 : orbisNfsConf->writeChunkSize; - while(leftBytes) - { - if(leftBytes < chunkSize) - { - chunkSize=leftBytes;//write last chunk with correct size - } - //write chunk - writtenBytes=nfs_write(orbisNfsConf->nfsHandle,orbisNfsConf->openEntries[slot]->fileHandle,chunkSize,(char *)data+numberOfBytesWritten); - if(writtenBytes<0) - { - debugNetPrintf(ERROR,"[ORBISNFS] %s slot=%d fd=%d error=%d %s\n",__FUNCTION__,slot,fd,writtenBytes,nfs_get_error(orbisNfsConf->nfsHandle)); - break; - } - //decrease left bytes - leftBytes-= writtenBytes; - //increase overall written bytes - numberOfBytesWritten += writtenBytes; - - } - if(writtenBytes>=0) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d bytewrite=%d\n",__FUNCTION__,slot,fd,numberOfBytesWritten); - return numberOfBytesWritten; - } - else - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d error=%d %s\n",__FUNCTION__,slot,fd,writtenBytes,nfs_get_error(orbisNfsConf->nfsHandle)); - } - } - } - return 0x80020009; -} -int orbisNfsLseek(int fd, int offset, int whence) -{ - int ret; - int slot=-1; - uint64_t loffset = 0; - debugNetPrintf(DEBUG,"[ORBISNFS] %s fd=%d offset=%d whence=%d\n",__FUNCTION__,fd,offset,whence); - - if(fd<0 || !orbisNfsConf) - { - return 0x80020009; - } - slot=orbisNfsCheckSlotByFd(fd); - if(slot>=0) - { - if(orbisNfsConf->nfsHandle && orbisNfsConf->openEntries[slot]->fileHandle) - { - ret=(int)nfs_lseek(orbisNfsConf->nfsHandle,orbisNfsConf->openEntries[slot]->fileHandle,offset,whence,&loffset); - if(ret<0) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d error=%d\n",__FUNCTION__,slot,fd,ret,nfs_get_error(orbisNfsConf->nfsHandle)); - } - else - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d fd=%d return=%d\n",__FUNCTION__,slot,fd,(int)loffset); - return (int)loffset; - } - } - } - return 0x80020009; -} - -int orbisNfsDopen(const char *path) -{ - int ret; - int slot; - debugNetPrintf(DEBUG,"[ORBISNFS] %s path=%s\n",__FUNCTION__,path); - - if(!path || !orbisNfsConf) - { - return 0x80020016; - } - - - slot=orbisNfsCheckFreeDescriptor(); - if(slot>=0) - { - if(orbisNfsConf->nfsHandle && !(orbisNfsConf->openEntries[slot]->dirHandle)) - { - ret=nfs_opendir(orbisNfsConf->nfsHandle,path,&orbisNfsConf->openEntries[slot]->dirHandle); - - if(ret==0) - { - orbisNfsConf->openDescriptors[slot]=orbisNfsConf->openEntries[slot]->fd; - debugNetPrintf(DEBUG,"[ORBISNFS] %s directory %s open slot=%d dfd=%d\n",__FUNCTION__,path,slot,orbisNfsConf->openDescriptors[slot]); - return orbisNfsConf->openDescriptors[slot]; - } - else - { - free(orbisNfsConf->openEntries[slot]->dirHandle); - orbisNfsConf->openEntries[slot]->dirHandle=NULL; - } - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d error=%d %s\n",__FUNCTION__,slot,ret,nfs_get_error(orbisNfsConf->nfsHandle)); - return 0x80020016; - } - } - debugNetPrintf(ERROR,"[ORBISNFS] %s no free slot available\n",__FUNCTION__); - return 0x80020016; -} -int orbisNfsDclose(int dfd) -{ - - int slot=-1; - if(dfd<0 || !orbisNfsConf) - { - return 0x80020009; - } - slot=orbisNfsCheckSlotByFd(dfd); - if(slot>=0) - { - if(orbisNfsConf->nfsHandle && orbisNfsConf->openEntries[slot]->dirHandle) - { - nfs_closedir(orbisNfsConf->nfsHandle,orbisNfsConf->openEntries[slot]->dirHandle); - - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d dfd=%d %s closed\n",__FUNCTION__,slot,dfd,orbisNfsConf->openEntries[slot]->path); - - orbisNfsConf->openEntries[slot]->dirHandle=NULL; - orbisNfsConf->openDescriptors[slot]=-1; - strcpy(orbisNfsConf->openEntries[slot]->path,""); - return 0; - } - } - return 0x80020009; -} -int orbisNfsDread(int dfd,OrbisNfsBrowserDirEntry *entry) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - int slot=-1; - unsigned int mode; - struct nfsdirent *dirent=NULL; - if(dfd<0) - { - return 0x80020009; - } - if(!entry) - { - return 0x8002000e; - } - slot=orbisNfsCheckSlotByFd(dfd); - if(slot>=0) - { - dirent=nfs_readdir(orbisNfsConf->nfsHandle,orbisNfsConf->openEntries[slot]->dirHandle); - - if(dirent!=NULL) - { - mode = (dirent->mode & 0xFFF); - switch(dirent->type) - { - case NF3REG: - entry->type=DT_REG; - mode |= 0x0100000; - break; - case NF3DIR: - entry->type=DT_DIR; - mode |= 0x0040000; - break; - case NF3LNK: - entry->type=DT_LNK; - mode |= 0x0120000; - break; - default: - entry->type=DT_UNKNOWN; - break; - } - - - entry->customtype=0; - entry->mode=mode; - entry->namelen=strlen(dirent->name); - memset(entry->name,0,255); - strncpy(entry->name,dirent->name,entry->namelen); - struct tm *cloctime,*aloctime,*mloctime; - cloctime=localtime(&dirent->ctime.tv_sec); - aloctime=localtime(&dirent->atime.tv_sec); - mloctime=localtime(&dirent->mtime.tv_sec); - - entry->ctime.year = (unsigned short)(cloctime->tm_year+1900); - entry->ctime.month = (unsigned short)(cloctime->tm_mon + 1); - entry->ctime.day = (unsigned short)cloctime->tm_mday; - entry->ctime.hour = (unsigned short)cloctime->tm_hour; - entry->ctime.minute = (unsigned short)cloctime->tm_min; - entry->ctime.second = (unsigned short)cloctime->tm_sec; - - entry->atime.year = (unsigned short)(aloctime->tm_year+1900); - entry->atime.month = (unsigned short)(aloctime->tm_mon + 1); - entry->atime.day = (unsigned short)aloctime->tm_mday; - entry->atime.hour = (unsigned short)aloctime->tm_hour; - entry->atime.minute = (unsigned short)aloctime->tm_min; - entry->atime.second = (unsigned short)aloctime->tm_sec; - - entry->mtime.year = (unsigned short)(mloctime->tm_year+1900); - entry->mtime.month = (unsigned short)(mloctime->tm_mon + 1); - entry->mtime.day = (unsigned short)mloctime->tm_mday; - entry->mtime.hour = (unsigned short)mloctime->tm_hour; - entry->mtime.minute = (unsigned short)mloctime->tm_min; - entry->mtime.second = (unsigned short)mloctime->tm_sec; - - - entry->size=(unsigned int)dirent->size; - debugNetPrintf(DEBUG,"[ORBISNFS] %s slot=%d dfd=%d entry %s size=%d\n",__FUNCTION__,slot,dfd,entry->name,entry->size); - - return 1; - } - else - { - return 0; - } - - } - return 0x80020009; - -} -/* -int orbisMkdir(const char* path, int mode) -{ - int ret=0; - if(!path) - { - return 0x80020016; - } - if (strncmp(path,HOST0,sizeof(HOST0)-1)==0) - { - ret=ps4LinkMkdir(path,mode); - debugNetPrintf(DEBUG,"[ORBISFILE] orbisMkdir path=%s ret=%d\n",path,ret); - return ret; - } - else - { - return sceKernelMkdir(path,mode); - } -} -*/ - - - - -unsigned char * orbisNfsGetFileContent(const char *filename) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - _orbisNfs_lastopenFile_size = -1; // reset exported variable - - int pFile=orbisNfsOpen(filename,O_RDONLY,0); - - if(pFile<0) - { - debugNetPrintf(ERROR,"[ORBISNFS] %s Failed to read file %s\n",__FUNCTION__,filename); - return 0; - } - - // obtain file size: - int32_t fileSize=orbisNfsLseek(pFile,0,SEEK_END); - orbisNfsLseek(pFile,0,SEEK_SET); // Seek back to start - if(fileSize<0) - { - debugNetPrintf(ERROR,"[ORBISNFS] %s Failed to read size of file %s\n",__FUNCTION__,filename); - orbisNfsClose(pFile); - return NULL; - } - - unsigned char* pText=malloc(sizeof(unsigned char)*fileSize+1); - if(!pText) - { - debugNetPrintf(ERROR,"[ORBISNFS] %s Failed to allocate %d\n",__FUNCTION__,fileSize+1); - orbisNfsClose(pFile); - return 0; - } - - if(orbisNfsRead(pFile,pText,fileSize)!=fileSize) - { - debugNetPrintf(ERROR,"[ORBISNFS] %s Failed to read content of file %s\n",__FUNCTION__,filename); - orbisNfsClose(pFile); - free(pText); - return 0; - } - orbisNfsClose(pFile); - - // add null terminator to string - pText[fileSize] = 0; - - _orbisNfs_lastopenFile_size = fileSize; // now we update exported variable - - return pText; -} - -int orbisNfsBrowserGetDirLevel() -{ - return orbisNfsConf->dirLevel; -} -int orbisNfsBrowserGetBasePos() -{ - return orbisNfsConf->basePos; -} -int orbisNfsBrowserGetRelPos() -{ - return orbisNfsConf->relPos; -} -int orbisNfsBrowserGetListLength() -{ - return orbisNfsConf->browserList->length; -} -char* orbisNfsBrowserGetListPath() -{ - return orbisNfsConf->browserList->path; -} -void orbisNfsBrowserSetListPath1(char *path) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - int len = strlen(orbisNfsConf->browserList->path); - debugNetPrintf(DEBUG,"[ORBISNFS] %s %s len=%d\n",__FUNCTION__,orbisNfsConf->browserList->path,len); - - if (orbisNfsConf->dirLevel==0) - { - strcpy(orbisNfsConf->browserList->path, path); - } - else - { - //if(orbisNfsConf->dirLevel > 1) - //{ - if(len+strlen(path)browserList->path[len-1]!='/') - { - strcat(orbisNfsConf->browserList->path,"/"); - } - } - //} - strcat(orbisNfsConf->browserList->path, path); - debugNetPrintf(DEBUG,"[ORBISNFS] %s concat done %s len=%d\n",__FUNCTION__,orbisNfsConf->browserList->path,strlen(orbisNfsConf->browserList->path)); - - } -} - -void orbisNfsBrowserSetListPath(char *path) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - int len = strlen(orbisNfsConf->browserList->path); - debugNetPrintf(DEBUG,"[ORBISNFS] %s %s len=%d dirlevel=%d\n",__FUNCTION__,orbisNfsConf->browserList->path,len,orbisNfsConf->dirLevel); - - if(orbisNfsConf->dirLevel==0) - { - strcpy(orbisNfsConf->browserList->path, path); - } - else - { - if(orbisNfsConf->dirLevel > 1) - { - if(len+strlen(path)browserList->path[len-1]!='/') - { - strcat(orbisNfsConf->browserList->path,"/"); - } - } - } - strcat(orbisNfsConf->browserList->path, path); - debugNetPrintf(DEBUG,"[ORBISNFS] %s concat done %s len=%d\n",__FUNCTION__,orbisNfsConf->browserList->path,strlen(orbisNfsConf->browserList->path)); - } -} -void orbisNfsBrowserEntryDown() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if((orbisNfsConf->relPos+1)browserList->length) - { - if((orbisNfsConf->relPos+1)relPos++; - } - else - { - if((orbisNfsConf->basePos+orbisNfsConf->relPos+1)browserList->length) - { - orbisNfsConf->basePos++; - } - } - } -} -void orbisNfsBrowserEntryUp() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if(orbisNfsConf->relPos>0) - { - orbisNfsConf->relPos--; - } - else - { - if(orbisNfsConf->basePos>0) - { - orbisNfsConf->basePos--; - } - } -} -int orbisNfsBrowserGetFileType(char *file) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - char *p=strrchr(file,'.'); - if(p) - { - int i; - for(i=0;i<(sizeof(myextensionTypes)/sizeof(ExtensionTypes));i++) - { - if(strcasecmp(p,myextensionTypes[i].extension)==0) - { - return myextensionTypes[i].type; - } - } - } - - return FILE_TYPE_UNKNOWN; -} -void orbisNfsBrowserDirLevelUp(char *path) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - orbisNfsConf->basePosList[orbisNfsConf->dirLevel]=orbisNfsConf->basePos; - orbisNfsConf->relPosList[orbisNfsConf->dirLevel]=orbisNfsConf->relPos; - orbisNfsConf->dirLevel++; - orbisNfsConf->basePosList[orbisNfsConf->dirLevel]=0; - orbisNfsConf->relPosList[orbisNfsConf->dirLevel]=0; - orbisNfsConf->basePos=0; - orbisNfsConf->relPos=0; - orbisNfsBrowserSetListPath(path); - orbisNfsBrowserListRefresh(); -} -void orbisNfsBrowserDirLevelDown() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - char *p; - - p=strrchr(orbisNfsConf->browserList->path,'/'); - if(p) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s before %s %d\n",__FUNCTION__,orbisNfsConf->browserList->path,strlen(orbisNfsConf->browserList->path)); - p[0]='\0'; - if(orbisNfsConf->dirLevel>0) - orbisNfsConf->dirLevel--; - debugNetPrintf(DEBUG,"[ORBISNFS] %s after %s %d\n",__FUNCTION__,orbisNfsConf->browserList->path,strlen(orbisNfsConf->browserList->path)); - - goto DIR_UP_RETURN; - } - - p=strrchr(orbisNfsConf->browserList->path,':'); - if(p) - { - if (strlen(orbisNfsConf->browserList->path)-((p+1)-orbisNfsConf->browserList->path)>0) - { - p[1]='\0'; - if(orbisNfsConf->dirLevel>0) - orbisNfsConf->dirLevel--; - goto DIR_UP_RETURN; - } - } - - strcpy(orbisNfsConf->browserList->path, ROOT_PATH); - orbisNfsConf->dirLevel=0; - - -DIR_UP_RETURN: - orbisNfsConf->basePos=orbisNfsConf->basePosList[orbisNfsConf->dirLevel]; - orbisNfsConf->relPos=orbisNfsConf->relPosList[orbisNfsConf->dirLevel]; - orbisNfsBrowserListRefresh(); -} - -void orbisNfsBrowserListClean() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if(orbisNfsConf) - { - - if(orbisNfsConf->browserList) - { - - OrbisNfsBrowserListEntry *entry = orbisNfsConf->browserList->head; - - while (entry) - { - OrbisNfsBrowserListEntry *next = entry->next; - debugNetPrintf(DEBUG,"[ORBISNFS] %s before free %s\n",__FUNCTION__,entry->dir->name); - - free(entry->dir); - debugNetPrintf(DEBUG,"[ORBISNFS] %s after free dir\n",__FUNCTION__); - - free(entry); - debugNetPrintf(DEBUG,"[ORBISNFS] %s after free entry\n",__FUNCTION__); - - entry = next; - } - debugNetPrintf(DEBUG,"[ORBISNFS] %s cleaning head tail and length\n",__FUNCTION__); - - orbisNfsConf->browserList->head=NULL; - orbisNfsConf->browserList->tail=NULL; - orbisNfsConf->browserList->length=0; - } - } - -} - -int orbisNfsBrowserListRefresh() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - int ret=0,res=0; - - //do - //{ - orbisNfsBrowserListClean(); - //debugNetPrintf(DEBUG,"after orbisFilebrowserListClean\n"); - - res=orbisNfsBrowserListGetEntries(orbisNfsConf->browserList->path); - debugNetPrintf(DEBUG,"[ORBISNFS] %s (%s) ret:%d\n",__FUNCTION__ ,orbisNfsConf->browserList->path, res); - - if(res<0) - { - debugNetPrintf(ERROR,"[ORBISNFS] %s error=%d\n",__FUNCTION__,res); - - ret=res; - orbisNfsBrowserDirLevelDown(); - } - //}while(res<0); - - // Correct position after deleting the latest entry of the file list - while((orbisNfsConf->basePos+orbisNfsConf->relPos)>=orbisNfsConf->browserList->length) - { - if(orbisNfsConf->basePos>0) - { - orbisNfsConf->basePos--; - } - else - { - if(orbisNfsConf->relPos>0) - { - orbisNfsConf->relPos--; - } - } - } - - // Correct position after deleting an entry while the scrollbar is on the bottom - if(orbisNfsConf->browserList->length>=MAX_POSITION) { - while((orbisNfsConf->basePos+MAX_POSITION-1)>=orbisNfsConf->browserList->length) - { - if(orbisNfsConf->basePos>0) - { - orbisNfsConf->basePos--; - orbisNfsConf->relPos++; - } - } - } - - return ret; -} - -OrbisNfsBrowserListEntry *orbisNfsBrowserListGetNthEntry(int n) -{ - debugNetPrintf(0,"[ORBISNFS] %s\n",__FUNCTION__); - - OrbisNfsBrowserListEntry *entry; - if(!orbisNfsConf || !orbisNfsConf->browserList) - { - return NULL; - } - entry=orbisNfsConf->browserList->head; - while(n>0 && entry->next) - { - n--; - entry=entry->next; - } - - if (n != 0) - return NULL; - - return entry; -} - -void orbisNfsBrowserListAddEntry(OrbisNfsBrowserListEntry *entry,int sort) -{ - if(!orbisNfsConf || !entry) - { - return; - } - debugNetPrintf(DEBUG,"[ORBISNFS] %s %s type=%d customType=%d\n",__FUNCTION__,entry->dir->name,entry->dir->type,entry->dir->customtype); - - if(orbisNfsConf->browserList) - { - entry->next=NULL; - entry->previous=NULL; - if(orbisNfsConf->browserList->head==NULL) - { - orbisNfsConf->browserList->head=entry; - orbisNfsConf->browserList->tail=entry; - } - else - { - if(strcmp(entry->dir->name,"..")==0) - { - entry->next=orbisNfsConf->browserList->head; - orbisNfsConf->browserList->head=entry; - - } - else - { - if(strcmp(entry->dir->name,".")==0) - { - entry->next=orbisNfsConf->browserList->head; - orbisNfsConf->browserList->head=entry; - } - else - { - OrbisNfsBrowserListEntry *tail=orbisNfsConf->browserList->tail; - tail->next=entry; - entry->previous=tail; - orbisNfsConf->browserList->tail=entry; - } - } - - } - - orbisNfsConf->browserList->length++; - } -} - -int orbisNfsBrowserGetDirectoryEntries(char *path) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - int type=0; - int res=0; - int dfd=orbisNfsDopen(path); - if (dfd<0) - return dfd; - do - { - OrbisNfsBrowserDirEntry *dir; - dir=malloc(sizeof(OrbisNfsBrowserDirEntry)); - memset(dir->name,0,255); - res=orbisNfsDread(dfd,dir); - if(res>0) - { - /* skip useless backup (~) files! */ - if(strstr(dir->name, "~")) continue; - - OrbisNfsBrowserListEntry *entry=malloc(sizeof(OrbisNfsBrowserListEntry)); - entry->dir=dir; - if(dir->type!=DT_DIR) - { - type=orbisNfsBrowserGetFileType(entry->dir->name); - switch(type) - { - case FILE_TYPE_ROM: - if(strncmp(path,"./system",6)==0) - { - entry->dir->customtype=FILE_TYPE_SYSTEM_ROM; - } - else - { - entry->dir->customtype=FILE_TYPE_GAME_ROM; - } - break; - case FILE_TYPE_DSK: - entry->dir->customtype=FILE_TYPE_GAME_DSK; - break; - case FILE_TYPE_CAS: - entry->dir->customtype=FILE_TYPE_CAS; - break; - case FILE_TYPE_UNKNOWN: - entry->dir->customtype=FILE_TYPE_UNKNOWN; - break; - } - } - else - { - entry->dir->customtype=FILE_TYPE_FOLDER; - } - orbisNfsBrowserListAddEntry(entry,SORT_BY_NAME_AND_FOLDER); - - } - - } - while(res>0); - //res=0; - - - orbisNfsDclose(dfd); - return res; -} - -void orbisNfsFinish() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if(orbisnfs_external_conf!=1) - { - if(orbisNfsConf->orbisnfs_initialized==1) - { - nfs_destroy_url(orbisNfsConf->urls); - if(orbisNfsConf->nfsHandle!=NULL) - { - nfs_destroy_context(orbisNfsConf->nfsHandle); - orbisNfsBrowserListClean(); - if(orbisNfsConf->browserList) - free(orbisNfsConf->browserList); - } - } - orbisNfsConf->orbisnfs_initialized=-1; - - debugNetPrintf(DEBUG,"[ORBISNFS] %s liborbisNfs finished\n",__FUNCTION__); - } - orbisNfsConf->orbisnfs_initialized=0; -} -int orbisNfsBrowserGetDevices() -{ - int i; - for(i=0;idir->name,mydevices[i]); - entry->dir->customtype=FILE_TYPE_FOLDER; - orbisNfsBrowserListAddEntry(entry,SORT_BY_NAME_AND_FOLDER); - - } - } - - return 0; -} -int orbisNfsBrowserListGetEntries(char *path) -{ - - if(strcmp(path,ROOT_PATH)==0) - { - return orbisNfsBrowserGetDevices(); - } - - return orbisNfsBrowserGetDirectoryEntries(path); - -} -OrbisNfsConfig *orbisNfsGetConf() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if(orbisNfsConf) - { - return orbisNfsConf; - } - - return NULL; -} - -int orbisNfsSetConf(OrbisNfsConfig *conf) -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if(conf) - { - orbisNfsConf=conf; - orbisnfs_external_conf=1; - return orbisNfsConf->orbisnfs_initialized; - } - else - { - debugNetPrintf(ERROR,"[ORBISNFS] %s invalid conf\n",__FUNCTION__); - } - return 0; -} -int orbisNfsInitWithConf(OrbisNfsConfig *conf) -{ - int ret; - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - ret=orbisNfsSetConf(conf); - if(ret) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s liborbisNfs already initialized using external configuration\n",__FUNCTION__); - debugNetPrintf(DEBUG,"[ORBISNFS] %s orbisnfs_initialized=%d\n",__FUNCTION__,orbisNfsConf->orbisnfs_initialized); - debugNetPrintf(DEBUG,"[ORBISNFS] %s ready to have a lot of fun...\n",__FUNCTION__); - return orbisNfsConf->orbisnfs_initialized; - } - else - { - return 0; - } -} - -int orbisNfsCreateConf() -{ - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - int i; - if(!orbisNfsConf) - { - orbisNfsConf=(OrbisNfsConfig *)malloc(sizeof(OrbisNfsConfig)); - if(orbisNfsConf) - { - orbisNfsConf->nfsHandle=NULL; - orbisNfsConf->urls=NULL; - for(i=0;iopenDescriptors[i]=-1; - orbisNfsConf->openEntries[i]=(OrbisNfsEntry *)malloc(sizeof(OrbisNfsEntry)); - if(orbisNfsConf->openEntries[i]) - { - orbisNfsConf->openEntries[i]->fd=i; - orbisNfsConf->openEntries[i]->size=0; - orbisNfsConf->openEntries[i]->fileHandle=NULL; - orbisNfsConf->openEntries[i]->dirHandle=NULL; - orbisNfsConf->browserList=NULL; - orbisNfsConf->basePos=0; - orbisNfsConf->relPos=0; - orbisNfsConf->dirLevel=0; - - } - else - { - debugNetPrintf(ERROR,"[ORBISNFS] %s malloc error 2 in %d\n",__FUNCTION__,i); - return 1; - } - } - orbisNfsConf->orbisnfs_initialized=-1; - return 0; - } - else - { - debugNetPrintf(ERROR,"[ORBISNFS] %s malloc error 1\n",__FUNCTION__); - return 1; - } - } - if(orbisNfsConf->orbisnfs_initialized==1) - { - return orbisNfsConf->orbisnfs_initialized; - } - //something weird happened - return -1; -} -char * orbisNfsGetExportPath() -{ - - return orbisNfsConf->urls->path; -} -int orbisNfsInit(const char *nfsurl) -{ - int ret; - debugNetPrintf(DEBUG,"[ORBISNFS] %s\n",__FUNCTION__); - - if(nfsurl==NULL) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s invalid url\n",__FUNCTION__); - return -1; - } - - if(orbisNfsCreateConf()==1) - { - return orbisNfsConf->orbisnfs_initialized; - } - - if(orbisNfsConf->orbisnfs_initialized==1) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s liborbisNfs is already initialized!\n",__FUNCTION__); - return orbisNfsConf->orbisnfs_initialized; - } - - debugNetPrintf(DEBUG,"[ORBISNFS] %s calling nfs_init_context\n",__FUNCTION__); - - orbisNfsConf->nfsHandle=nfs_init_context(); - - if(orbisNfsConf->nfsHandle==NULL) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s Failed to init nfs context %s\n",__FUNCTION__,nfs_get_error(orbisNfsConf->nfsHandle)); - return orbisNfsConf->orbisnfs_initialized; - } - - debugNetPrintf(DEBUG,"[ORBISNFS] %s nfs_init_context return valid nfs object\n",__FUNCTION__); - - debugNetPrintf(DEBUG,"[ORBISNFS] %s calling nfs_parse_url_dir\n",__FUNCTION__); - - orbisNfsConf->urls=nfs_parse_url_dir(orbisNfsConf->nfsHandle,nfsurl); - - if(orbisNfsConf->urls==NULL) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s Failed to parse url : %s\n",__FUNCTION__,nfs_get_error(orbisNfsConf->nfsHandle)); - return orbisNfsConf->orbisnfs_initialized; - } - - debugNetPrintf(DEBUG,"[ORBISNFS] %s nfs_parse_url_dir return valid urls object\n",__FUNCTION__); - - debugNetPrintf(DEBUG,"[ORBISNFS] %s calling nfs_mount\n",__FUNCTION__); - - ret=nfs_mount(orbisNfsConf->nfsHandle,orbisNfsConf->urls->server,orbisNfsConf->urls->path); - - if(ret!=0) - { - debugNetPrintf(DEBUG,"[ORBISNFS] %s Failed to mount nfs share : %s\n",__FUNCTION__,nfs_get_error(orbisNfsConf->nfsHandle)); - return orbisNfsConf->orbisnfs_initialized; - } - debugNetPrintf(DEBUG,"[ORBISNFS] %s nfs_mount return fine\n",__FUNCTION__); - - orbisNfsConf->readChunkSize=nfs_get_readmax(orbisNfsConf->nfsHandle); - orbisNfsConf->writeChunkSize=nfs_get_writemax(orbisNfsConf->nfsHandle); - - orbisNfsConf->orbisnfs_initialized=1; - - debugNetPrintf(DEBUG,"[ORBISNFS] %s liborbisNfs initialized readChunkSize=%d writeChunkSize=%d\n",__FUNCTION__,orbisNfsConf->readChunkSize,orbisNfsConf->writeChunkSize); - - orbisNfsConf->browserList=malloc(sizeof(OrbisNfsBrowserList)); - if(orbisNfsConf->browserList!=NULL) - { - orbisNfsConf->browserList->head=NULL; - orbisNfsConf->browserList->tail=NULL; - orbisNfsBrowserListClean(); - strcpy(orbisNfsConf->browserList->path, "."); - orbisNfsConf->dirLevel=1; - //orbisNfsBrowserDirLevelUp(); - orbisNfsBrowserListGetEntries("."); - } - else - { - debugNetPrintf(ERROR,"[ORBISNFS] %s problem in malloc browserList\n",__FUNCTION__); - - } - return orbisNfsConf->orbisnfs_initialized; -} diff --git a/source/liborbisNfs/pdu.c b/source/liborbisNfs/pdu.c deleted file mode 100644 index 6fc3ac5..0000000 --- a/source/liborbisNfs/pdu.c +++ /dev/null @@ -1,637 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef HAVE_NETINET_IN_H -#include -#endif - -#ifdef HAVE_SYS_SOCKET_H -#include -#endif - -#ifdef HAVE_STRINGS_H -#include -#endif - -#include -#include -#include -#include -#include -#include "slist.h" -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" - -void rpc_reset_queue(struct rpc_queue *q) -{ - q->head = NULL; - q->tail = NULL; -} - -/* - * Push to the tail end of the queue - */ -void rpc_enqueue(struct rpc_queue *q, struct rpc_pdu *pdu) -{ - if (q->head == NULL) - q->head = pdu; - else - q->tail->next = pdu; - q->tail = pdu; - pdu->next = NULL; -} - -/* - * Push to the front/head of the queue - */ -void rpc_return_to_queue(struct rpc_queue *q, struct rpc_pdu *pdu) -{ - pdu->next = q->head; - q->head = pdu; - if (q->tail == NULL) - q->tail = pdu; -} - -unsigned int rpc_hash_xid(uint32_t xid) -{ - return (xid * 7919) % HASHES; -} - -#define PAD_TO_8_BYTES(x) ((x + 0x07) & ~0x07) - -static struct rpc_pdu *rpc_allocate_reply_pdu(struct rpc_context *rpc, - struct rpc_msg *res, - size_t alloc_hint) -{ - struct rpc_pdu *pdu; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - pdu = malloc(sizeof(struct rpc_pdu)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory: Failed to allocate pdu structure"); - return NULL; - } - memset(pdu, 0, sizeof(struct rpc_pdu)); - pdu->flags = PDU_DISCARD_AFTER_SENDING; - pdu->xid = 0; - pdu->cb = NULL; - pdu->private_data = NULL; - pdu->zdr_decode_fn = NULL; - pdu->zdr_decode_bufsize = 0; - - pdu->outdata.data = malloc(ZDR_ENCODEBUF_MINSIZE + alloc_hint); - if (pdu->outdata.data == NULL) { - rpc_set_error(rpc, "Out of memory: Failed to allocate encode buffer"); - free(pdu); - return NULL; - } - - zdrmem_create(&pdu->zdr, pdu->outdata.data, ZDR_ENCODEBUF_MINSIZE + alloc_hint, ZDR_ENCODE); - if (rpc->is_udp == 0) { - zdr_setpos(&pdu->zdr, 4); /* skip past the record marker */ - } - - if (zdr_replymsg(rpc, &pdu->zdr, res) == 0) { - rpc_set_error(rpc, "zdr_replymsg failed with %s", - rpc_get_error(rpc)); - zdr_destroy(&pdu->zdr); - free(pdu->outdata.data); - free(pdu); - return NULL; - } - - return pdu; -} - -struct rpc_pdu *rpc_allocate_pdu2(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_decode_bufsize, size_t alloc_hint) -{ - struct rpc_pdu *pdu; - struct rpc_msg msg; - int pdu_size; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Since we already know how much buffer we need for the decoding - * we can just piggyback in the same alloc as for the pdu. - */ - pdu_size = PAD_TO_8_BYTES(sizeof(struct rpc_pdu)); - pdu_size += PAD_TO_8_BYTES(zdr_decode_bufsize); - - pdu = malloc(pdu_size); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory: Failed to allocate pdu structure"); - return NULL; - } - memset(pdu, 0, pdu_size); - pdu->xid = rpc->xid++; - pdu->cb = cb; - pdu->private_data = private_data; - pdu->zdr_decode_fn = zdr_decode_fn; - pdu->zdr_decode_bufsize = zdr_decode_bufsize; - - pdu->outdata.data = malloc(ZDR_ENCODEBUF_MINSIZE + alloc_hint); - if (pdu->outdata.data == NULL) { - rpc_set_error(rpc, "Out of memory: Failed to allocate encode buffer"); - free(pdu); - return NULL; - } - - zdrmem_create(&pdu->zdr, pdu->outdata.data, ZDR_ENCODEBUF_MINSIZE + alloc_hint, ZDR_ENCODE); - if (rpc->is_udp == 0) { - zdr_setpos(&pdu->zdr, 4); /* skip past the record marker */ - } - - memset(&msg, 0, sizeof(struct rpc_msg)); - msg.xid = pdu->xid; - msg.direction = CALL; - msg.body.cbody.rpcvers = RPC_MSG_VERSION; - msg.body.cbody.prog = program; - msg.body.cbody.vers = version; - msg.body.cbody.proc = procedure; - msg.body.cbody.cred = rpc->auth->ah_cred; - msg.body.cbody.verf = rpc->auth->ah_verf; - - if (zdr_callmsg(rpc, &pdu->zdr, &msg) == 0) { - rpc_set_error(rpc, "zdr_callmsg failed with %s", - rpc_get_error(rpc)); - zdr_destroy(&pdu->zdr); - free(pdu->outdata.data); - free(pdu); - return NULL; - } - - return pdu; -} - -struct rpc_pdu *rpc_allocate_pdu(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_decode_bufsize) -{ - return rpc_allocate_pdu2(rpc, program, version, procedure, cb, private_data, zdr_decode_fn, zdr_decode_bufsize, 0); -} - -void rpc_free_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - free(pdu->outdata.data); - - if (pdu->zdr_decode_buf != NULL) { - zdr_free(pdu->zdr_decode_fn, pdu->zdr_decode_buf); - } - - zdr_destroy(&pdu->zdr); - - free(pdu); -} - -void rpc_set_next_xid(struct rpc_context *rpc, uint32_t xid) -{ - rpc->xid = xid; -} - -int rpc_queue_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu) -{ - int size, recordmarker; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->timeout > 0) { - pdu->timeout = rpc_current_time() + rpc->timeout; -#ifndef HAVE_CLOCK_GETTIME - /* If we do not have GETTIME we fallback to time() which - * has 1s granularity for its timestamps. - * We thus need to bump the timeout by 1000ms - * so that the PDU will timeout within 1.0 - 2.0 seconds. - * Otherwise setting a 1s timeout would trigger within - * 0.001 - 1.0s. - */ - pdu->timeout += 1000; -#endif - } else { - pdu->timeout = 0; - } - - size = zdr_getpos(&pdu->zdr); - - /* for udp we dont queue, we just send it straight away */ - if (rpc->is_udp != 0) { - unsigned int hash; - -// XXX add a rpc->udp_dest_sock_size and get rid of sys/socket.h and netinet/in.h - if (sendto(rpc->fd, pdu->zdr.buf, size, MSG_DONTWAIT, - (struct sockaddr *)&rpc->udp_dest, - sizeof(rpc->udp_dest)) < 0) { - rpc_set_error(rpc, "Sendto failed with errno %s", strerror(errno)); - rpc_free_pdu(rpc, pdu); - return -1; - } - - hash = rpc_hash_xid(pdu->xid); - rpc_enqueue(&rpc->waitpdu[hash], pdu); - rpc->waitpdu_len++; - return 0; - } - - /* write recordmarker */ - zdr_setpos(&pdu->zdr, 0); - recordmarker = (size - 4) | 0x80000000; - zdr_int(&pdu->zdr, &recordmarker); - - pdu->outdata.size = size; - rpc_enqueue(&rpc->outqueue, pdu); - - return 0; -} - -uint32_t rpc_get_pdu_size(char *buf) -{ - uint32_t size; - - size = ntohl(*(uint32_t *)(void *)buf); - - return (size & 0x7fffffff) + 4; -} - -static int rpc_process_reply(struct rpc_context *rpc, struct rpc_pdu *pdu, ZDR *zdr) -{ - struct rpc_msg msg; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - memset(&msg, 0, sizeof(struct rpc_msg)); - msg.body.rbody.reply.areply.verf = _null_auth; - if (pdu->zdr_decode_bufsize > 0) { - pdu->zdr_decode_buf = (char *)pdu + PAD_TO_8_BYTES(sizeof(struct rpc_pdu)); - } - msg.body.rbody.reply.areply.reply_data.results.where = pdu->zdr_decode_buf; - msg.body.rbody.reply.areply.reply_data.results.proc = pdu->zdr_decode_fn; - if (zdr_replymsg(rpc, zdr, &msg) == 0) { - rpc_set_error(rpc, "zdr_replymsg failed in rpc_process_reply: " - "%s", rpc_get_error(rpc)); - pdu->cb(rpc, RPC_STATUS_ERROR, "Message rejected by server", - pdu->private_data); - if (pdu->zdr_decode_buf != NULL) { - pdu->zdr_decode_buf = NULL; - } - return 0; - } - if (msg.body.rbody.stat != MSG_ACCEPTED) { - pdu->cb(rpc, RPC_STATUS_ERROR, "RPC Packet not accepted by the server", pdu->private_data); - return 0; - } - switch (msg.body.rbody.reply.areply.stat) { - case SUCCESS: - pdu->cb(rpc, RPC_STATUS_SUCCESS, pdu->zdr_decode_buf, pdu->private_data); - break; - case PROG_UNAVAIL: - pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program not available", pdu->private_data); - break; - case PROG_MISMATCH: - pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program version mismatch", pdu->private_data); - break; - case PROC_UNAVAIL: - pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Procedure not available", pdu->private_data); - break; - case GARBAGE_ARGS: - pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Garbage arguments", pdu->private_data); - break; - case SYSTEM_ERR: - pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: System Error", pdu->private_data); - break; - default: - pdu->cb(rpc, RPC_STATUS_ERROR, "Unknown rpc response from server", pdu->private_data); - break; - } - - return 0; -} - -static int rpc_send_error_reply(struct rpc_context *rpc, - struct rpc_msg *call, - enum accept_stat err, - int min_vers, int max_vers) -{ - struct rpc_pdu *pdu; - struct rpc_msg res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - memset(&res, 0, sizeof(struct rpc_msg)); - res.xid = call->xid; - res.direction = REPLY; - res.body.rbody.stat = MSG_ACCEPTED; - res.body.rbody.reply.areply.reply_data.mismatch_info.low = min_vers; - res.body.rbody.reply.areply.reply_data.mismatch_info.high = max_vers; - res.body.rbody.reply.areply.verf = _null_auth; - res.body.rbody.reply.areply.stat = err; - - if (rpc->is_udp) { - /* send the reply back to the client */ - memcpy(&rpc->udp_dest, &rpc->udp_src, sizeof(rpc->udp_dest)); - } - - pdu = rpc_allocate_reply_pdu(rpc, &res, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to send error_reply: %s", - rpc_get_error(rpc)); - return -1; - } - rpc_queue_pdu(rpc, pdu); - - return 0; -} - -int rpc_send_reply(struct rpc_context *rpc, - struct rpc_msg *call, - void *reply, - zdrproc_t encode_fn, - int alloc_hint) -{ - struct rpc_pdu *pdu; - struct rpc_msg res; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - memset(&res, 0, sizeof(struct rpc_msg)); - res.xid = call->xid; - res.direction = REPLY; - res.body.rbody.stat = MSG_ACCEPTED; - res.body.rbody.reply.areply.verf = _null_auth; - res.body.rbody.reply.areply.stat = SUCCESS; - - res.body.rbody.reply.areply.reply_data.results.where = reply; - res.body.rbody.reply.areply.reply_data.results.proc = encode_fn; - - if (rpc->is_udp) { - /* send the reply back to the client */ - memcpy(&rpc->udp_dest, &rpc->udp_src, sizeof(rpc->udp_dest)); - } - - pdu = rpc_allocate_reply_pdu(rpc, &res, alloc_hint); - if (pdu == NULL) { - rpc_set_error(rpc, "Failed to send error_reply: %s", - rpc_get_error(rpc)); - return -1; - } - rpc_queue_pdu(rpc, pdu); - - return 0; -} - -static int rpc_process_call(struct rpc_context *rpc, ZDR *zdr) -{ - struct rpc_msg call; - struct rpc_endpoint *endpoint; - int i, min_version = 0, max_version = 0, found_program = 0; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - memset(&call, 0, sizeof(struct rpc_msg)); - if (zdr_callmsg(rpc, zdr, &call) == 0) { - rpc_set_error(rpc, "Failed to decode CALL message. %s", - rpc_get_error(rpc)); - return rpc_send_error_reply(rpc, &call, GARBAGE_ARGS, 0, 0); - } - for (endpoint = rpc->endpoints; endpoint; endpoint = endpoint->next) { - if (call.body.cbody.prog == endpoint->program) { - if (!found_program) { - min_version = max_version = endpoint->version; - } - if (endpoint->version < min_version) { - min_version = endpoint->version; - } - if (endpoint->version > max_version) { - max_version = endpoint->version; - } - found_program = 1; - if (call.body.cbody.vers == endpoint->version) { - break; - } - } - } - if (endpoint == NULL) { - rpc_set_error(rpc, "No endpoint found for CALL " - "program:0x%08x version:%d\n", - call.body.cbody.prog, call.body.cbody.vers); - if (!found_program) { - return rpc_send_error_reply(rpc, &call, PROG_UNAVAIL, - 0, 0); - } - return rpc_send_error_reply(rpc, &call, PROG_MISMATCH, - min_version, max_version); - } - for (i = 0; i < endpoint->num_procs; i++) { - if (endpoint->procs[i].proc == call.body.cbody.proc) { - if (endpoint->procs[i].decode_buf_size) { - call.body.cbody.args = zdr_malloc(zdr, endpoint->procs[i].decode_buf_size); - } - if (!endpoint->procs[i].decode_fn(zdr, call.body.cbody.args)) { - rpc_set_error(rpc, "Failed to unmarshall " - "call payload"); - return rpc_send_error_reply(rpc, &call, GARBAGE_ARGS, 0 ,0); - } - return endpoint->procs[i].func(rpc, &call); - } - } - - return rpc_send_error_reply(rpc, &call, PROC_UNAVAIL, 0 ,0); -} - -int rpc_process_pdu(struct rpc_context *rpc, char *buf, int size) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s \n",__FUNCTION__); - - struct rpc_pdu *pdu, *prev_pdu; - struct rpc_queue *q; - ZDR zdr; - int pos, recordmarker = 0; - unsigned int hash; - uint32_t xid; - char *reasbuf = NULL; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - memset(&zdr, 0, sizeof(ZDR)); - - zdrmem_create(&zdr, buf, size, ZDR_DECODE); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after zdrmem_create \n",__FUNCTION__); - - if (rpc->is_udp == 0) { - if (zdr_int(&zdr, &recordmarker) == 0) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s recordmarker \n",__FUNCTION__); - - rpc_set_error(rpc, "zdr_int reading recordmarker failed"); - zdr_destroy(&zdr); - return -1; - } - if (!(recordmarker&0x80000000)) { - debugNetPrintf(3,"[LIBNFS] %s recormarker 8----\n",__FUNCTION__); - - zdr_destroy(&zdr); - if (rpc_add_fragment(rpc, buf+4, size-4) != 0) { - rpc_set_error(rpc, "Failed to queue fragment for reassembly."); - return -1; - } - return 0; - } - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after udp check \n",__FUNCTION__); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after udp check 1 \n",__FUNCTION__); - - /* reassembly */ - if (recordmarker != 0 && rpc->fragments != NULL) { - struct rpc_fragment *fragment; - uint32_t total = size - 4; - char *ptr; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s before destroy\n",__FUNCTION__); - - zdr_destroy(&zdr); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after destroy\n",__FUNCTION__); - - for (fragment = rpc->fragments; fragment; fragment = fragment->next) { - total += fragment->size; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s fragments\n",__FUNCTION__); - - if (total < fragment->size) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s fragment large\n",__FUNCTION__); - - rpc_set_error(rpc, "Fragments too large"); - rpc_free_all_fragments(rpc); - return -1; - } - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s before malloc 1\n",__FUNCTION__); - - reasbuf = malloc(total); - if (reasbuf == NULL) { - - debugNetPrintf(2,"[LIBNFS] %s error malloc\n",__FUNCTION__); - rpc_set_error(rpc, "Failed to reassemble PDU"); - rpc_free_all_fragments(rpc); - return -1; - } - ptr = reasbuf; - for (fragment = rpc->fragments; fragment; fragment = fragment->next) { - memcpy(ptr, fragment->data, fragment->size); - ptr += fragment->size; - } - memcpy(ptr, buf + 4, size - 4); - zdrmem_create(&zdr, reasbuf, total, ZDR_DECODE); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after zdrmem_create\n",__FUNCTION__); - - rpc_free_all_fragments(rpc); - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after fragment check \n",__FUNCTION__); - - if (rpc->is_server_context) { - int ret; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s is_server_context \n",__FUNCTION__); - - ret = rpc_process_call(rpc, &zdr); - zdr_destroy(&zdr); - if (reasbuf != NULL) { - free(reasbuf); - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s is_server_context return\n",__FUNCTION__); - return ret; - } - - pos = zdr_getpos(&zdr); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after zdr_getpos \n",__FUNCTION__); - - if (zdr_int(&zdr, (int *)&xid) == 0) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s xid err \n",__FUNCTION__); - - rpc_set_error(rpc, "zdr_int reading xid failed"); - zdr_destroy(&zdr); - if (reasbuf != NULL) { - free(reasbuf); - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s error xid return \n",__FUNCTION__); - - return -1; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after zdr_setpos \n",__FUNCTION__); - - zdr_setpos(&zdr, pos); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after zdr_setpos \n",__FUNCTION__); - - /* Look up the transaction in a hash table of our requests */ - hash = rpc_hash_xid(xid); - q = &rpc->waitpdu[hash]; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s before for \n",__FUNCTION__); - - /* Follow the hash chain. Linear traverse singly-linked list, - * but track previous entry for optimised removal */ - prev_pdu = NULL; - for (pdu=q->head; pdu; pdu=pdu->next) { - if (pdu->xid != xid) { - prev_pdu = pdu; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s for continue \n",__FUNCTION__); - continue; - } - if (rpc->is_udp == 0 || rpc->is_broadcast == 0) { - /* Singly-linked but we track head and tail */ - if (pdu == q->head) - q->head = pdu->next; - if (pdu == q->tail) - q->tail = prev_pdu; - if (prev_pdu != NULL) - prev_pdu->next = pdu->next; - rpc->waitpdu_len--; - } - if (rpc_process_reply(rpc, pdu, &zdr) != 0) { - debugNetPrintf(2,"[LIBNFS] %s error reply in for \n",__FUNCTION__); - - rpc_set_error(rpc, "rpc_procdess_reply failed"); - } - zdr_destroy(&zdr); - if (rpc->is_udp == 0 || rpc->is_broadcast == 0) { - rpc_free_pdu(rpc, pdu); - } - if (reasbuf != NULL) { - free(reasbuf); - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end in for \n",__FUNCTION__); - - return 0; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after for \n",__FUNCTION__); - - zdr_destroy(&zdr); - if (reasbuf != NULL) { - free(reasbuf); - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end \n",__FUNCTION__); - - return 0; -} - diff --git a/source/liborbisNfs/portmap.c b/source/liborbisNfs/portmap.c deleted file mode 100644 index 886c42c..0000000 --- a/source/liborbisNfs/portmap.c +++ /dev/null @@ -1,391 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -#ifdef WIN32 -#include -#endif/*WIN32*/ - -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-portmap.h" - -/* - * PORTMAP v2 - */ -int rpc_pmap2_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP2_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP2/NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for PORTMAP2/NULL call"); - return -1; - } - - return 0; -} - -int rpc_pmap2_getport_async(struct rpc_context *rpc, int program, int version, int protocol, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - struct pmap2_mapping m; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP2_GETPORT, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP2/GETPORT call"); - return -1; - } - - m.prog = program; - m.vers = version; - m.prot = protocol; - m.port = 0; - if (zdr_pmap2_mapping(&pdu->zdr, &m) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP2/GETPORT call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP2/GETPORT pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap2_set_async(struct rpc_context *rpc, int program, int version, int protocol, int port, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - struct pmap2_mapping m; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP2_SET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP2/SET call"); - return -1; - } - - m.prog = program; - m.vers = version; - m.prot = protocol; - m.port = port; - if (zdr_pmap2_mapping(&pdu->zdr, &m) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP2/SET call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP2/SET pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap2_unset_async(struct rpc_context *rpc, int program, int version, int protocol, int port, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - struct pmap2_mapping m; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP2_UNSET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP2/UNSET call"); - return -1; - } - - m.prog = program; - m.vers = version; - m.prot = protocol; - m.port = port; - if (zdr_pmap2_mapping(&pdu->zdr, &m) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP2/UNSET call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP2/UNSET pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap2_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP2_DUMP, cb, private_data, (zdrproc_t)zdr_pmap2_dump_result, sizeof(pmap2_dump_result)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP2/DUMP call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP2/DUMP pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap2_callit_async(struct rpc_context *rpc, int program, int version, int procedure, char *data, int datalen, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - struct pmap2_call_args ca; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V2, PMAP2_CALLIT, cb, private_data, (zdrproc_t)zdr_pmap2_call_result, sizeof(pmap2_call_result)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP2/CALLIT call"); - return -1; - } - - ca.prog = program; - ca.vers = version; - ca.proc = procedure; - ca.args.args_len = datalen; - ca.args.args_val = data; - - if (zdr_pmap2_call_args(&pdu->zdr, &ca) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP2/CALLIT call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP2/CALLIT pdu: %s", rpc_get_error(rpc)); - return -1; - } - - return 0; -} - -/* - * PORTMAP v3 - */ -int rpc_pmap3_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/NULL call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for PORTMAP3/NULL call"); - return -1; - } - - return 0; -} - -int rpc_pmap3_set_async(struct rpc_context *rpc, struct pmap3_mapping *map, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_SET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/SET call"); - return -1; - } - - if (zdr_pmap3_mapping(&pdu->zdr, map) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP3/SET call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/SET pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap3_unset_async(struct rpc_context *rpc, struct pmap3_mapping *map, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_UNSET, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/UNSET call"); - return -1; - } - - if (zdr_pmap3_mapping(&pdu->zdr, map) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP3/UNSET call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/UNSET pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap3_getaddr_async(struct rpc_context *rpc, struct pmap3_mapping *map, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_GETADDR, cb, private_data, (zdrproc_t)zdr_pmap3_string_result, sizeof(pmap3_string_result)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/GETADDR call"); - return -1; - } - - if (zdr_pmap3_mapping(&pdu->zdr, map) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP3/GETADDR call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/GETADDR pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap3_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_DUMP, cb, private_data, (zdrproc_t)zdr_pmap3_dump_result, sizeof(pmap3_dump_result)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/DUMP call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/DUMP pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap3_gettime_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_GETTIME, cb, private_data, (zdrproc_t)zdr_int, sizeof(uint32_t)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/GETTIME call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/GETTIME pdu"); - return -1; - } - - return 0; -} - -int rpc_pmap3_callit_async(struct rpc_context *rpc, int program, int version, int procedure, char *data, int datalen, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - struct pmap3_call_args ca; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_CALLIT, cb, private_data, (zdrproc_t)zdr_pmap3_call_result, sizeof(pmap3_call_result)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/CALLIT call"); - return -1; - } - - ca.prog = program; - ca.vers = version; - ca.proc = procedure; - ca.args.args_len = datalen; - ca.args.args_val = data; - - if (zdr_pmap3_call_args(&pdu->zdr, &ca) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP3/CALLIT call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/CALLIT pdu: %s", rpc_get_error(rpc)); - return -1; - } - - return 0; -} - -int rpc_pmap3_uaddr2taddr_async(struct rpc_context *rpc, char *uaddr, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_UADDR2TADDR, cb, private_data, (zdrproc_t)zdr_pmap3_netbuf, sizeof(pmap3_netbuf)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/UADDR2TADDR call"); - return -1; - } - - if (zdr_string(&pdu->zdr, &uaddr, 255) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP3/UADDR2TADDR call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/UADDR2TADDR pdu: %s", rpc_get_error(rpc)); - return -1; - } - - return 0; -} - -int rpc_pmap3_taddr2uaddr_async(struct rpc_context *rpc, struct pmap3_netbuf *nb, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, PMAP_PROGRAM, PMAP_V3, PMAP3_TADDR2UADDR, cb, private_data, (zdrproc_t)zdr_pmap3_string_result, sizeof(pmap3_string_result)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for PORTMAP3/TADDR2UADDR call"); - return -1; - } - - if (zdr_pmap3_netbuf(&pdu->zdr, nb) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode data for PORTMAP3/TADDR2UADDR call"); - rpc_free_pdu(rpc, pdu); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Failed to queue PORTMAP3/TADDR2UADDR pdu: %s", rpc_get_error(rpc)); - return -1; - } - - return 0; -} diff --git a/source/liborbisNfs/rquota.c b/source/liborbisNfs/rquota.c deleted file mode 100644 index ed4813b..0000000 --- a/source/liborbisNfs/rquota.c +++ /dev/null @@ -1,202 +0,0 @@ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -#ifdef WIN32 -#include -#endif/*WIN32*/ - -#include -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "libnfs-raw-rquota.h" - - - -char *rquotastat_to_str(int error) -{ - switch (error) { - case RQUOTA_OK: return "RQUOTA_OK"; break; - case RQUOTA_NOQUOTA: return "RQUOTA_NOQUOTA"; break; - case RQUOTA_EPERM: return "RQUOTA_EPERM"; break; - }; - return "unknown rquota error"; -} - -int rquotastat_to_errno(int error) -{ - switch (error) { - case RQUOTA_OK: return 0; break; - case RQUOTA_NOQUOTA: return -ENOENT; break; - case RQUOTA_EPERM: return -EPERM; break; - }; - return -ENOENT; -} - - -int rpc_rquota1_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, RQUOTA_PROGRAM, RQUOTA_V1, RQUOTA1_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for rquota1/null call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for rquota1/null call"); - return -2; - } - - return 0; -} - -int rpc_rquota1_getquota_async(struct rpc_context *rpc, rpc_cb cb, char *export, int uid, void *private_data) -{ - struct rpc_pdu *pdu; - GETQUOTA1args args; - - pdu = rpc_allocate_pdu(rpc, RQUOTA_PROGRAM, RQUOTA_V1, RQUOTA1_GETQUOTA, cb, private_data, (zdrproc_t)zdr_GETQUOTA1res, sizeof(GETQUOTA1res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for rquota1/getquota call"); - return -1; - } - - args.export = export; - args.uid = uid; - - if (zdr_GETQUOTA1args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETQUOTA1args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for rquota1/getquota call"); - return -3; - } - - return 0; -} - -int rpc_rquota1_getactivequota_async(struct rpc_context *rpc, rpc_cb cb, char *export, int uid, void *private_data) -{ - struct rpc_pdu *pdu; - GETQUOTA1args args; - - pdu = rpc_allocate_pdu(rpc, RQUOTA_PROGRAM, RQUOTA_V1, RQUOTA1_GETACTIVEQUOTA, cb, private_data, (zdrproc_t)zdr_GETQUOTA1res, sizeof(GETQUOTA1res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for rquota1/getactivequota call"); - return -1; - } - - args.export = export; - args.uid = uid; - - if (zdr_GETQUOTA1args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETQUOTA1args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for rquota1/getactivequota call"); - return -3; - } - - return 0; -} - - -int rpc_rquota2_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) -{ - struct rpc_pdu *pdu; - - pdu = rpc_allocate_pdu(rpc, RQUOTA_PROGRAM, RQUOTA_V2, RQUOTA2_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for rquota2/null call"); - return -1; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for rquota2/null call"); - return -2; - } - - return 0; -} - -int rpc_rquota2_getquota_async(struct rpc_context *rpc, rpc_cb cb, char *export, int type, int uid, void *private_data) -{ - struct rpc_pdu *pdu; - GETQUOTA2args args; - - pdu = rpc_allocate_pdu(rpc, RQUOTA_PROGRAM, RQUOTA_V2, RQUOTA2_GETQUOTA, cb, private_data, (zdrproc_t)zdr_GETQUOTA1res, sizeof(GETQUOTA1res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for rquota2/getquota call"); - return -1; - } - - args.export = export; - args.type = type; - args.uid = uid; - - if (zdr_GETQUOTA2args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETQUOTA2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for rquota2/getquota call"); - return -3; - } - - return 0; -} - -int rpc_rquota2_getactivequota_async(struct rpc_context *rpc, rpc_cb cb, char *export, int type, int uid, void *private_data) -{ - struct rpc_pdu *pdu; - GETQUOTA2args args; - - pdu = rpc_allocate_pdu(rpc, RQUOTA_PROGRAM, RQUOTA_V2, RQUOTA2_GETACTIVEQUOTA, cb, private_data, (zdrproc_t)zdr_GETQUOTA1res, sizeof(GETQUOTA1res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for rquota2/getactivequota call"); - return -1; - } - - args.export = export; - args.type = type; - args.uid = uid; - - if (zdr_GETQUOTA2args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode GETQUOTA2args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for rquota2/getactivequota call"); - return -3; - } - - return 0; -} diff --git a/source/liborbisNfs/socket.c b/source/liborbisNfs/socket.c deleted file mode 100644 index fd6f3a6..0000000 --- a/source/liborbisNfs/socket.c +++ /dev/null @@ -1,1066 +0,0 @@ -/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ -/* - Copyright (C) 2010 by Ronnie Sahlberg - - This program 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 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 Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public License - along with this program; if not, see . -*/ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifdef AROS -#include "aros_compat.h" -#endif - -#ifdef WIN32 -#include -#endif - -#ifdef HAVE_ARPA_INET_H -#include -#endif - -#ifdef HAVE_POLL_H -#include -#endif - -#ifdef HAVE_UNISTD_H -#include -#endif - -#ifdef HAVE_SYS_IOCTL_H -#include -#endif - -#ifdef HAVE_SYS_SOCKET_H -#include -#endif - -#ifdef HAVE_NETINET_IN_H -#include -#endif - -#ifdef HAVE_NETINET_TCP_H -#include -#endif - -#ifdef HAVE_NETDB_H -#include -#endif - -#ifdef HAVE_SYS_FILIO_H -#include -#endif - -#ifdef HAVE_SYS_SOCKIO_H -#include -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include "libnfs-zdr.h" -#include "libnfs.h" -#include "libnfs-raw.h" -#include "libnfs-private.h" -#include "slist.h" - -#ifdef WIN32 -//has to be included after stdlib!! -#include "win32_errnowrapper.h" -#endif - -#ifndef MSG_NOSIGNAL -#if (defined(__APPLE__) && defined(__MACH__)) -#define MSG_NOSIGNAL 0 -#endif -#endif - -static int -rpc_reconnect_requeue(struct rpc_context *rpc); - -static int -create_socket(int domain, int type, int protocol) -{ -#ifdef SOCK_CLOEXEC -#ifdef __linux__ - /* Linux-specific extension (since 2.6.27): set the - close-on-exec flag on all sockets to avoid leaking file - descriptors to child processes */ - int fd = socket(domain, type|SOCK_CLOEXEC, protocol); - if (fd >= 0 || errno != EINVAL) - return fd; -#endif -#endif - - return socket(domain, type, protocol); -} - -static int -set_nonblocking(int fd) -{ - int v = 0; -#if defined(WIN32) - u_long nonblocking=1; -// v = ioctl(fd, FIONBIO, &nonblocking); -#else - v = fcntl(fd, F_GETFL, 0); - v = fcntl(fd, F_SETFL, v | O_NONBLOCK); -#endif - return v; -} - -static void -set_nolinger(int fd) -{ - struct linger lng; - lng.l_onoff = 1; - lng.l_linger = 0; - setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *)&lng, sizeof(lng)); -} - -static int -set_bind_device(int fd, char *ifname) -{ - int rc = 0; - -#ifdef HAVE_SO_BINDTODEVICE - if (*ifname) { - rc = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname, - strlen(ifname)); - } - -#endif - return rc; -} - -#ifdef HAVE_NETINET_TCP_H -static int -set_tcp_sockopt(int sockfd, int optname, int value) -{ - int level; - - #if defined(__FreeBSD__) || defined(__sun) || (defined(__APPLE__) && defined(__MACH__)) - struct protoent *buf; - - //if ((buf = getprotobyname("tcp")) != NULL) - level = 6;//buf->p_proto; - //else - // return -1; - #else - level = SOL_TCP; - #endif - - return setsockopt(sockfd, level, optname, (char *)&value, - sizeof(value)); -} -#endif - -int -rpc_get_fd(struct rpc_context *rpc) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->old_fd) { - return rpc->old_fd; - } - - return rpc->fd; -} - -static int -rpc_has_queue(struct rpc_queue *q) -{ - return q->head != NULL; -} - -int -rpc_which_events(struct rpc_context *rpc) -{ - int events; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - events = rpc->is_connected ? POLLIN : POLLOUT; - - if (rpc->is_udp != 0) { - /* for udp sockets we only wait for pollin */ - return POLLIN; - } - - if (rpc_has_queue(&rpc->outqueue)) { - events |= POLLOUT; - } - return events; -} - -static int -rpc_write_to_socket(struct rpc_context *rpc) -{ - int32_t count; - struct rpc_pdu *pdu; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->fd == -1) { - rpc_set_error(rpc, "trying to write but not connected"); - return -1; - } - - while ((pdu = rpc->outqueue.head) != NULL) { - int64_t total; - - total = pdu->outdata.size; - - count = send(rpc->fd, pdu->outdata.data + pdu->written, - (int)(total - pdu->written), MSG_NOSIGNAL); - if (count == -1) { - if (errno == EAGAIN || errno == EWOULDBLOCK) { - return 0; - } - rpc_set_error(rpc, "Error when writing to socket :%s" - "(%d)", strerror(errno), errno); - return -1; - } - - pdu->written += count; - if (pdu->written == total) { - unsigned int hash; - - rpc->outqueue.head = pdu->next; - if (pdu->next == NULL) - rpc->outqueue.tail = NULL; - - if (pdu->flags & PDU_DISCARD_AFTER_SENDING) { - rpc_free_pdu(rpc, pdu); - return 0; - } - - hash = rpc_hash_xid(pdu->xid); - rpc_enqueue(&rpc->waitpdu[hash], pdu); - rpc->waitpdu_len++; - } - } - return 0; -} - -#define MAX_UDP_SIZE 65536 -static int -rpc_read_from_socket(struct rpc_context *rpc) -{ - uint32_t pdu_size; - ssize_t count; - char *buf; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->is_udp) { - socklen_t socklen = sizeof(rpc->udp_src); - - buf = malloc(MAX_UDP_SIZE); - if (buf == NULL) { - rpc_set_error(rpc, "Failed to malloc buffer for " - "recvfrom"); - return -1; - } - count = recvfrom(rpc->fd, buf, MAX_UDP_SIZE, MSG_DONTWAIT, - (struct sockaddr *)&rpc->udp_src, &socklen); - if (count == -1) { - free(buf); - if (errno == EINTR || errno == EAGAIN) { - return 0; - } - rpc_set_error(rpc, "Failed recvfrom: %s", - strerror(errno)); - return -1; - } - if (rpc_process_pdu(rpc, buf, count) != 0) { - rpc_set_error(rpc, "Invalid/garbage pdu received from " - "server. Ignoring PDU"); - free(buf); - return -1; - } - free(buf); - return 0; - } - - do { - /* Read record marker, - * 4 bytes at the beginning of every pdu. - */ - if (rpc->inpos < 4) { - buf = (void *)rpc->rm_buf; - pdu_size = 4; - } else { - pdu_size = rpc_get_pdu_size((void *)&rpc->rm_buf); - if (rpc->inbuf == NULL) { - if (pdu_size > NFS_MAX_XFER_SIZE + 4096) { - rpc_set_error(rpc, "Incoming PDU " - "exceeds limit of %d " - "bytes.", - NFS_MAX_XFER_SIZE + 4096); - return -1; - } - rpc->inbuf = malloc(pdu_size); - if (rpc->inbuf == NULL) { - rpc_set_error(rpc, "Failed to allocate " - "buffer of %d bytes for " - "pdu, errno:%d. Closing " - "socket.", - pdu_size, errno); - return -1; - } - memcpy(rpc->inbuf, &rpc->rm_buf, 4); - } - buf = rpc->inbuf; - } - - count = recv(rpc->fd, buf + rpc->inpos, pdu_size - rpc->inpos, - MSG_DONTWAIT); - if (count < 0) { - if (errno == EINTR || errno == EAGAIN) { - break; - } - rpc_set_error(rpc, "Read from socket failed, errno:%d. " - "Closing socket.", errno); - return -1; - } - if (count == 0) { - /* remote side has closed the socket. Reconnect. */ - return -1; - } - rpc->inpos += count; - - if (rpc->inpos == 4) { - /* We have just read the header and there is likely - * more data available */ - continue; - } - - if (rpc->inpos == pdu_size) { - rpc->inbuf = NULL; - rpc->inpos = 0; - - if (rpc_process_pdu(rpc, buf, pdu_size) != 0) { - rpc_set_error(rpc, "Invalid/garbage pdu " - "received from server. Closing " - "socket"); - free(buf); - return -1; - } - free(buf); - } - } while (rpc->is_nonblocking && rpc->waitpdu_len > 0); - - return 0; -} - -static void -maybe_call_connect_cb(struct rpc_context *rpc, int status) -{ - rpc_cb tmp_cb = rpc->connect_cb; - - if (rpc->connect_cb == NULL) { - return; - } - - rpc->connect_cb = NULL; - tmp_cb(rpc, status, rpc->error_string, rpc->connect_data); -} - -static void -rpc_timeout_scan(struct rpc_context *rpc) -{ - struct rpc_pdu *pdu; - struct rpc_pdu *next_pdu; - uint64_t t = rpc_current_time(); - unsigned int i; - - for (pdu = rpc->outqueue.head; pdu; pdu = next_pdu) { - next_pdu = pdu->next; - - if (pdu->timeout == 0) { - /* no timeout for this pdu */ - continue; - } - if (t < pdu->timeout) { - /* not expired yet */ - continue; - } - LIBNFS_LIST_REMOVE(&rpc->outqueue.head, pdu); - if (!rpc->outqueue.head) { - rpc->outqueue.tail = NULL; - } - rpc_set_error(rpc, "command timed out"); - pdu->cb(rpc, RPC_STATUS_TIMEOUT, - NULL, pdu->private_data); - rpc_free_pdu(rpc, pdu); - } - for (i = 0; i < HASHES; i++) { - struct rpc_queue *q = &rpc->waitpdu[i]; - - for (pdu = q->head; pdu; pdu = next_pdu) { - next_pdu = pdu->next; - - if (pdu->timeout == 0) { - /* no timeout for this pdu */ - continue; - } - if (t < pdu->timeout) { - /* not expired yet */ - continue; - } - LIBNFS_LIST_REMOVE(&q->head, pdu); - if (!q->head) { - q->tail = NULL; - } - rpc_set_error(rpc, "command timed out"); - pdu->cb(rpc, RPC_STATUS_TIMEOUT, - NULL, pdu->private_data); - rpc_free_pdu(rpc, pdu); - } - } -} - -int -rpc_service(struct rpc_context *rpc, int revents) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s \n",__FUNCTION__); - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - rpc_timeout_scan(rpc); - - if (revents == -1 || revents & (POLLERR|POLLHUP)) { - if (revents != -1 && revents & POLLERR) { - -#ifdef WIN32 - char err = 0; -#else - int err = 0; -#endif - socklen_t err_size = sizeof(err); - - if (getsockopt(rpc->fd, SOL_SOCKET, SO_ERROR, - (char *)&err, &err_size) != 0 || err != 0) { - if (err == 0) { - err = errno; - } - rpc_set_error(rpc, "rpc_service: socket error " - "%s(%d).", - strerror(err), err); - } else { - rpc_set_error(rpc, "rpc_service: POLLERR, " - "Unknown socket error."); - } - } - if (revents != -1 && revents & POLLHUP) { - rpc_set_error(rpc, "Socket failed with POLLHUP"); - } - if (rpc->auto_reconnect) { - return rpc_reconnect_requeue(rpc); - } - maybe_call_connect_cb(rpc, RPC_STATUS_ERROR); - return -1; - - } - - if (rpc->is_connected == 0 && rpc->fd != -1 && (revents & POLLOUT)) { - int err = 0; - socklen_t err_size = sizeof(err); - - if (getsockopt(rpc->fd, SOL_SOCKET, SO_ERROR, - (char *)&err, &err_size) != 0 || err != 0) { - if (err == 0) { - err = errno; - } - rpc_set_error(rpc, "rpc_service: socket error " - "%s(%d) while connecting.", - strerror(err), err); - maybe_call_connect_cb(rpc, RPC_STATUS_ERROR); - return -1; - } - - rpc->is_connected = 1; - RPC_LOG(rpc, 2, "connection established on fd %d", rpc->fd); - maybe_call_connect_cb(rpc, RPC_STATUS_SUCCESS); - return 0; - } - - if (revents & POLLIN) { - if (rpc_read_from_socket(rpc) != 0) { - if (rpc->is_server_context) { - return -1; - } else { - return rpc_reconnect_requeue(rpc); - } - } - } - - if (revents & POLLOUT && rpc_has_queue(&rpc->outqueue)) { - if (rpc_write_to_socket(rpc) != 0) { - if (rpc->is_server_context) { - return -1; - } else { - return rpc_reconnect_requeue(rpc); - } - } - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - - return 0; -} - -void -rpc_set_autoreconnect(struct rpc_context *rpc, int num_retries) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* we can not connect and not reconnect on a server context. */ - if (rpc->is_server_context) { - return; - } - - rpc->auto_reconnect = num_retries; -} - -void -rpc_set_tcp_syncnt(struct rpc_context *rpc, int v) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - rpc->tcp_syncnt = v; -} - -#ifndef TCP_SYNCNT -#define TCP_SYNCNT 7 -#endif - -static int -rpc_connect_sockaddr_async(struct rpc_context *rpc) -{ - struct sockaddr_storage *s = &rpc->s; - socklen_t socksize; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - switch (s->ss_family) { - case AF_INET: - socksize = sizeof(struct sockaddr_in); - rpc->fd = create_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - if (set_bind_device(rpc->fd, rpc->ifname) != 0) { - rpc_set_error (rpc, "Failed to bind to interface"); - return -1; - } - -#ifdef HAVE_NETINET_TCP_H - if (rpc->tcp_syncnt != RPC_PARAM_UNDEFINED) { - set_tcp_sockopt(rpc->fd, TCP_SYNCNT, rpc->tcp_syncnt); - } -#endif - break; - case AF_INET6: - socksize = sizeof(struct sockaddr_in6); - rpc->fd = create_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); - if (set_bind_device(rpc->fd, rpc->ifname) != 0) { - rpc_set_error (rpc, "Failed to bind to interface"); - return -1; - } - -#ifdef HAVE_NETINET_TCP_H - if (rpc->tcp_syncnt != RPC_PARAM_UNDEFINED) { - set_tcp_sockopt(rpc->fd, TCP_SYNCNT, rpc->tcp_syncnt); - } -#endif - break; - default: - rpc_set_error(rpc, "Can not handle AF_FAMILY:%d", s->ss_family); - return -1; - } - - if (rpc->fd == -1) { - rpc_set_error(rpc, "Failed to open socket"); - return -1; - } - - if (rpc->old_fd) { -#if !defined(WIN32) - if (dup2(rpc->fd, rpc->old_fd) == -1) { - return -1; - } - close(rpc->fd); - rpc->fd = rpc->old_fd; -#else - /* On Windows dup2 does not work on sockets - * instead just close the old socket */ - close(rpc->old_fd); - rpc->old_fd = 0; -#endif - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s go go\n",__FUNCTION__); - - /* Some systems allow you to set capabilities on an executable - * to allow the file to be executed with privilege to bind to - * privileged system ports, even if the user is not root. - * - * Opportunistically try to bind the socket to a low numbered - * system port in the hope that the user is either root or the - * executable has the CAP_NET_BIND_SERVICE. - * - * As soon as we fail the bind() with EACCES we know we will never - * be able to bind to a system port so we terminate the loop. - * - * On linux, use - * sudo setcap 'cap_net_bind_service=+ep' /path/executable - * to make the executable able to bind to a system port. - * - * On Windows, there is no concept of privileged ports. Thus - * binding will usually succeed. - */ - { - struct sockaddr_storage ss; - struct sockaddr_in *sin; - struct sockaddr_in6 *sin6; - static int portOfs = 0; - const int firstPort = 512; /* >= 512 according to Sun docs */ - const int portCount = IPPORT_RESERVED - firstPort; - int startOfs, port, rc; - - sin = (struct sockaddr_in *)&ss; - sin6 = (struct sockaddr_in6 *)&ss; - - if (portOfs == 0) { - portOfs = 60800;//60000+100*(rand()%11);//rpc_current_time() % 400; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s portOfs=%d portCount=%d\n",__FUNCTION__,portOfs,portCount); - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s \n",__FUNCTION__); - - startOfs = portOfs; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s startOfs=%d portOfs=%d \n",__FUNCTION__,startOfs,portOfs); - - do { - jander: - rc = -1; - port = htons(firstPort + portOfs); - portOfs = (portOfs + 1) % portCount; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s port=%d\n",__FUNCTION__,port); - - /* skip well-known ports */ - //if (!getservbyport(port, "tcp")) { - - if (1) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s in port=%d portOfs=%d\n",__FUNCTION__,port,portOfs); - - memset(&ss, 0, sizeof(ss)); - - switch (s->ss_family) { - case AF_INET: - sin->sin_port = port; - sin->sin_family = AF_INET; -#ifdef HAVE_SOCKADDR_LEN - sin->sin_len = - sizeof(struct sockaddr_in); -#endif - break; - case AF_INET6: - sin6->sin6_port = port; - sin6->sin6_family = AF_INET6; -#ifdef HAVE_SOCKADDR_LEN - sin6->sin6_len = - sizeof(struct sockaddr_in6); -#endif - break; - } - - rc = bind(rpc->fd, (struct sockaddr *)&ss, - socksize); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s rc=%d \n",__FUNCTION__,rc); - - if(rc==-1) - { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s jander rc=%d \n",__FUNCTION__,rc); - - goto jander; - } - -#if !defined(WIN32) - /* we got EACCES, so don't try again */ - if (rc != 0 && errno == EACCES) - { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s wrong chungo rc=%d \n",__FUNCTION__,rc); - - break; - } -#endif - } - } while (rc != 0 && portOfs != startOfs); - } - - rpc->is_nonblocking = !set_nonblocking(rpc->fd); - set_nolinger(rpc->fd); - - if (connect(rpc->fd, (struct sockaddr *)s, socksize) != 0 && - errno != EINPROGRESS) { - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s 1\n",__FUNCTION__); - - rpc_set_error(rpc, "connect() to server failed. %s(%d)", - strerror(errno), errno); - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s 2\n",__FUNCTION__); - - return -1; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s end\n",__FUNCTION__); - - return 0; -} - -static int -rpc_set_sockaddr(struct rpc_context *rpc, const char *server, int port) -{ - struct addrinfo *ai = NULL; - debugNetPrintf(3,"[LIBNFS] %s server=%s\n",__FUNCTION__,server); - - //if (getaddrinfo(server, NULL, NULL, &ai) != 0) { - // rpc_set_error(rpc, "Invalid address:%s. " - // "Can not resolv into IPv4/v6 structure.", server); - // return -1; - //} - -// switch (ai->ai_family) { -// case AF_INET: - ((struct sockaddr_in *)&rpc->s)->sin_family = 2;//ai->ai_family; - ((struct sockaddr_in *)&rpc->s)->sin_port = htons(port); - sceNetInetPton(AF_INET, server, &(((struct sockaddr_in *)&rpc->s)->sin_addr)); - //((struct sockaddr_in *)&rpc->s)->sin_addr = - // ((struct sockaddr_in *)(void *)(ai->ai_addr))->sin_addr; -#ifdef HAVE_SOCKADDR_LEN - ((struct sockaddr_in *)&rpc->s)->sin_len = - sizeof(struct sockaddr_in); -#endif -// break; -// case AF_INET6: -// ((struct sockaddr_in6 *)&rpc->s)->sin6_family = ai->ai_family; -// ((struct sockaddr_in6 *)&rpc->s)->sin6_port = htons(port); -// ((struct sockaddr_in6 *)&rpc->s)->sin6_addr = - -// ((struct sockaddr_in6 *)(void *)(ai->ai_addr))->sin6_addr; -//#ifdef HAVE_SOCKADDR_LEN -// ((struct sockaddr_in6 *)&rpc->s)->sin6_len = -// sizeof(struct sockaddr_in6); -//#endif -// break; -// } -// freeaddrinfo(ai); - - return 0; -} - -int -rpc_connect_async(struct rpc_context *rpc, const char *server, int port, - rpc_cb cb, void *private_data) -{ - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s\n",__FUNCTION__); - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->is_server_context) { - rpc_set_error(rpc, "Can not connect on a server context"); - return -1; - } - - if (rpc->fd != -1) { - rpc_set_error(rpc, "Trying to connect while already connected"); - return -1; - } - - if (rpc->is_udp != 0) { - rpc_set_error(rpc, "Trying to connect on UDP socket"); - return -1; - } - - rpc->auto_reconnect = 0; - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s before rpc_set_sockaddr\n",__FUNCTION__); - - if (rpc_set_sockaddr(rpc, server, port) != 0) { - return -1; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after rpc_set_sockaddr\n",__FUNCTION__); - - rpc->connect_cb = cb; - rpc->connect_data = private_data; - - if (rpc_connect_sockaddr_async(rpc) != 0) { - return -1; - } - debugNetPrintf(DEBUGNETLEVEL,"[LIBNFS] %s after rpc_connect_sockaddr_async\n",__FUNCTION__); - - return 0; -} - -int -rpc_disconnect(struct rpc_context *rpc, const char *error) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - /* Do not re-disconnect if we are already disconnected */ - if (!rpc->is_connected) { - return 0; - } - /* Disable autoreconnect */ - rpc_set_autoreconnect(rpc, 0); - - if (rpc->fd != -1) { - close(rpc->fd); - } - rpc->fd = -1; - - rpc->is_connected = 0; - - if (!rpc->is_server_context) { - rpc_error_all_pdus(rpc, error); - } - - maybe_call_connect_cb(rpc, RPC_STATUS_CANCEL); - return 0; -} - -static void -reconnect_cb(struct rpc_context *rpc, int status, void *data _U_, - void *private_data) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (status != RPC_STATUS_SUCCESS) { - rpc_set_error(rpc, "Failed to reconnect async"); - rpc_reconnect_requeue(rpc); - return; - } - - rpc->is_connected = 1; - rpc->connect_cb = NULL; - rpc->old_fd = 0; -} - -/* Disconnect but do not error all PDUs, just move pdus in-flight back to the - * outqueue and reconnect. - */ -static int -rpc_reconnect_requeue(struct rpc_context *rpc) -{ - struct rpc_pdu *pdu, *next; - unsigned int i; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->auto_reconnect == 0) { - RPC_LOG(rpc, 1, "reconnect is disabled"); - rpc_error_all_pdus(rpc, "RPC ERROR: Failed to reconnect async"); - return -1; - } - - if (rpc->is_connected) { - rpc->num_retries = rpc->auto_reconnect; - } - - if (rpc->fd != -1) { - rpc->old_fd = rpc->fd; - } - rpc->fd = -1; - rpc->is_connected = 0; - - if (rpc->outqueue.head) { - rpc->outqueue.head->written = 0; - } - - /* Socket is closed so we will not get any replies to any commands - * in flight. Move them all over from the waitpdu queue back to the - * out queue. - */ - for (i = 0; i < HASHES; i++) { - struct rpc_queue *q = &rpc->waitpdu[i]; - for (pdu = q->head; pdu; pdu = next) { - next = pdu->next; - rpc_return_to_queue(&rpc->outqueue, pdu); - /* we have to re-send the whole pdu again */ - pdu->written = 0; - } - rpc_reset_queue(q); - } - rpc->waitpdu_len = 0; - - if (rpc->auto_reconnect < 0 || rpc->num_retries > 0) { - rpc->num_retries--; - rpc->connect_cb = reconnect_cb; - RPC_LOG(rpc, 1, "reconnect initiated"); - if (rpc_connect_sockaddr_async(rpc) != 0) { - rpc_error_all_pdus(rpc, "RPC ERROR: Failed to " - "reconnect async"); - return -1; - } - return 0; - } - - RPC_LOG(rpc, 1, "reconnect: all attempts failed."); - rpc_error_all_pdus(rpc, "RPC ERROR: All attempts to reconnect failed."); - return -1; -} - - -int -rpc_bind_udp(struct rpc_context *rpc, char *addr, int port) -{ - struct addrinfo *ai = NULL; - char service[6]; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->is_udp == 0) { - rpc_set_error(rpc, "Cant not bind UDP. Not UDP context"); - return -1; - } - - sprintf(service, "%d", port); - //if (getaddrinfo(addr, service, NULL, &ai) != 0) { - // rpc_set_error(rpc, "Invalid address:%s. " - // "Can not resolv into IPv4/v6 structure.", addr); - // return -1; - //} - - //switch(ai->ai_family) { - //case AF_INET: - rpc->fd = create_socket(/*ai->ai_family*/AF_INET, SOCK_DGRAM, 0); - if (rpc->fd == -1) { - rpc_set_error(rpc, "Failed to create UDP socket: %s", - strerror(errno)); - // freeaddrinfo(ai); - return -1; - } - struct sockaddr_in address; - - memset(&address, 0, sizeof(address)); - address.sin_family = AF_INET; - address.sin_port = htons(port); - sceNetInetPton(AF_INET,addr, &address.sin_addr); - - if (bind(rpc->fd, (struct sockaddr *)&address, - sizeof(struct sockaddr_in)) != 0) { - rpc_set_error(rpc, "Failed to bind to UDP socket: %s", - strerror(errno)); - // freeaddrinfo(ai); - return -1; - } - // break; - //default: - // rpc_set_error(rpc, "Can not handle UPD sockets of family %d " - // "yet", ai->ai_family); - // freeaddrinfo(ai); - // return -1; - //} - - //freeaddrinfo(ai); - - return 0; -} - -int -rpc_set_udp_destination(struct rpc_context *rpc, char *addr, int port, - int is_broadcast) -{ - struct addrinfo *ai = NULL; - char service[6]; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - if (rpc->is_udp == 0) { - rpc_set_error(rpc, "Can not set destination sockaddr. Not UDP " - "context"); - return -1; - } - - sprintf(service, "%d", port); - //if (getaddrinfo(addr, service, NULL, &ai) != 0) { - // rpc_set_error(rpc, "Invalid address:%s. " - // "Can not resolv into IPv4/v6 structure.", addr); - // return -1; - //} -struct sockaddr_in address; - - memset(&address, 0, sizeof(address)); - address.sin_family = AF_INET; - address.sin_port = htons(port); - sceNetInetPton(AF_INET, addr, &address.sin_addr); - - memcpy(&rpc->udp_dest, &address/*ai->ai_addr*/, sizeof(address)/*ai->ai_addrlen*/); - //freeaddrinfo(ai); - - rpc->is_broadcast = is_broadcast; - setsockopt(rpc->fd, SOL_SOCKET, SO_BROADCAST, (char *)&is_broadcast, - sizeof(is_broadcast)); - - return 0; -} - -struct sockaddr * -rpc_get_recv_sockaddr(struct rpc_context *rpc) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - return (struct sockaddr *)&rpc->udp_src; -} - -int -rpc_queue_length(struct rpc_context *rpc) -{ - int i = 0; - struct rpc_pdu *pdu; - - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - for(pdu = rpc->outqueue.head; pdu; pdu = pdu->next) { - i++; - } - - i += rpc->waitpdu_len; - - return i; -} - -void -rpc_set_fd(struct rpc_context *rpc, int fd) -{ - assert(rpc->magic == RPC_CONTEXT_MAGIC); - - rpc->fd = fd; -} - -int -rpc_is_udp_socket(struct rpc_context *rpc) -{ -#ifdef WIN32 - char type = 0; -#else - int type = 0; -#endif - socklen_t len = sizeof(type); - - getsockopt(rpc->fd, SOL_SOCKET, SO_TYPE, &type, &len); - return type == SOCK_DGRAM; -} diff --git a/source/liborbisPad/orbisPad.c b/source/liborbisPad/orbisPad.c deleted file mode 100644 index c8524fe..0000000 --- a/source/liborbisPad/orbisPad.c +++ /dev/null @@ -1,241 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#include -#include -#include -#include -//#include -//#include -#include - -#include -#include "orbisPad.h" - -OrbisPadConfig *orbisPadConf=NULL; - -int orbispad_external_conf=-1; - -void orbisPadFinish() -{ - int ret; - if(orbispad_external_conf!=1) - { - if(orbisPadConf->orbispad_initialized==1) - { - ret=scePadClose(orbisPadConf->padHandle); - - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s scePadClose return 0x%8x\n",__FUNCTION__,ret); - } - orbisPadConf->orbispad_initialized=-1; - - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s finished\n",__FUNCTION__); - } -} - -OrbisPadConfig *orbisPadGetConf() -{ - if(orbisPadConf) - { - return orbisPadConf; - } - - return NULL; -} -int orbisPadCreateConf() -{ - if(!orbisPadConf) - { - orbisPadConf=(OrbisPadConfig *)malloc(sizeof(OrbisPadConfig)); - - orbisPadConf->userId=0; - orbisPadConf->padHandle=-1; - - orbisPadConf->padDataCurrent=(ScePadData *)malloc(sizeof(ScePadData)); - orbisPadConf->padDataLast=(ScePadData *)malloc(sizeof(ScePadData)); - - orbisPadConf->buttonsPressed=0; - orbisPadConf->buttonsReleased=0; - orbisPadConf->buttonsHold=0; - - orbisPadConf->orbispad_initialized=-1; - - return 0; - } - - if(orbisPadConf->orbispad_initialized==1) - { - return orbisPadConf->orbispad_initialized; - } - //something weird happened - return -1; -} -int orbisPadSetConf(OrbisPadConfig *conf) -{ - if(conf) - { - orbisPadConf=conf; - orbispad_external_conf=1; - return orbisPadConf->orbispad_initialized; - } - - return 0; -} -int orbisPadInitWithConf(OrbisPadConfig *conf) -{ - int ret; - ret=orbisPadSetConf(conf); - if(ret) - { - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s already initialized using configuration external\n",__FUNCTION__); - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s orbispad_initialized=%d\n",__FUNCTION__,orbisPadConf->orbispad_initialized); - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s ready to have a lot of fun...\n",__FUNCTION__); - return orbisPadConf->orbispad_initialized; - } - else - { - return 0; - } -} -unsigned int orbisPadGetCurrentButtonsPressed() -{ - return orbisPadConf->buttonsPressed; -} -void orbisPadSetCurrentButtonsPressed(unsigned int buttons) -{ - orbisPadConf->buttonsPressed=buttons; -} -unsigned int orbisPadGetCurrentButtonsReleased() -{ - return orbisPadConf->buttonsReleased; -} -void orbisPadSetCurrentButtonsReleased(unsigned int buttons) -{ - orbisPadConf->buttonsReleased=buttons; -} - -bool orbisPadGetButtonHold(unsigned int filter) -{ - if((orbisPadConf->buttonsHold&filter)==filter) - { - return 1; - } - return 0; -} -bool orbisPadGetButtonPressed(unsigned int filter) -{ - if((orbisPadConf->buttonsPressed&filter)==filter) - { - return 1; - } - return 0; -} -bool orbisPadGetButtonReleased(unsigned int filter) -{ - if((orbisPadConf->buttonsReleased&filter)==filter) - { - if(~(orbisPadConf->padDataLast->buttons)&filter) - { - return 0; - } - return 1; - } - return 0; -} -int orbisPadUpdate() -{ - int ret; - unsigned int actualButtons=0; - unsigned int lastButtons=0; - memcpy(orbisPadConf->padDataLast,orbisPadConf->padDataCurrent,sizeof(ScePadData)); - - ret=scePadReadState(orbisPadConf->padHandle,orbisPadConf->padDataCurrent); - - if(ret==0 && orbisPadConf->padDataCurrent->connected==1) - { - actualButtons=orbisPadConf->padDataCurrent->buttons; - lastButtons=orbisPadConf->padDataLast->buttons; - orbisPadConf->buttonsPressed=(actualButtons)&(~lastButtons); - if(actualButtons!=lastButtons) - { - orbisPadConf->buttonsReleased=(~actualButtons)&(lastButtons); - } - else - { - orbisPadConf->buttonsReleased=0; - } - orbisPadConf->buttonsHold=actualButtons&lastButtons; - return 0; - - } - else - { - return -1; - } -} -int orbisPadInit() -{ - int ret; - - int param=700; - - if(orbisPadCreateConf()==1) - { - return orbisPadConf->orbispad_initialized; - } - if (orbisPadConf->orbispad_initialized==1) - { - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s is already initialized!\n",__FUNCTION__); - return orbisPadConf->orbispad_initialized; - } - ret=sceUserServiceInitialize(¶m); - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s sceUserServiceInitialize return 0x%8x!\n",__FUNCTION__,ret); - - - if(ret==0) - { - ret=scePadInit(); - if(ret<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s scePadInit return error 0x%8x\n",__FUNCTION__,ret); - return -1; - } - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s scePadInit return %d\n",__FUNCTION__,ret); - if(ret==0) - { - - ret=sceUserServiceGetInitialUser(&orbisPadConf->userId); - if(ret<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s sceUserServiceGetInitialUser return error 0x%8x\n",__FUNCTION__,ret); - orbisPadConf->userId=0x10000000; - - } - - orbisPadConf->padHandle=scePadOpen(orbisPadConf->userId, 0, 0, NULL); - if(orbisPadConf->padHandle<0) - { - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s scePadOpen return error 0x%8x\n",__FUNCTION__,orbisPadConf->padHandle); - return -1; - } - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s scePadOpen return handle 0x%8x\n",__FUNCTION__,orbisPadConf->padHandle); - if(orbisPadConf->padHandle>0) - { - orbisPadConf->orbispad_initialized=1; - - } - - } - } - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISPAD] %s liborbispad initialized\n",__FUNCTION__); - - return orbisPadConf->orbispad_initialized; -} - diff --git a/source/libplini/LICENSE b/source/libplini/LICENSE deleted file mode 100644 index 19dc35b..0000000 --- a/source/libplini/LICENSE +++ /dev/null @@ -1,175 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. \ No newline at end of file diff --git a/source/libplini/pl_ini.c b/source/libplini/pl_ini.c deleted file mode 100644 index 1455402..0000000 --- a/source/libplini/pl_ini.c +++ /dev/null @@ -1,516 +0,0 @@ -// Copyright 2007-2015 Akop Karapetyan -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "pl_ini.h" -#include -#include -#include -#include -#include -#include -#include -#define PL_MAX_LINE_LENGTH 512 - -typedef struct pl_ini_pair_t -{ - char *key; - char *value; - struct pl_ini_pair_t *next; -} pl_ini_pair; - -typedef struct pl_ini_section_t -{ - char *name; - struct pl_ini_pair_t *head; - struct pl_ini_section_t *next; -} pl_ini_section; - -pl_ini_section* create_section(const char *name); -pl_ini_pair* create_pair(char *string); -pl_ini_section* find_section(const pl_ini_file *file, - const char *section_name); -pl_ini_pair* find_pair(const pl_ini_section *section, - const char *key_name); -pl_ini_pair* locate(const pl_ini_file *file, - const char *section_name, - const char *key_name); -pl_ini_pair* locate_or_create(pl_ini_file *file, - const char *section_name, - const char *key_name); - -int pl_ini_create(pl_ini_file *file) -{ - file->head = NULL; - return 1; -} -int pl_ini_load_from_nfs(pl_ini_file *file, const char *path) -{ - file->head = NULL; - - int fd; - fd = orbisNfsOpen(path,O_RDONLY, 0777); - if(fd<0) - return 0; - - pl_ini_section *current_section = NULL; - pl_ini_pair *tail; - - char string[PL_MAX_LINE_LENGTH], - name[PL_MAX_LINE_LENGTH]; - char *ptr; - int len; - - /* Create unnamed section */ - current_section = NULL; - tail = NULL; - int ret=orbisNfsRead(fd,string,sizeof(string)); - if(ret>0) - { - /* TODO: Skip whitespace */ - /* New section */ - if (string[0] == '[') - { - if ((ptr = strrchr(string, ']'))) - { - len = ptr - string - 1; - strncpy(name, string + 1, len); - name[len] = '\0'; - - if (!current_section) - current_section = file->head = create_section(name); - else - { - current_section->next = create_section(name); - current_section = current_section->next; - } - - tail = NULL; - } - } - else if (string[0] =='#'); /* Do nothing - comment */ - else - { - /* No section defined - create empty section */ - if (!current_section) - { - current_section = create_section(strdup("")); - file->head = current_section; - tail = NULL; - } - - pl_ini_pair *pair = create_pair(string); - if (pair) - { - if (tail) tail->next = pair; - else current_section->head = pair; - tail = pair; - } - } - } - - orbisNfsClose(fd); - return 1; - -} -int pl_ini_load_from_data(pl_ini_file *file, - const char *path) -{ - file->head = NULL; - - int fd; - fd=open(path,O_RDONLY, 0777); - if(fd<0) - return 0; - - pl_ini_section *current_section = NULL; - pl_ini_pair *tail; - - char string[PL_MAX_LINE_LENGTH], - name[PL_MAX_LINE_LENGTH]; - char *ptr; - int len; - - /* Create unnamed section */ - current_section = NULL; - tail = NULL; - int ret=read(fd,string,sizeof(string)); - if(ret>0) - { - /* TODO: Skip whitespace */ - /* New section */ - if (string[0] == '[') - { - if ((ptr = strrchr(string, ']'))) - { - len = ptr - string - 1; - strncpy(name, string + 1, len); - name[len] = '\0'; - - if (!current_section) - current_section = file->head = create_section(name); - else - { - current_section->next = create_section(name); - current_section = current_section->next; - } - - tail = NULL; - } - } - else if (string[0] =='#'); /* Do nothing - comment */ - else - { - /* No section defined - create empty section */ - if (!current_section) - { - current_section = create_section(strdup("")); - file->head = current_section; - tail = NULL; - } - - pl_ini_pair *pair = create_pair(string); - if (pair) - { - if (tail) tail->next = pair; - else current_section->head = pair; - tail = pair; - } - } - } - - close(fd); - return 1; -} - - - -int pl_ini_load(pl_ini_file *file, - const char *path) -{ - file->head = NULL; - - FILE *stream; - if (!(stream = fopen(path, "r"))) - return 0; - - pl_ini_section *current_section = NULL; - pl_ini_pair *tail; - - char string[PL_MAX_LINE_LENGTH], - name[PL_MAX_LINE_LENGTH]; - char *ptr; - int len; - - /* Create unnamed section */ - current_section = NULL; - tail = NULL; - char *retfget= fgets(string, sizeof(string), stream); - int retfeof=feof(stream); - //debugNetPrintf(3,"[PL] before while refget=%s retfeof=%d\n",retfget,retfeof); - - while(retfget) - { - - - /* TODO: Skip whitespace */ - /* New section */ - //debugNetPrintf(3,"[PL] %s\n%s\n",__FUNCTION__,string); - if (string[0] == '[') - { - if ((ptr = strrchr(string, ']'))) - { - len = ptr - string - 1; - strncpy(name, string + 1, len); - name[len] = '\0'; - - if (!current_section) - current_section = file->head = create_section(name); - else - { - current_section->next = create_section(name); - current_section = current_section->next; - } - - tail = NULL; - } - } - else if (string[0] =='#'); /* Do nothing - comment */ - else - { - /* No section defined - create empty section */ - if (!current_section) - { - current_section = create_section(strdup("")); - file->head = current_section; - tail = NULL; - } - - pl_ini_pair *pair = create_pair(string); - if (pair) - { - if (tail) tail->next = pair; - else current_section->head = pair; - tail = pair; - } - } - retfget= fgets(string, sizeof(string), stream); - retfeof=feof(stream); - //debugNetPrintf(3,"[PL] refget=%s retfeof=%d\n",retfget,retfeof); - } - - fclose(stream); - return 1; -} - -int pl_ini_save(const pl_ini_file *file, - const char *path) -{ - FILE *stream; - if (!(stream = fopen(path, "w"))) - return 0; - - pl_ini_section *section; - pl_ini_pair *pair; - - for (section = file->head; section; section = section->next) - { - fprintf(stream, "[%s]\n", section->name); - for (pair = section->head; pair; pair = pair->next) - fprintf(stream, "%s=%s\n", pair->key, pair->value); - } - - fclose(stream); - return 1; -} - -int pl_ini_get_int(const pl_ini_file *file, - const char *section, - const char *key, - int default_value) -{ - pl_ini_pair *pair = locate(file, section, key); - return (pair) ? atoi(pair->value) : default_value; -} - -int pl_ini_get_string(const pl_ini_file *file, - const char *section, - const char *key, - const char *default_value, - char *copy_to, - int dest_len) -{ - pl_ini_pair *pair = locate(file, section, key); - if (pair) - { - strncpy(copy_to, pair->value, dest_len); - return 1; - } - else if (default_value) - { - strncpy(copy_to, default_value, dest_len); - return 1; - } - - return 0; -} - -void pl_ini_set_int(pl_ini_file *file, - const char *section, - const char *key, - int value) -{ - pl_ini_pair *pair; - if (!(pair = locate_or_create(file, section, key))) - return; - - /* Replace the value */ - if (pair->value) - free(pair->value); - - char temp[64]; - snprintf(temp, 63, "%i", value); - pair->value = strdup(temp); -} - -void pl_ini_set_string(pl_ini_file *file, - const char *section, - const char *key, - const char *string) -{ - pl_ini_pair *pair; - if (!(pair = locate_or_create(file, section, key))) - return; - - /* Replace the value */ - if (pair->value) - free(pair->value); - pair->value = strdup(string); -} - -void pl_ini_destroy(pl_ini_file *file) -{ - pl_ini_section *section, *next_section; - pl_ini_pair *pair, *next_pair; - - for (section = file->head; section; section = next_section) - { - next_section = section->next; - - if (section->name) - free(section->name); - for (pair = section->head; pair; pair = next_pair) - { - next_pair = pair->next; - if (pair->key) - free(pair->key); - if (pair->value) - free(pair->value); - free(pair); - } - - free(section); - } -} - -pl_ini_section* find_section(const pl_ini_file *file, - const char *section_name) -{ - pl_ini_section *section; - for (section = file->head; section; section = section->next) - if (strcmp(section_name, section->name) == 0) - return section; - - return NULL; -} - -pl_ini_pair* find_pair(const pl_ini_section *section, - const char *key_name) -{ - pl_ini_pair *pair; - for (pair = section->head; pair; pair = pair->next) - if (strcmp(pair->key, key_name) == 0) - return pair; - - return NULL; -} - -pl_ini_pair* locate(const pl_ini_file *file, - const char *section_name, - const char *key_name) -{ - pl_ini_section *section; - if (!(section = find_section(file, section_name))) - return NULL; - - return find_pair(section, key_name); -} - -pl_ini_pair* locate_or_create(pl_ini_file *file, - const char *section_name, - const char *key_name) -{ - pl_ini_section *section = find_section(file, section_name); - pl_ini_pair *pair = NULL; - - if (section) - pair = find_pair(section, key_name); - else - { - /* Create section */ - section = create_section(section_name); - - if (!file->head) - file->head = section; - else - { - pl_ini_section *s; - for (s = file->head; s->next; s = s->next); /* Find the tail */ - s->next = section; - } - } - - if (!pair) - { - /* Create pair */ - pair = (pl_ini_pair*)malloc(sizeof(pl_ini_pair)); - pair->key = strdup(key_name); - pair->value = NULL; - pair->next = NULL; - - if (!section->head) - section->head = pair; - else - { - pl_ini_pair *p; - for (p = section->head; p->next; p = p->next); /* Find the tail */ - p->next = pair; - } - } - - return pair; -} - -pl_ini_section* create_section(const char *name) -{ - pl_ini_section *section - = (pl_ini_section*)malloc(sizeof(pl_ini_section)); - section->head = NULL; - section->next = NULL; - section->name = strdup(name); - - return section; -} - -pl_ini_pair* create_pair(char *string) -{ - char *ptr; - if (!(ptr = strchr(string, '='))) - return NULL; - - int len; - char *name, *value; - - /* Copy NAME */ - len = ptr - string; - if (!(name = (char*)malloc(sizeof(char) * (len + 1)))) - return NULL; - strncpy(name, string, len); - name[len] = '\0'; - - /* Copy VALUE */ - if (!(value = strdup(ptr + 1))) - { - free(name); - return NULL; - } - - len = strlen(value); - if (value[len - 1] == '\n') value[len - 1] = '\0'; - - /* Create struct */ - pl_ini_pair *pair = (pl_ini_pair*)malloc(sizeof(pl_ini_pair)); - - if (!pair) - { - free(name); - free(value); - return NULL; - } - - pair->key = name; - pair->value = value; - pair->next = NULL; - - return pair; -} \ No newline at end of file diff --git a/source/libpng/LICENSE b/source/libpng/LICENSE deleted file mode 100644 index e5ec839..0000000 --- a/source/libpng/LICENSE +++ /dev/null @@ -1,96 +0,0 @@ -This copy of the libpng notices is provided for your convenience. In case of -any discrepancy between this copy and the notices in the file png.h that is -included in the libpng distribution, the latter shall prevail. - -/* - * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: - * - * If you modify libpng you may insert additional notices immediately following - * this sentence. - * - * This code is released under the libpng license. - * - * libpng versions 1.2.6, August 15, 2004, through 1.5.10, March 29, 2012, are - * Copyright (c) 2004, 2006-2012 Glenn Randers-Pehrson, and are - * distributed according to the same disclaimer and license as libpng-1.2.5 - * with the following individual added to the list of Contributing Authors: - * - * Cosmin Truta - * - * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are - * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are - * distributed according to the same disclaimer and license as libpng-1.0.6 - * with the following individuals added to the list of Contributing Authors: - * - * Simon-Pierre Cadieux - * Eric S. Raymond - * Gilles Vollant - * - * and with the following additions to the disclaimer: - * - * There is no warranty against interference with your enjoyment of the - * library or against infringement. There is no warranty that our - * efforts or the library will fulfill any of your particular purposes - * or needs. This library is provided with all faults, and the entire - * risk of satisfactory quality, performance, accuracy, and effort is with - * the user. - * - * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are - * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are - * distributed according to the same disclaimer and license as libpng-0.96, - * with the following individuals added to the list of Contributing Authors: - * - * Tom Lane - * Glenn Randers-Pehrson - * Willem van Schaik - * - * libpng versions 0.89, June 1996, through 0.96, May 1997, are - * Copyright (c) 1996, 1997 Andreas Dilger - * Distributed according to the same disclaimer and license as libpng-0.88, - * with the following individuals added to the list of Contributing Authors: - * - * John Bowler - * Kevin Bracey - * Sam Bushell - * Magnus Holmgren - * Greg Roelofs - * Tom Tanner - * - * libpng versions 0.5, May 1995, through 0.88, January 1996, are - * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. - * - * For the purposes of this copyright and license, "Contributing Authors" - * is defined as the following set of individuals: - * - * Andreas Dilger - * Dave Martindale - * Guy Eric Schalnat - * Paul Schmidt - * Tim Wegner - * - * The PNG Reference Library is supplied "AS IS". The Contributing Authors - * and Group 42, Inc. disclaim all warranties, expressed or implied, - * including, without limitation, the warranties of merchantability and of - * fitness for any purpose. The Contributing Authors and Group 42, Inc. - * assume no liability for direct, indirect, incidental, special, exemplary, - * or consequential damages, which may result from the use of the PNG - * Reference Library, even if advised of the possibility of such damage. - * - * Permission is hereby granted to use, copy, modify, and distribute this - * source code, or portions hereof, for any purpose, without fee, subject - * to the following restrictions: - * - * 1. The origin of this source code must not be misrepresented. - * - * 2. Altered versions must be plainly marked as such and must not - * be misrepresented as being the original source. - * - * 3. This Copyright notice may not be removed or altered from - * any source or altered source distribution. - * - * The Contributing Authors and Group 42, Inc. specifically permit, without - * fee, and encourage the use of this source code as a component to - * supporting the PNG file format in commercial products. If you use this - * source code in a product, acknowledgment is not required but would be - * appreciated. - */ \ No newline at end of file diff --git a/source/libpng/png.c b/source/libpng/png.c deleted file mode 100644 index 988dcaa..0000000 --- a/source/libpng/png.c +++ /dev/null @@ -1,2874 +0,0 @@ - -/* png.c - location for general purpose libpng functions - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -#include "pngpriv.h" - -/* Generate a compiler error if there is an old png.h in the search path. */ -typedef png_libpng_version_1_5_10 Your_png_h_is_not_version_1_5_10; - -/* Tells libpng that we have already handled the first "num_bytes" bytes - * of the PNG file signature. If the PNG data is embedded into another - * stream we can set num_bytes = 8 so that libpng will not attempt to read - * or write any of the magic bytes before it starts on the IHDR. - */ - -#ifdef PNG_READ_SUPPORTED -void PNGAPI -png_set_sig_bytes(png_structp png_ptr, int num_bytes) -{ - png_debug(1, "in png_set_sig_bytes"); - - if (png_ptr == NULL) - return; - - if (num_bytes > 8) - png_error(png_ptr, "Too many bytes for PNG signature"); - - png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); -} - -/* Checks whether the supplied bytes match the PNG signature. We allow - * checking less than the full 8-byte signature so that those apps that - * already read the first few bytes of a file to determine the file type - * can simply check the remaining bytes for extra assurance. Returns - * an integer less than, equal to, or greater than zero if sig is found, - * respectively, to be less than, to match, or be greater than the correct - * PNG signature (this is the same behavior as strcmp, memcmp, etc). - */ -int PNGAPI -png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check) -{ - png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; - - if (num_to_check > 8) - num_to_check = 8; - - else if (num_to_check < 1) - return (-1); - - if (start > 7) - return (-1); - - if (start + num_to_check > 8) - num_to_check = 8 - start; - - return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); -} - -#endif /* PNG_READ_SUPPORTED */ - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) -/* Function to allocate memory for zlib */ -PNG_FUNCTION(voidpf /* PRIVATE */, -png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED) -{ - png_voidp ptr; - png_structp p=(png_structp)png_ptr; - png_uint_32 save_flags=p->flags; - png_alloc_size_t num_bytes; - - if (png_ptr == NULL) - return (NULL); - - if (items > PNG_UINT_32_MAX/size) - { - png_warning (p, "Potential overflow in png_zalloc()"); - return (NULL); - } - num_bytes = (png_alloc_size_t)items * size; - - p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; - ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); - p->flags=save_flags; - - return ((voidpf)ptr); -} - -/* Function to free memory for zlib */ -void /* PRIVATE */ -png_zfree(voidpf png_ptr, voidpf ptr) -{ - png_free((png_structp)png_ptr, (png_voidp)ptr); -} - -/* Reset the CRC variable to 32 bits of 1's. Care must be taken - * in case CRC is > 32 bits to leave the top bits 0. - */ -void /* PRIVATE */ -png_reset_crc(png_structp png_ptr) -{ - /* The cast is safe because the crc is a 32 bit value. */ - png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0); -} - -/* Calculate the CRC over a section of data. We can only pass as - * much data to this routine as the largest single buffer size. We - * also check that this data will actually be used before going to the - * trouble of calculating it. - */ -void /* PRIVATE */ -png_calculate_crc(png_structp png_ptr, png_const_bytep ptr, png_size_t length) -{ - int need_crc = 1; - - if (PNG_CHUNK_ANCILLIARY(png_ptr->chunk_name)) - { - if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == - (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) - need_crc = 0; - } - - else /* critical */ - { - if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) - need_crc = 0; - } - - /* 'uLong' is defined as unsigned long, this means that on some systems it is - * a 64 bit value. crc32, however, returns 32 bits so the following cast is - * safe. 'uInt' may be no more than 16 bits, so it is necessary to perform a - * loop here. - */ - if (need_crc && length > 0) - { - uLong crc = png_ptr->crc; /* Should never issue a warning */ - - do - { - uInt safeLength = (uInt)length; - if (safeLength == 0) - safeLength = (uInt)-1; /* evil, but safe */ - - crc = crc32(crc, ptr, safeLength); - - /* The following should never issue compiler warnings, if they do the - * target system has characteristics that will probably violate other - * assumptions within the libpng code. - */ - ptr += safeLength; - length -= safeLength; - } - while (length > 0); - - /* And the following is always safe because the crc is only 32 bits. */ - png_ptr->crc = (png_uint_32)crc; - } -} - -/* Check a user supplied version number, called from both read and write - * functions that create a png_struct - */ -int -png_user_version_check(png_structp png_ptr, png_const_charp user_png_ver) -{ - if (user_png_ver) - { - int i = 0; - - do - { - if (user_png_ver[i] != png_libpng_ver[i]) - png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; - } while (png_libpng_ver[i++]); - } - - else - png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; - - if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) - { - /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so - * we must recompile any applications that use any older library version. - * For versions after libpng 1.0, we will be compatible, so we need - * only check the first digit. - */ - if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || - (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || - (user_png_ver[0] == '0' && user_png_ver[2] < '9')) - { -#ifdef PNG_WARNINGS_SUPPORTED - size_t pos = 0; - char m[128]; - - pos = png_safecat(m, sizeof m, pos, "Application built with libpng-"); - pos = png_safecat(m, sizeof m, pos, user_png_ver); - pos = png_safecat(m, sizeof m, pos, " but running with "); - pos = png_safecat(m, sizeof m, pos, png_libpng_ver); - - png_warning(png_ptr, m); -#endif - -#ifdef PNG_ERROR_NUMBERS_SUPPORTED - png_ptr->flags = 0; -#endif - - return 0; - } - } - - /* Success return. */ - return 1; -} - -/* Allocate the memory for an info_struct for the application. We don't - * really need the png_ptr, but it could potentially be useful in the - * future. This should be used in favour of malloc(png_sizeof(png_info)) - * and png_info_init() so that applications that want to use a shared - * libpng don't have to be recompiled if png_info changes size. - */ -PNG_FUNCTION(png_infop,PNGAPI -png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED) -{ - png_infop info_ptr; - - png_debug(1, "in png_create_info_struct"); - - if (png_ptr == NULL) - return (NULL); - -#ifdef PNG_USER_MEM_SUPPORTED - info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, - png_ptr->malloc_fn, png_ptr->mem_ptr); -#else - info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); -#endif - if (info_ptr != NULL) - png_info_init_3(&info_ptr, png_sizeof(png_info)); - - return (info_ptr); -} - -/* This function frees the memory associated with a single info struct. - * Normally, one would use either png_destroy_read_struct() or - * png_destroy_write_struct() to free an info struct, but this may be - * useful for some applications. - */ -void PNGAPI -png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) -{ - png_infop info_ptr = NULL; - - png_debug(1, "in png_destroy_info_struct"); - - if (png_ptr == NULL) - return; - - if (info_ptr_ptr != NULL) - info_ptr = *info_ptr_ptr; - - if (info_ptr != NULL) - { - png_info_destroy(png_ptr, info_ptr); - -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, - png_ptr->mem_ptr); -#else - png_destroy_struct((png_voidp)info_ptr); -#endif - *info_ptr_ptr = NULL; - } -} - -/* Initialize the info structure. This is now an internal function (0.89) - * and applications using it are urged to use png_create_info_struct() - * instead. - */ - -void PNGAPI -png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) -{ - png_infop info_ptr = *ptr_ptr; - - png_debug(1, "in png_info_init_3"); - - if (info_ptr == NULL) - return; - - if (png_sizeof(png_info) > png_info_struct_size) - { - png_destroy_struct(info_ptr); - info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); - *ptr_ptr = info_ptr; - } - - /* Set everything to 0 */ - png_memset(info_ptr, 0, png_sizeof(png_info)); -} - -void PNGAPI -png_data_freer(png_structp png_ptr, png_infop info_ptr, - int freer, png_uint_32 mask) -{ - png_debug(1, "in png_data_freer"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - if (freer == PNG_DESTROY_WILL_FREE_DATA) - info_ptr->free_me |= mask; - - else if (freer == PNG_USER_WILL_FREE_DATA) - info_ptr->free_me &= ~mask; - - else - png_warning(png_ptr, - "Unknown freer parameter in png_data_freer"); -} - -void PNGAPI -png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, - int num) -{ - png_debug(1, "in png_free_data"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - -#ifdef PNG_TEXT_SUPPORTED - /* Free text item num or (if num == -1) all text items */ - if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) - { - if (num != -1) - { - if (info_ptr->text && info_ptr->text[num].key) - { - png_free(png_ptr, info_ptr->text[num].key); - info_ptr->text[num].key = NULL; - } - } - - else - { - int i; - for (i = 0; i < info_ptr->num_text; i++) - png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); - png_free(png_ptr, info_ptr->text); - info_ptr->text = NULL; - info_ptr->num_text=0; - } - } -#endif - -#ifdef PNG_tRNS_SUPPORTED - /* Free any tRNS entry */ - if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) - { - png_free(png_ptr, info_ptr->trans_alpha); - info_ptr->trans_alpha = NULL; - info_ptr->valid &= ~PNG_INFO_tRNS; - } -#endif - -#ifdef PNG_sCAL_SUPPORTED - /* Free any sCAL entry */ - if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) - { - png_free(png_ptr, info_ptr->scal_s_width); - png_free(png_ptr, info_ptr->scal_s_height); - info_ptr->scal_s_width = NULL; - info_ptr->scal_s_height = NULL; - info_ptr->valid &= ~PNG_INFO_sCAL; - } -#endif - -#ifdef PNG_pCAL_SUPPORTED - /* Free any pCAL entry */ - if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) - { - png_free(png_ptr, info_ptr->pcal_purpose); - png_free(png_ptr, info_ptr->pcal_units); - info_ptr->pcal_purpose = NULL; - info_ptr->pcal_units = NULL; - if (info_ptr->pcal_params != NULL) - { - int i; - for (i = 0; i < (int)info_ptr->pcal_nparams; i++) - { - png_free(png_ptr, info_ptr->pcal_params[i]); - info_ptr->pcal_params[i] = NULL; - } - png_free(png_ptr, info_ptr->pcal_params); - info_ptr->pcal_params = NULL; - } - info_ptr->valid &= ~PNG_INFO_pCAL; - } -#endif - -#ifdef PNG_iCCP_SUPPORTED - /* Free any iCCP entry */ - if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) - { - png_free(png_ptr, info_ptr->iccp_name); - png_free(png_ptr, info_ptr->iccp_profile); - info_ptr->iccp_name = NULL; - info_ptr->iccp_profile = NULL; - info_ptr->valid &= ~PNG_INFO_iCCP; - } -#endif - -#ifdef PNG_sPLT_SUPPORTED - /* Free a given sPLT entry, or (if num == -1) all sPLT entries */ - if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) - { - if (num != -1) - { - if (info_ptr->splt_palettes) - { - png_free(png_ptr, info_ptr->splt_palettes[num].name); - png_free(png_ptr, info_ptr->splt_palettes[num].entries); - info_ptr->splt_palettes[num].name = NULL; - info_ptr->splt_palettes[num].entries = NULL; - } - } - - else - { - if (info_ptr->splt_palettes_num) - { - int i; - for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) - png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); - - png_free(png_ptr, info_ptr->splt_palettes); - info_ptr->splt_palettes = NULL; - info_ptr->splt_palettes_num = 0; - } - info_ptr->valid &= ~PNG_INFO_sPLT; - } - } -#endif - -#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED - if (png_ptr->unknown_chunk.data) - { - png_free(png_ptr, png_ptr->unknown_chunk.data); - png_ptr->unknown_chunk.data = NULL; - } - - if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) - { - if (num != -1) - { - if (info_ptr->unknown_chunks) - { - png_free(png_ptr, info_ptr->unknown_chunks[num].data); - info_ptr->unknown_chunks[num].data = NULL; - } - } - - else - { - int i; - - if (info_ptr->unknown_chunks_num) - { - for (i = 0; i < info_ptr->unknown_chunks_num; i++) - png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); - - png_free(png_ptr, info_ptr->unknown_chunks); - info_ptr->unknown_chunks = NULL; - info_ptr->unknown_chunks_num = 0; - } - } - } -#endif - -#ifdef PNG_hIST_SUPPORTED - /* Free any hIST entry */ - if ((mask & PNG_FREE_HIST) & info_ptr->free_me) - { - png_free(png_ptr, info_ptr->hist); - info_ptr->hist = NULL; - info_ptr->valid &= ~PNG_INFO_hIST; - } -#endif - - /* Free any PLTE entry that was internally allocated */ - if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) - { - png_zfree((voidpf)png_ptr, (voidpf)info_ptr->palette); - info_ptr->palette = NULL; - info_ptr->valid &= ~PNG_INFO_PLTE; - info_ptr->num_palette = 0; - } - -#ifdef PNG_INFO_IMAGE_SUPPORTED - /* Free any image bits attached to the info structure */ - if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) - { - if (info_ptr->row_pointers) - { - int row; - for (row = 0; row < (int)info_ptr->height; row++) - { - png_free(png_ptr, info_ptr->row_pointers[row]); - info_ptr->row_pointers[row] = NULL; - } - png_free(png_ptr, info_ptr->row_pointers); - info_ptr->row_pointers = NULL; - } - info_ptr->valid &= ~PNG_INFO_IDAT; - } -#endif - - if (num != -1) - mask &= ~PNG_FREE_MUL; - - info_ptr->free_me &= ~mask; -} - -/* This is an internal routine to free any memory that the info struct is - * pointing to before re-using it or freeing the struct itself. Recall - * that png_free() checks for NULL pointers for us. - */ -void /* PRIVATE */ -png_info_destroy(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_info_destroy"); - - png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - if (png_ptr->num_chunk_list) - { - png_free(png_ptr, png_ptr->chunk_list); - png_ptr->chunk_list = NULL; - png_ptr->num_chunk_list = 0; - } -#endif - - png_info_init_3(&info_ptr, png_sizeof(png_info)); -} -#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ - -/* This function returns a pointer to the io_ptr associated with the user - * functions. The application should free any memory associated with this - * pointer before png_write_destroy() or png_read_destroy() are called. - */ -png_voidp PNGAPI -png_get_io_ptr(png_structp png_ptr) -{ - if (png_ptr == NULL) - return (NULL); - - return (png_ptr->io_ptr); -} - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) -# ifdef PNG_STDIO_SUPPORTED -/* Initialize the default input/output functions for the PNG file. If you - * use your own read or write routines, you can call either png_set_read_fn() - * or png_set_write_fn() instead of png_init_io(). If you have defined - * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a - * function of your own because "FILE *" isn't necessarily available. - */ -void PNGAPI -png_init_io(png_structp png_ptr, png_FILE_p fp) -{ - png_debug(1, "in png_init_io"); - - if (png_ptr == NULL) - return; - - png_ptr->io_ptr = (png_voidp)fp; -} -# endif - -# ifdef PNG_TIME_RFC1123_SUPPORTED -/* Convert the supplied time into an RFC 1123 string suitable for use in - * a "Creation Time" or other text-based time string. - */ -png_const_charp PNGAPI -png_convert_to_rfc1123(png_structp png_ptr, png_const_timep ptime) -{ - static PNG_CONST char short_months[12][4] = - {"Jan", "Feb", "Mar", "Apr", "May", "Jun", - "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; - - if (png_ptr == NULL) - return (NULL); - - if (ptime->year > 9999 /* RFC1123 limitation */ || - ptime->month == 0 || ptime->month > 12 || - ptime->day == 0 || ptime->day > 31 || - ptime->hour > 23 || ptime->minute > 59 || - ptime->second > 60) - { - png_warning(png_ptr, "Ignoring invalid time value"); - return (NULL); - } - - { - size_t pos = 0; - char number_buf[5]; /* enough for a four-digit year */ - -# define APPEND_STRING(string)\ - pos = png_safecat(png_ptr->time_buffer, sizeof png_ptr->time_buffer,\ - pos, (string)) -# define APPEND_NUMBER(format, value)\ - APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value))) -# define APPEND(ch)\ - if (pos < (sizeof png_ptr->time_buffer)-1)\ - png_ptr->time_buffer[pos++] = (ch) - - APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day); - APPEND(' '); - APPEND_STRING(short_months[(ptime->month - 1)]); - APPEND(' '); - APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year); - APPEND(' '); - APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour); - APPEND(':'); - APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute); - APPEND(':'); - APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second); - APPEND_STRING(" +0000"); /* This reliably terminates the buffer */ - -# undef APPEND -# undef APPEND_NUMBER -# undef APPEND_STRING - } - - return png_ptr->time_buffer; -} -# endif /* PNG_TIME_RFC1123_SUPPORTED */ - -#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ - -png_const_charp PNGAPI -png_get_copyright(png_const_structp png_ptr) -{ - PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ -#ifdef PNG_STRING_COPYRIGHT - return PNG_STRING_COPYRIGHT -#else -# ifdef __STDC__ - return PNG_STRING_NEWLINE \ - "libpng version 1.5.10 - March 29, 2012" PNG_STRING_NEWLINE \ - "Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ - "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ - "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ - PNG_STRING_NEWLINE; -# else - return "libpng version 1.5.10 - March 29, 2012\ - Copyright (c) 1998-2011 Glenn Randers-Pehrson\ - Copyright (c) 1996-1997 Andreas Dilger\ - Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; -# endif -#endif -} - -/* The following return the library version as a short string in the - * format 1.0.0 through 99.99.99zz. To get the version of *.h files - * used with your application, print out PNG_LIBPNG_VER_STRING, which - * is defined in png.h. - * Note: now there is no difference between png_get_libpng_ver() and - * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, - * it is guaranteed that png.c uses the correct version of png.h. - */ -png_const_charp PNGAPI -png_get_libpng_ver(png_const_structp png_ptr) -{ - /* Version of *.c files used when building libpng */ - return png_get_header_ver(png_ptr); -} - -png_const_charp PNGAPI -png_get_header_ver(png_const_structp png_ptr) -{ - /* Version of *.h files used when building libpng */ - PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ - return PNG_LIBPNG_VER_STRING; -} - -png_const_charp PNGAPI -png_get_header_version(png_const_structp png_ptr) -{ - /* Returns longer string containing both version and date */ - PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ -#ifdef __STDC__ - return PNG_HEADER_VERSION_STRING -# ifndef PNG_READ_SUPPORTED - " (NO READ SUPPORT)" -# endif - PNG_STRING_NEWLINE; -#else - return PNG_HEADER_VERSION_STRING; -#endif -} - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -int PNGAPI -png_handle_as_unknown(png_structp png_ptr, png_const_bytep chunk_name) -{ - /* Check chunk_name and return "keep" value if it's on the list, else 0 */ - png_const_bytep p, p_end; - - if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list <= 0) - return PNG_HANDLE_CHUNK_AS_DEFAULT; - - p_end = png_ptr->chunk_list; - p = p_end + png_ptr->num_chunk_list*5; /* beyond end */ - - /* The code is the fifth byte after each four byte string. Historically this - * code was always searched from the end of the list, so it should continue - * to do so in case there are duplicated entries. - */ - do /* num_chunk_list > 0, so at least one */ - { - p -= 5; - if (!png_memcmp(chunk_name, p, 4)) - return p[4]; - } - while (p > p_end); - - return PNG_HANDLE_CHUNK_AS_DEFAULT; -} - -int /* PRIVATE */ -png_chunk_unknown_handling(png_structp png_ptr, png_uint_32 chunk_name) -{ - png_byte chunk_string[5]; - - PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name); - return png_handle_as_unknown(png_ptr, chunk_string); -} -#endif - -#ifdef PNG_READ_SUPPORTED -/* This function, added to libpng-1.0.6g, is untested. */ -int PNGAPI -png_reset_zstream(png_structp png_ptr) -{ - if (png_ptr == NULL) - return Z_STREAM_ERROR; - - return (inflateReset(&png_ptr->zstream)); -} -#endif /* PNG_READ_SUPPORTED */ - -/* This function was added to libpng-1.0.7 */ -png_uint_32 PNGAPI -png_access_version_number(void) -{ - /* Version of *.c files used when building libpng */ - return((png_uint_32)PNG_LIBPNG_VER); -} - - - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) -/* png_convert_size: a PNGAPI but no longer in png.h, so deleted - * at libpng 1.5.5! - */ - -/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */ -# ifdef PNG_CHECK_cHRM_SUPPORTED - -int /* PRIVATE */ -png_check_cHRM_fixed(png_structp png_ptr, - png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, - png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, - png_fixed_point blue_x, png_fixed_point blue_y) -{ - int ret = 1; - unsigned long xy_hi,xy_lo,yx_hi,yx_lo; - - png_debug(1, "in function png_check_cHRM_fixed"); - - if (png_ptr == NULL) - return 0; - - /* (x,y,z) values are first limited to 0..100000 (PNG_FP_1), the white - * y must also be greater than 0. To test for the upper limit calculate - * (PNG_FP_1-y) - x must be <= to this for z to be >= 0 (and the expression - * cannot overflow.) At this point we know x and y are >= 0 and (x+y) is - * <= PNG_FP_1. The previous test on PNG_MAX_UINT_31 is removed because it - * pointless (and it produces compiler warnings!) - */ - if (white_x < 0 || white_y <= 0 || - red_x < 0 || red_y < 0 || - green_x < 0 || green_y < 0 || - blue_x < 0 || blue_y < 0) - { - png_warning(png_ptr, - "Ignoring attempt to set negative chromaticity value"); - ret = 0; - } - /* And (x+y) must be <= PNG_FP_1 (so z is >= 0) */ - if (white_x > PNG_FP_1 - white_y) - { - png_warning(png_ptr, "Invalid cHRM white point"); - ret = 0; - } - - if (red_x > PNG_FP_1 - red_y) - { - png_warning(png_ptr, "Invalid cHRM red point"); - ret = 0; - } - - if (green_x > PNG_FP_1 - green_y) - { - png_warning(png_ptr, "Invalid cHRM green point"); - ret = 0; - } - - if (blue_x > PNG_FP_1 - blue_y) - { - png_warning(png_ptr, "Invalid cHRM blue point"); - ret = 0; - } - - png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo); - png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo); - - if (xy_hi == yx_hi && xy_lo == yx_lo) - { - png_warning(png_ptr, - "Ignoring attempt to set cHRM RGB triangle with zero area"); - ret = 0; - } - - return ret; -} -# endif /* PNG_CHECK_cHRM_SUPPORTED */ - -#ifdef PNG_cHRM_SUPPORTED -/* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for - * cHRM, as opposed to using chromaticities. These internal APIs return - * non-zero on a parameter error. The X, Y and Z values are required to be - * positive and less than 1.0. - */ -int png_xy_from_XYZ(png_xy *xy, png_XYZ XYZ) -{ - png_int_32 d, dwhite, whiteX, whiteY; - - d = XYZ.redX + XYZ.redY + XYZ.redZ; - if (!png_muldiv(&xy->redx, XYZ.redX, PNG_FP_1, d)) return 1; - if (!png_muldiv(&xy->redy, XYZ.redY, PNG_FP_1, d)) return 1; - dwhite = d; - whiteX = XYZ.redX; - whiteY = XYZ.redY; - - d = XYZ.greenX + XYZ.greenY + XYZ.greenZ; - if (!png_muldiv(&xy->greenx, XYZ.greenX, PNG_FP_1, d)) return 1; - if (!png_muldiv(&xy->greeny, XYZ.greenY, PNG_FP_1, d)) return 1; - dwhite += d; - whiteX += XYZ.greenX; - whiteY += XYZ.greenY; - - d = XYZ.blueX + XYZ.blueY + XYZ.blueZ; - if (!png_muldiv(&xy->bluex, XYZ.blueX, PNG_FP_1, d)) return 1; - if (!png_muldiv(&xy->bluey, XYZ.blueY, PNG_FP_1, d)) return 1; - dwhite += d; - whiteX += XYZ.blueX; - whiteY += XYZ.blueY; - - /* The reference white is simply the same of the end-point (X,Y,Z) vectors, - * thus: - */ - if (!png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite)) return 1; - if (!png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite)) return 1; - - return 0; -} - -int png_XYZ_from_xy(png_XYZ *XYZ, png_xy xy) -{ - png_fixed_point red_inverse, green_inverse, blue_scale; - png_fixed_point left, right, denominator; - - /* Check xy and, implicitly, z. Note that wide gamut color spaces typically - * have end points with 0 tristimulus values (these are impossible end - * points, but they are used to cover the possible colors.) - */ - if (xy.redx < 0 || xy.redx > PNG_FP_1) return 1; - if (xy.redy < 0 || xy.redy > PNG_FP_1-xy.redx) return 1; - if (xy.greenx < 0 || xy.greenx > PNG_FP_1) return 1; - if (xy.greeny < 0 || xy.greeny > PNG_FP_1-xy.greenx) return 1; - if (xy.bluex < 0 || xy.bluex > PNG_FP_1) return 1; - if (xy.bluey < 0 || xy.bluey > PNG_FP_1-xy.bluex) return 1; - if (xy.whitex < 0 || xy.whitex > PNG_FP_1) return 1; - if (xy.whitey < 0 || xy.whitey > PNG_FP_1-xy.whitex) return 1; - - /* The reverse calculation is more difficult because the original tristimulus - * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8 - * derived values were recorded in the cHRM chunk; - * (red,green,blue,white)x(x,y). This loses one degree of freedom and - * therefore an arbitrary ninth value has to be introduced to undo the - * original transformations. - * - * Think of the original end-points as points in (X,Y,Z) space. The - * chromaticity values (c) have the property: - * - * C - * c = --------- - * X + Y + Z - * - * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the - * three chromaticity values (x,y,z) for each end-point obey the - * relationship: - * - * x + y + z = 1 - * - * This describes the plane in (X,Y,Z) space that intersects each axis at the - * value 1.0; call this the chromaticity plane. Thus the chromaticity - * calculation has scaled each end-point so that it is on the x+y+z=1 plane - * and chromaticity is the intersection of the vector from the origin to the - * (X,Y,Z) value with the chromaticity plane. - * - * To fully invert the chromaticity calculation we would need the three - * end-point scale factors, (red-scale, green-scale, blue-scale), but these - * were not recorded. Instead we calculated the reference white (X,Y,Z) and - * recorded the chromaticity of this. The reference white (X,Y,Z) would have - * given all three of the scale factors since: - * - * color-C = color-c * color-scale - * white-C = red-C + green-C + blue-C - * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale - * - * But cHRM records only white-x and white-y, so we have lost the white scale - * factor: - * - * white-C = white-c*white-scale - * - * To handle this the inverse transformation makes an arbitrary assumption - * about white-scale: - * - * Assume: white-Y = 1.0 - * Hence: white-scale = 1/white-y - * Or: red-Y + green-Y + blue-Y = 1.0 - * - * Notice the last statement of the assumption gives an equation in three of - * the nine values we want to calculate. 8 more equations come from the - * above routine as summarised at the top above (the chromaticity - * calculation): - * - * Given: color-x = color-X / (color-X + color-Y + color-Z) - * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0 - * - * This is 9 simultaneous equations in the 9 variables "color-C" and can be - * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix - * determinants, however this is not as bad as it seems because only 28 of - * the total of 90 terms in the various matrices are non-zero. Nevertheless - * Cramer's rule is notoriously numerically unstable because the determinant - * calculation involves the difference of large, but similar, numbers. It is - * difficult to be sure that the calculation is stable for real world values - * and it is certain that it becomes unstable where the end points are close - * together. - * - * So this code uses the perhaps slighly less optimal but more understandable - * and totally obvious approach of calculating color-scale. - * - * This algorithm depends on the precision in white-scale and that is - * (1/white-y), so we can immediately see that as white-y approaches 0 the - * accuracy inherent in the cHRM chunk drops off substantially. - * - * libpng arithmetic: a simple invertion of the above equations - * ------------------------------------------------------------ - * - * white_scale = 1/white-y - * white-X = white-x * white-scale - * white-Y = 1.0 - * white-Z = (1 - white-x - white-y) * white_scale - * - * white-C = red-C + green-C + blue-C - * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale - * - * This gives us three equations in (red-scale,green-scale,blue-scale) where - * all the coefficients are now known: - * - * red-x*red-scale + green-x*green-scale + blue-x*blue-scale - * = white-x/white-y - * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1 - * red-z*red-scale + green-z*green-scale + blue-z*blue-scale - * = (1 - white-x - white-y)/white-y - * - * In the last equation color-z is (1 - color-x - color-y) so we can add all - * three equations together to get an alternative third: - * - * red-scale + green-scale + blue-scale = 1/white-y = white-scale - * - * So now we have a Cramer's rule solution where the determinants are just - * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve - * multiplication of three coefficients so we can't guarantee to avoid - * overflow in the libpng fixed point representation. Using Cramer's rule in - * floating point is probably a good choice here, but it's not an option for - * fixed point. Instead proceed to simplify the first two equations by - * eliminating what is likely to be the largest value, blue-scale: - * - * blue-scale = white-scale - red-scale - green-scale - * - * Hence: - * - * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale = - * (white-x - blue-x)*white-scale - * - * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale = - * 1 - blue-y*white-scale - * - * And now we can trivially solve for (red-scale,green-scale): - * - * green-scale = - * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale - * ----------------------------------------------------------- - * green-x - blue-x - * - * red-scale = - * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale - * --------------------------------------------------------- - * red-y - blue-y - * - * Hence: - * - * red-scale = - * ( (green-x - blue-x) * (white-y - blue-y) - - * (green-y - blue-y) * (white-x - blue-x) ) / white-y - * ------------------------------------------------------------------------- - * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x) - * - * green-scale = - * ( (red-y - blue-y) * (white-x - blue-x) - - * (red-x - blue-x) * (white-y - blue-y) ) / white-y - * ------------------------------------------------------------------------- - * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x) - * - * Accuracy: - * The input values have 5 decimal digits of accuracy. The values are all in - * the range 0 < value < 1, so simple products are in the same range but may - * need up to 10 decimal digits to preserve the original precision and avoid - * underflow. Because we are using a 32-bit signed representation we cannot - * match this; the best is a little over 9 decimal digits, less than 10. - * - * The approach used here is to preserve the maximum precision within the - * signed representation. Because the red-scale calculation above uses the - * difference between two products of values that must be in the range -1..+1 - * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The - * factor is irrelevant in the calculation because it is applied to both - * numerator and denominator. - * - * Note that the values of the differences of the products of the - * chromaticities in the above equations tend to be small, for example for - * the sRGB chromaticities they are: - * - * red numerator: -0.04751 - * green numerator: -0.08788 - * denominator: -0.2241 (without white-y multiplication) - * - * The resultant Y coefficients from the chromaticities of some widely used - * color space definitions are (to 15 decimal places): - * - * sRGB - * 0.212639005871510 0.715168678767756 0.072192315360734 - * Kodak ProPhoto - * 0.288071128229293 0.711843217810102 0.000085653960605 - * Adobe RGB - * 0.297344975250536 0.627363566255466 0.075291458493998 - * Adobe Wide Gamut RGB - * 0.258728243040113 0.724682314948566 0.016589442011321 - */ - /* By the argument, above overflow should be impossible here. The return - * value of 2 indicates an internal error to the caller. - */ - if (!png_muldiv(&left, xy.greenx-xy.bluex, xy.redy - xy.bluey, 7)) return 2; - if (!png_muldiv(&right, xy.greeny-xy.bluey, xy.redx - xy.bluex, 7)) return 2; - denominator = left - right; - - /* Now find the red numerator. */ - if (!png_muldiv(&left, xy.greenx-xy.bluex, xy.whitey-xy.bluey, 7)) return 2; - if (!png_muldiv(&right, xy.greeny-xy.bluey, xy.whitex-xy.bluex, 7)) return 2; - - /* Overflow is possible here and it indicates an extreme set of PNG cHRM - * chunk values. This calculation actually returns the reciprocal of the - * scale value because this allows us to delay the multiplication of white-y - * into the denominator, which tends to produce a small number. - */ - if (!png_muldiv(&red_inverse, xy.whitey, denominator, left-right) || - red_inverse <= xy.whitey /* r+g+b scales = white scale */) - return 1; - - /* Similarly for green_inverse: */ - if (!png_muldiv(&left, xy.redy-xy.bluey, xy.whitex-xy.bluex, 7)) return 2; - if (!png_muldiv(&right, xy.redx-xy.bluex, xy.whitey-xy.bluey, 7)) return 2; - if (!png_muldiv(&green_inverse, xy.whitey, denominator, left-right) || - green_inverse <= xy.whitey) - return 1; - - /* And the blue scale, the checks above guarantee this can't overflow but it - * can still produce 0 for extreme cHRM values. - */ - blue_scale = png_reciprocal(xy.whitey) - png_reciprocal(red_inverse) - - png_reciprocal(green_inverse); - if (blue_scale <= 0) return 1; - - - /* And fill in the png_XYZ: */ - if (!png_muldiv(&XYZ->redX, xy.redx, PNG_FP_1, red_inverse)) return 1; - if (!png_muldiv(&XYZ->redY, xy.redy, PNG_FP_1, red_inverse)) return 1; - if (!png_muldiv(&XYZ->redZ, PNG_FP_1 - xy.redx - xy.redy, PNG_FP_1, - red_inverse)) - return 1; - - if (!png_muldiv(&XYZ->greenX, xy.greenx, PNG_FP_1, green_inverse)) return 1; - if (!png_muldiv(&XYZ->greenY, xy.greeny, PNG_FP_1, green_inverse)) return 1; - if (!png_muldiv(&XYZ->greenZ, PNG_FP_1 - xy.greenx - xy.greeny, PNG_FP_1, - green_inverse)) - return 1; - - if (!png_muldiv(&XYZ->blueX, xy.bluex, blue_scale, PNG_FP_1)) return 1; - if (!png_muldiv(&XYZ->blueY, xy.bluey, blue_scale, PNG_FP_1)) return 1; - if (!png_muldiv(&XYZ->blueZ, PNG_FP_1 - xy.bluex - xy.bluey, blue_scale, - PNG_FP_1)) - return 1; - - return 0; /*success*/ -} - -int png_XYZ_from_xy_checked(png_structp png_ptr, png_XYZ *XYZ, png_xy xy) -{ - switch (png_XYZ_from_xy(XYZ, xy)) - { - case 0: /* success */ - return 1; - - case 1: - /* The chunk may be technically valid, but we got png_fixed_point - * overflow while trying to get XYZ values out of it. This is - * entirely benign - the cHRM chunk is pretty extreme. - */ - png_warning(png_ptr, - "extreme cHRM chunk cannot be converted to tristimulus values"); - break; - - default: - /* libpng is broken; this should be a warning but if it happens we - * want error reports so for the moment it is an error. - */ - png_error(png_ptr, "internal error in png_XYZ_from_xy"); - break; - } - - /* ERROR RETURN */ - return 0; -} -#endif - -void /* PRIVATE */ -png_check_IHDR(png_structp png_ptr, - png_uint_32 width, png_uint_32 height, int bit_depth, - int color_type, int interlace_type, int compression_type, - int filter_type) -{ - int error = 0; - - /* Check for width and height valid values */ - if (width == 0) - { - png_warning(png_ptr, "Image width is zero in IHDR"); - error = 1; - } - - if (height == 0) - { - png_warning(png_ptr, "Image height is zero in IHDR"); - error = 1; - } - -# ifdef PNG_SET_USER_LIMITS_SUPPORTED - if (width > png_ptr->user_width_max) - -# else - if (width > PNG_USER_WIDTH_MAX) -# endif - { - png_warning(png_ptr, "Image width exceeds user limit in IHDR"); - error = 1; - } - -# ifdef PNG_SET_USER_LIMITS_SUPPORTED - if (height > png_ptr->user_height_max) -# else - if (height > PNG_USER_HEIGHT_MAX) -# endif - { - png_warning(png_ptr, "Image height exceeds user limit in IHDR"); - error = 1; - } - - if (width > PNG_UINT_31_MAX) - { - png_warning(png_ptr, "Invalid image width in IHDR"); - error = 1; - } - - if (height > PNG_UINT_31_MAX) - { - png_warning(png_ptr, "Invalid image height in IHDR"); - error = 1; - } - - if (width > (PNG_UINT_32_MAX - >> 3) /* 8-byte RGBA pixels */ - - 48 /* bigrowbuf hack */ - - 1 /* filter byte */ - - 7*8 /* rounding of width to multiple of 8 pixels */ - - 8) /* extra max_pixel_depth pad */ - png_warning(png_ptr, "Width is too large for libpng to process pixels"); - - /* Check other values */ - if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && - bit_depth != 8 && bit_depth != 16) - { - png_warning(png_ptr, "Invalid bit depth in IHDR"); - error = 1; - } - - if (color_type < 0 || color_type == 1 || - color_type == 5 || color_type > 6) - { - png_warning(png_ptr, "Invalid color type in IHDR"); - error = 1; - } - - if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || - ((color_type == PNG_COLOR_TYPE_RGB || - color_type == PNG_COLOR_TYPE_GRAY_ALPHA || - color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) - { - png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR"); - error = 1; - } - - if (interlace_type >= PNG_INTERLACE_LAST) - { - png_warning(png_ptr, "Unknown interlace method in IHDR"); - error = 1; - } - - if (compression_type != PNG_COMPRESSION_TYPE_BASE) - { - png_warning(png_ptr, "Unknown compression method in IHDR"); - error = 1; - } - -# ifdef PNG_MNG_FEATURES_SUPPORTED - /* Accept filter_method 64 (intrapixel differencing) only if - * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and - * 2. Libpng did not read a PNG signature (this filter_method is only - * used in PNG datastreams that are embedded in MNG datastreams) and - * 3. The application called png_permit_mng_features with a mask that - * included PNG_FLAG_MNG_FILTER_64 and - * 4. The filter_method is 64 and - * 5. The color_type is RGB or RGBA - */ - if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) && - png_ptr->mng_features_permitted) - png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); - - if (filter_type != PNG_FILTER_TYPE_BASE) - { - if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && - (filter_type == PNG_INTRAPIXEL_DIFFERENCING) && - ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) && - (color_type == PNG_COLOR_TYPE_RGB || - color_type == PNG_COLOR_TYPE_RGB_ALPHA))) - { - png_warning(png_ptr, "Unknown filter method in IHDR"); - error = 1; - } - - if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) - { - png_warning(png_ptr, "Invalid filter method in IHDR"); - error = 1; - } - } - -# else - if (filter_type != PNG_FILTER_TYPE_BASE) - { - png_warning(png_ptr, "Unknown filter method in IHDR"); - error = 1; - } -# endif - - if (error == 1) - png_error(png_ptr, "Invalid IHDR data"); -} - -#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) -/* ASCII to fp functions */ -/* Check an ASCII formated floating point value, see the more detailed - * comments in pngpriv.h - */ -/* The following is used internally to preserve the sticky flags */ -#define png_fp_add(state, flags) ((state) |= (flags)) -#define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY)) - -int /* PRIVATE */ -png_check_fp_number(png_const_charp string, png_size_t size, int *statep, - png_size_tp whereami) -{ - int state = *statep; - png_size_t i = *whereami; - - while (i < size) - { - int type; - /* First find the type of the next character */ - switch (string[i]) - { - case 43: type = PNG_FP_SAW_SIGN; break; - case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break; - case 46: type = PNG_FP_SAW_DOT; break; - case 48: type = PNG_FP_SAW_DIGIT; break; - case 49: case 50: case 51: case 52: - case 53: case 54: case 55: case 56: - case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break; - case 69: - case 101: type = PNG_FP_SAW_E; break; - default: goto PNG_FP_End; - } - - /* Now deal with this type according to the current - * state, the type is arranged to not overlap the - * bits of the PNG_FP_STATE. - */ - switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY)) - { - case PNG_FP_INTEGER + PNG_FP_SAW_SIGN: - if (state & PNG_FP_SAW_ANY) - goto PNG_FP_End; /* not a part of the number */ - - png_fp_add(state, type); - break; - - case PNG_FP_INTEGER + PNG_FP_SAW_DOT: - /* Ok as trailer, ok as lead of fraction. */ - if (state & PNG_FP_SAW_DOT) /* two dots */ - goto PNG_FP_End; - - else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */ - png_fp_add(state, type); - - else - png_fp_set(state, PNG_FP_FRACTION | type); - - break; - - case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT: - if (state & PNG_FP_SAW_DOT) /* delayed fraction */ - png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); - - png_fp_add(state, type | PNG_FP_WAS_VALID); - - break; - - case PNG_FP_INTEGER + PNG_FP_SAW_E: - if ((state & PNG_FP_SAW_DIGIT) == 0) - goto PNG_FP_End; - - png_fp_set(state, PNG_FP_EXPONENT); - - break; - - /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN: - goto PNG_FP_End; ** no sign in fraction */ - - /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT: - goto PNG_FP_End; ** Because SAW_DOT is always set */ - - case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT: - png_fp_add(state, type | PNG_FP_WAS_VALID); - break; - - case PNG_FP_FRACTION + PNG_FP_SAW_E: - /* This is correct because the trailing '.' on an - * integer is handled above - so we can only get here - * with the sequence ".E" (with no preceding digits). - */ - if ((state & PNG_FP_SAW_DIGIT) == 0) - goto PNG_FP_End; - - png_fp_set(state, PNG_FP_EXPONENT); - - break; - - case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN: - if (state & PNG_FP_SAW_ANY) - goto PNG_FP_End; /* not a part of the number */ - - png_fp_add(state, PNG_FP_SAW_SIGN); - - break; - - /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT: - goto PNG_FP_End; */ - - case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT: - png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID); - - break; - - /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E: - goto PNG_FP_End; */ - - default: goto PNG_FP_End; /* I.e. break 2 */ - } - - /* The character seems ok, continue. */ - ++i; - } - -PNG_FP_End: - /* Here at the end, update the state and return the correct - * return code. - */ - *statep = state; - *whereami = i; - - return (state & PNG_FP_SAW_DIGIT) != 0; -} - - -/* The same but for a complete string. */ -int -png_check_fp_string(png_const_charp string, png_size_t size) -{ - int state=0; - png_size_t char_index=0; - - if (png_check_fp_number(string, size, &state, &char_index) && - (char_index == size || string[char_index] == 0)) - return state /* must be non-zero - see above */; - - return 0; /* i.e. fail */ -} -#endif /* pCAL or sCAL */ - -#ifdef PNG_READ_sCAL_SUPPORTED -# ifdef PNG_FLOATING_POINT_SUPPORTED -/* Utility used below - a simple accurate power of ten from an integral - * exponent. - */ -static double -png_pow10(int power) -{ - int recip = 0; - double d = 1.0; - - /* Handle negative exponent with a reciprocal at the end because - * 10 is exact whereas .1 is inexact in base 2 - */ - if (power < 0) - { - if (power < DBL_MIN_10_EXP) return 0; - recip = 1, power = -power; - } - - if (power > 0) - { - /* Decompose power bitwise. */ - double mult = 10.0; - do - { - if (power & 1) d *= mult; - mult *= mult; - power >>= 1; - } - while (power > 0); - - if (recip) d = 1/d; - } - /* else power is 0 and d is 1 */ - - return d; -} - -/* Function to format a floating point value in ASCII with a given - * precision. - */ -void /* PRIVATE */ -png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size, - double fp, unsigned int precision) -{ - /* We use standard functions from math.h, but not printf because - * that would require stdio. The caller must supply a buffer of - * sufficient size or we will png_error. The tests on size and - * the space in ascii[] consumed are indicated below. - */ - if (precision < 1) - precision = DBL_DIG; - - /* Enforce the limit of the implementation precision too. */ - if (precision > DBL_DIG+1) - precision = DBL_DIG+1; - - /* Basic sanity checks */ - if (size >= precision+5) /* See the requirements below. */ - { - if (fp < 0) - { - fp = -fp; - *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */ - --size; - } - - if (fp >= DBL_MIN && fp <= DBL_MAX) - { - int exp_b10; /* A base 10 exponent */ - double base; /* 10^exp_b10 */ - - /* First extract a base 10 exponent of the number, - * the calculation below rounds down when converting - * from base 2 to base 10 (multiply by log10(2) - - * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to - * be increased. Note that the arithmetic shift - * performs a floor() unlike C arithmetic - using a - * C multiply would break the following for negative - * exponents. - */ - (void)frexp(fp, &exp_b10); /* exponent to base 2 */ - - exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */ - - /* Avoid underflow here. */ - base = png_pow10(exp_b10); /* May underflow */ - - while (base < DBL_MIN || base < fp) - { - /* And this may overflow. */ - double test = png_pow10(exp_b10+1); - - if (test <= DBL_MAX) - ++exp_b10, base = test; - - else - break; - } - - /* Normalize fp and correct exp_b10, after this fp is in the - * range [.1,1) and exp_b10 is both the exponent and the digit - * *before* which the decimal point should be inserted - * (starting with 0 for the first digit). Note that this - * works even if 10^exp_b10 is out of range because of the - * test on DBL_MAX above. - */ - fp /= base; - while (fp >= 1) fp /= 10, ++exp_b10; - - /* Because of the code above fp may, at this point, be - * less than .1, this is ok because the code below can - * handle the leading zeros this generates, so no attempt - * is made to correct that here. - */ - - { - int czero, clead, cdigits; - char exponent[10]; - - /* Allow up to two leading zeros - this will not lengthen - * the number compared to using E-n. - */ - if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */ - { - czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */ - exp_b10 = 0; /* Dot added below before first output. */ - } - else - czero = 0; /* No zeros to add */ - - /* Generate the digit list, stripping trailing zeros and - * inserting a '.' before a digit if the exponent is 0. - */ - clead = czero; /* Count of leading zeros */ - cdigits = 0; /* Count of digits in list. */ - - do - { - double d; - - fp *= 10.0; - - /* Use modf here, not floor and subtract, so that - * the separation is done in one step. At the end - * of the loop don't break the number into parts so - * that the final digit is rounded. - */ - if (cdigits+czero-clead+1 < (int)precision) - fp = modf(fp, &d); - - else - { - d = floor(fp + .5); - - if (d > 9.0) - { - /* Rounding up to 10, handle that here. */ - if (czero > 0) - { - --czero, d = 1; - if (cdigits == 0) --clead; - } - - else - { - while (cdigits > 0 && d > 9.0) - { - int ch = *--ascii; - - if (exp_b10 != (-1)) - ++exp_b10; - - else if (ch == 46) - { - ch = *--ascii, ++size; - /* Advance exp_b10 to '1', so that the - * decimal point happens after the - * previous digit. - */ - exp_b10 = 1; - } - - --cdigits; - d = ch - 47; /* I.e. 1+(ch-48) */ - } - - /* Did we reach the beginning? If so adjust the - * exponent but take into account the leading - * decimal point. - */ - if (d > 9.0) /* cdigits == 0 */ - { - if (exp_b10 == (-1)) - { - /* Leading decimal point (plus zeros?), if - * we lose the decimal point here it must - * be reentered below. - */ - int ch = *--ascii; - - if (ch == 46) - ++size, exp_b10 = 1; - - /* Else lost a leading zero, so 'exp_b10' is - * still ok at (-1) - */ - } - else - ++exp_b10; - - /* In all cases we output a '1' */ - d = 1.0; - } - } - } - fp = 0; /* Guarantees termination below. */ - } - - if (d == 0.0) - { - ++czero; - if (cdigits == 0) ++clead; - } - - else - { - /* Included embedded zeros in the digit count. */ - cdigits += czero - clead; - clead = 0; - - while (czero > 0) - { - /* exp_b10 == (-1) means we just output the decimal - * place - after the DP don't adjust 'exp_b10' any - * more! - */ - if (exp_b10 != (-1)) - { - if (exp_b10 == 0) *ascii++ = 46, --size; - /* PLUS 1: TOTAL 4 */ - --exp_b10; - } - *ascii++ = 48, --czero; - } - - if (exp_b10 != (-1)) - { - if (exp_b10 == 0) *ascii++ = 46, --size; /* counted - above */ - --exp_b10; - } - - *ascii++ = (char)(48 + (int)d), ++cdigits; - } - } - while (cdigits+czero-clead < (int)precision && fp > DBL_MIN); - - /* The total output count (max) is now 4+precision */ - - /* Check for an exponent, if we don't need one we are - * done and just need to terminate the string. At - * this point exp_b10==(-1) is effectively if flag - it got - * to '-1' because of the decrement after outputing - * the decimal point above (the exponent required is - * *not* -1!) - */ - if (exp_b10 >= (-1) && exp_b10 <= 2) - { - /* The following only happens if we didn't output the - * leading zeros above for negative exponent, so this - * doest add to the digit requirement. Note that the - * two zeros here can only be output if the two leading - * zeros were *not* output, so this doesn't increase - * the output count. - */ - while (--exp_b10 >= 0) *ascii++ = 48; - - *ascii = 0; - - /* Total buffer requirement (including the '\0') is - * 5+precision - see check at the start. - */ - return; - } - - /* Here if an exponent is required, adjust size for - * the digits we output but did not count. The total - * digit output here so far is at most 1+precision - no - * decimal point and no leading or trailing zeros have - * been output. - */ - size -= cdigits; - - *ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision */ - - /* The following use of an unsigned temporary avoids ambiguities in - * the signed arithmetic on exp_b10 and permits GCC at least to do - * better optimization. - */ - { - unsigned int uexp_b10; - - if (exp_b10 < 0) - { - *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */ - uexp_b10 = -exp_b10; - } - - else - uexp_b10 = exp_b10; - - cdigits = 0; - - while (uexp_b10 > 0) - { - exponent[cdigits++] = (char)(48 + uexp_b10 % 10); - uexp_b10 /= 10; - } - } - - /* Need another size check here for the exponent digits, so - * this need not be considered above. - */ - if ((int)size > cdigits) - { - while (cdigits > 0) *ascii++ = exponent[--cdigits]; - - *ascii = 0; - - return; - } - } - } - else if (!(fp >= DBL_MIN)) - { - *ascii++ = 48; /* '0' */ - *ascii = 0; - return; - } - else - { - *ascii++ = 105; /* 'i' */ - *ascii++ = 110; /* 'n' */ - *ascii++ = 102; /* 'f' */ - *ascii = 0; - return; - } - } - - /* Here on buffer too small. */ - png_error(png_ptr, "ASCII conversion buffer too small"); -} - -# endif /* FLOATING_POINT */ - -# ifdef PNG_FIXED_POINT_SUPPORTED -/* Function to format a fixed point value in ASCII. - */ -void /* PRIVATE */ -png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size, - png_fixed_point fp) -{ - /* Require space for 10 decimal digits, a decimal point, a minus sign and a - * trailing \0, 13 characters: - */ - if (size > 12) - { - png_uint_32 num; - - /* Avoid overflow here on the minimum integer. */ - if (fp < 0) - *ascii++ = 45, --size, num = -fp; - else - num = fp; - - if (num <= 0x80000000) /* else overflowed */ - { - unsigned int ndigits = 0, first = 16 /* flag value */; - char digits[10]; - - while (num) - { - /* Split the low digit off num: */ - unsigned int tmp = num/10; - num -= tmp*10; - digits[ndigits++] = (char)(48 + num); - /* Record the first non-zero digit, note that this is a number - * starting at 1, it's not actually the array index. - */ - if (first == 16 && num > 0) - first = ndigits; - num = tmp; - } - - if (ndigits > 0) - { - while (ndigits > 5) *ascii++ = digits[--ndigits]; - /* The remaining digits are fractional digits, ndigits is '5' or - * smaller at this point. It is certainly not zero. Check for a - * non-zero fractional digit: - */ - if (first <= 5) - { - unsigned int i; - *ascii++ = 46; /* decimal point */ - /* ndigits may be <5 for small numbers, output leading zeros - * then ndigits digits to first: - */ - i = 5; - while (ndigits < i) *ascii++ = 48, --i; - while (ndigits >= first) *ascii++ = digits[--ndigits]; - /* Don't output the trailing zeros! */ - } - } - else - *ascii++ = 48; - - /* And null terminate the string: */ - *ascii = 0; - return; - } - } - - /* Here on buffer too small. */ - png_error(png_ptr, "ASCII conversion buffer too small"); -} -# endif /* FIXED_POINT */ -#endif /* READ_SCAL */ - -#if defined(PNG_FLOATING_POINT_SUPPORTED) && \ - !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) -png_fixed_point -png_fixed(png_structp png_ptr, double fp, png_const_charp text) -{ - double r = floor(100000 * fp + .5); - - if (r > 2147483647. || r < -2147483648.) - png_fixed_error(png_ptr, text); - - return (png_fixed_point)r; -} -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || \ - defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED) -/* muldiv functions */ -/* This API takes signed arguments and rounds the result to the nearest - * integer (or, for a fixed point number - the standard argument - to - * the nearest .00001). Overflow and divide by zero are signalled in - * the result, a boolean - true on success, false on overflow. - */ -int -png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, - png_int_32 divisor) -{ - /* Return a * times / divisor, rounded. */ - if (divisor != 0) - { - if (a == 0 || times == 0) - { - *res = 0; - return 1; - } - else - { -#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - double r = a; - r *= times; - r /= divisor; - r = floor(r+.5); - - /* A png_fixed_point is a 32-bit integer. */ - if (r <= 2147483647. && r >= -2147483648.) - { - *res = (png_fixed_point)r; - return 1; - } -#else - int negative = 0; - png_uint_32 A, T, D; - png_uint_32 s16, s32, s00; - - if (a < 0) - negative = 1, A = -a; - else - A = a; - - if (times < 0) - negative = !negative, T = -times; - else - T = times; - - if (divisor < 0) - negative = !negative, D = -divisor; - else - D = divisor; - - /* Following can't overflow because the arguments only - * have 31 bits each, however the result may be 32 bits. - */ - s16 = (A >> 16) * (T & 0xffff) + - (A & 0xffff) * (T >> 16); - /* Can't overflow because the a*times bit is only 30 - * bits at most. - */ - s32 = (A >> 16) * (T >> 16) + (s16 >> 16); - s00 = (A & 0xffff) * (T & 0xffff); - - s16 = (s16 & 0xffff) << 16; - s00 += s16; - - if (s00 < s16) - ++s32; /* carry */ - - if (s32 < D) /* else overflow */ - { - /* s32.s00 is now the 64-bit product, do a standard - * division, we know that s32 < D, so the maximum - * required shift is 31. - */ - int bitshift = 32; - png_fixed_point result = 0; /* NOTE: signed */ - - while (--bitshift >= 0) - { - png_uint_32 d32, d00; - - if (bitshift > 0) - d32 = D >> (32-bitshift), d00 = D << bitshift; - - else - d32 = 0, d00 = D; - - if (s32 > d32) - { - if (s00 < d00) --s32; /* carry */ - s32 -= d32, s00 -= d00, result += 1<= d00) - s32 = 0, s00 -= d00, result += 1<= (D >> 1)) - ++result; - - if (negative) - result = -result; - - /* Check for overflow. */ - if ((negative && result <= 0) || (!negative && result >= 0)) - { - *res = result; - return 1; - } - } -#endif - } - } - - return 0; -} -#endif /* READ_GAMMA || INCH_CONVERSIONS */ - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) -/* The following is for when the caller doesn't much care about the - * result. - */ -png_fixed_point -png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times, - png_int_32 divisor) -{ - png_fixed_point result = 0; (void)result; - - if (png_muldiv(&result, a, times, divisor)) - return result; - - png_warning(png_ptr, "fixed point overflow ignored"); - return 0; -} -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */ -/* Calculate a reciprocal, return 0 on div-by-zero or overflow. */ -png_fixed_point -png_reciprocal(png_fixed_point a) -{ -#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - double r = floor(1E10/a+.5); - - if (r <= 2147483647. && r >= -2147483648.) - return (png_fixed_point)r; -#else - png_fixed_point res; - - if (png_muldiv(&res, 100000, 100000, a)) - return res; -#endif - - return 0; /* error/overflow */ -} - -/* A local convenience routine. */ -static png_fixed_point -png_product2(png_fixed_point a, png_fixed_point b) -{ - /* The required result is 1/a * 1/b; the following preserves accuracy. */ -#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - double r = a * 1E-5; - r *= b; - r = floor(r+.5); - - if (r <= 2147483647. && r >= -2147483648.) - return (png_fixed_point)r; -#else - png_fixed_point res; - - if (png_muldiv(&res, a, b, 100000)) - return res; -#endif - - return 0; /* overflow */ -} - -/* The inverse of the above. */ -png_fixed_point -png_reciprocal2(png_fixed_point a, png_fixed_point b) -{ - /* The required result is 1/a * 1/b; the following preserves accuracy. */ -#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - double r = 1E15/a; - r /= b; - r = floor(r+.5); - - if (r <= 2147483647. && r >= -2147483648.) - return (png_fixed_point)r; -#else - /* This may overflow because the range of png_fixed_point isn't symmetric, - * but this API is only used for the product of file and screen gamma so it - * doesn't matter that the smallest number it can produce is 1/21474, not - * 1/100000 - */ - png_fixed_point res = png_product2(a, b); - - if (res != 0) - return png_reciprocal(res); -#endif - - return 0; /* overflow */ -} -#endif /* READ_GAMMA */ - -#ifdef PNG_CHECK_cHRM_SUPPORTED -/* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2, - * 2010: moved from pngset.c) */ -/* - * Multiply two 32-bit numbers, V1 and V2, using 32-bit - * arithmetic, to produce a 64-bit result in the HI/LO words. - * - * A B - * x C D - * ------ - * AD || BD - * AC || CB || 0 - * - * where A and B are the high and low 16-bit words of V1, - * C and D are the 16-bit words of V2, AD is the product of - * A and D, and X || Y is (X << 16) + Y. -*/ - -void /* PRIVATE */ -png_64bit_product (long v1, long v2, unsigned long *hi_product, - unsigned long *lo_product) -{ - int a, b, c, d; - long lo, hi, x, y; - - a = (v1 >> 16) & 0xffff; - b = v1 & 0xffff; - c = (v2 >> 16) & 0xffff; - d = v2 & 0xffff; - - lo = b * d; /* BD */ - x = a * d + c * b; /* AD + CB */ - y = ((lo >> 16) & 0xffff) + x; - - lo = (lo & 0xffff) | ((y & 0xffff) << 16); - hi = (y >> 16) & 0xffff; - - hi += a * c; /* AC */ - - *hi_product = (unsigned long)hi; - *lo_product = (unsigned long)lo; -} -#endif /* CHECK_cHRM */ - -#ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */ -#ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED -/* Fixed point gamma. - * - * To calculate gamma this code implements fast log() and exp() calls using only - * fixed point arithmetic. This code has sufficient precision for either 8-bit - * or 16-bit sample values. - * - * The tables used here were calculated using simple 'bc' programs, but C double - * precision floating point arithmetic would work fine. The programs are given - * at the head of each table. - * - * 8-bit log table - * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to - * 255, so it's the base 2 logarithm of a normalized 8-bit floating point - * mantissa. The numbers are 32-bit fractions. - */ -static png_uint_32 -png_8bit_l2[128] = -{ -# ifdef PNG_DO_BC - for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; } -# else - 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U, - 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U, - 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U, - 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U, - 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U, - 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U, - 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U, - 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U, - 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U, - 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U, - 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U, - 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U, - 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U, - 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U, - 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U, - 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U, - 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U, - 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U, - 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U, - 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U, - 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U, - 24347096U, 0U -# endif - -#if 0 - /* The following are the values for 16-bit tables - these work fine for the - * 8-bit conversions but produce very slightly larger errors in the 16-bit - * log (about 1.2 as opposed to 0.7 absolute error in the final value). To - * use these all the shifts below must be adjusted appropriately. - */ - 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054, - 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803, - 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068, - 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782, - 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887, - 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339, - 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098, - 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132, - 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415, - 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523, - 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495, - 1119, 744, 372 -#endif -}; - -PNG_STATIC png_int_32 -png_log8bit(unsigned int x) -{ - unsigned int lg2 = 0; - /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log, - * because the log is actually negate that means adding 1. The final - * returned value thus has the range 0 (for 255 input) to 7.994 (for 1 - * input), return 7.99998 for the overflow (log 0) case - so the result is - * always at most 19 bits. - */ - if ((x &= 0xff) == 0) - return 0xffffffff; - - if ((x & 0xf0) == 0) - lg2 = 4, x <<= 4; - - if ((x & 0xc0) == 0) - lg2 += 2, x <<= 2; - - if ((x & 0x80) == 0) - lg2 += 1, x <<= 1; - - /* result is at most 19 bits, so this cast is safe: */ - return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16)); -} - -/* The above gives exact (to 16 binary places) log2 values for 8-bit images, - * for 16-bit images we use the most significant 8 bits of the 16-bit value to - * get an approximation then multiply the approximation by a correction factor - * determined by the remaining up to 8 bits. This requires an additional step - * in the 16-bit case. - * - * We want log2(value/65535), we have log2(v'/255), where: - * - * value = v' * 256 + v'' - * = v' * f - * - * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128 - * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less - * than 258. The final factor also needs to correct for the fact that our 8-bit - * value is scaled by 255, whereas the 16-bit values must be scaled by 65535. - * - * This gives a final formula using a calculated value 'x' which is value/v' and - * scaling by 65536 to match the above table: - * - * log2(x/257) * 65536 - * - * Since these numbers are so close to '1' we can use simple linear - * interpolation between the two end values 256/257 (result -368.61) and 258/257 - * (result 367.179). The values used below are scaled by a further 64 to give - * 16-bit precision in the interpolation: - * - * Start (256): -23591 - * Zero (257): 0 - * End (258): 23499 - */ -PNG_STATIC png_int_32 -png_log16bit(png_uint_32 x) -{ - unsigned int lg2 = 0; - - /* As above, but now the input has 16 bits. */ - if ((x &= 0xffff) == 0) - return 0xffffffff; - - if ((x & 0xff00) == 0) - lg2 = 8, x <<= 8; - - if ((x & 0xf000) == 0) - lg2 += 4, x <<= 4; - - if ((x & 0xc000) == 0) - lg2 += 2, x <<= 2; - - if ((x & 0x8000) == 0) - lg2 += 1, x <<= 1; - - /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional - * value. - */ - lg2 <<= 28; - lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4; - - /* Now we need to interpolate the factor, this requires a division by the top - * 8 bits. Do this with maximum precision. - */ - x = ((x << 16) + (x >> 9)) / (x >> 8); - - /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24, - * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly - * 16 bits to interpolate to get the low bits of the result. Round the - * answer. Note that the end point values are scaled by 64 to retain overall - * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust - * the overall scaling by 6-12. Round at every step. - */ - x -= 1U << 24; - - if (x <= 65536U) /* <= '257' */ - lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12); - - else - lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12); - - /* Safe, because the result can't have more than 20 bits: */ - return (png_int_32)((lg2 + 2048) >> 12); -} - -/* The 'exp()' case must invert the above, taking a 20-bit fixed point - * logarithmic value and returning a 16 or 8-bit number as appropriate. In - * each case only the low 16 bits are relevant - the fraction - since the - * integer bits (the top 4) simply determine a shift. - * - * The worst case is the 16-bit distinction between 65535 and 65534, this - * requires perhaps spurious accuracy in the decoding of the logarithm to - * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance - * of getting this accuracy in practice. - * - * To deal with this the following exp() function works out the exponent of the - * frational part of the logarithm by using an accurate 32-bit value from the - * top four fractional bits then multiplying in the remaining bits. - */ -static png_uint_32 -png_32bit_exp[16] = -{ -# ifdef PNG_DO_BC - for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; } -# else - /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */ - 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U, - 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U, - 2553802834U, 2445529972U, 2341847524U, 2242560872U -# endif -}; - -/* Adjustment table; provided to explain the numbers in the code below. */ -#ifdef PNG_DO_BC -for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"} - 11 44937.64284865548751208448 - 10 45180.98734845585101160448 - 9 45303.31936980687359311872 - 8 45364.65110595323018870784 - 7 45395.35850361789624614912 - 6 45410.72259715102037508096 - 5 45418.40724413220722311168 - 4 45422.25021786898173001728 - 3 45424.17186732298419044352 - 2 45425.13273269940811464704 - 1 45425.61317555035558641664 - 0 45425.85339951654943850496 -#endif - -PNG_STATIC png_uint_32 -png_exp(png_fixed_point x) -{ - if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */ - { - /* Obtain a 4-bit approximation */ - png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf]; - - /* Incorporate the low 12 bits - these decrease the returned value by - * multiplying by a number less than 1 if the bit is set. The multiplier - * is determined by the above table and the shift. Notice that the values - * converge on 45426 and this is used to allow linear interpolation of the - * low bits. - */ - if (x & 0x800) - e -= (((e >> 16) * 44938U) + 16U) >> 5; - - if (x & 0x400) - e -= (((e >> 16) * 45181U) + 32U) >> 6; - - if (x & 0x200) - e -= (((e >> 16) * 45303U) + 64U) >> 7; - - if (x & 0x100) - e -= (((e >> 16) * 45365U) + 128U) >> 8; - - if (x & 0x080) - e -= (((e >> 16) * 45395U) + 256U) >> 9; - - if (x & 0x040) - e -= (((e >> 16) * 45410U) + 512U) >> 10; - - /* And handle the low 6 bits in a single block. */ - e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9; - - /* Handle the upper bits of x. */ - e >>= x >> 16; - return e; - } - - /* Check for overflow */ - if (x <= 0) - return png_32bit_exp[0]; - - /* Else underflow */ - return 0; -} - -PNG_STATIC png_byte -png_exp8bit(png_fixed_point lg2) -{ - /* Get a 32-bit value: */ - png_uint_32 x = png_exp(lg2); - - /* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the - * second, rounding, step can't overflow because of the first, subtraction, - * step. - */ - x -= x >> 8; - return (png_byte)((x + 0x7fffffU) >> 24); -} - -PNG_STATIC png_uint_16 -png_exp16bit(png_fixed_point lg2) -{ - /* Get a 32-bit value: */ - png_uint_32 x = png_exp(lg2); - - /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */ - x -= x >> 16; - return (png_uint_16)((x + 32767U) >> 16); -} -#endif /* FLOATING_ARITHMETIC */ - -png_byte -png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val) -{ - if (value > 0 && value < 255) - { -# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - double r = floor(255*pow(value/255.,gamma_val*.00001)+.5); - return (png_byte)r; -# else - png_int_32 lg2 = png_log8bit(value); - png_fixed_point res; - - if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1)) - return png_exp8bit(res); - - /* Overflow. */ - value = 0; -# endif - } - - return (png_byte)value; -} - -png_uint_16 -png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val) -{ - if (value > 0 && value < 65535) - { -# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5); - return (png_uint_16)r; -# else - png_int_32 lg2 = png_log16bit(value); - png_fixed_point res; - - if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1)) - return png_exp16bit(res); - - /* Overflow. */ - value = 0; -# endif - } - - return (png_uint_16)value; -} - -/* This does the right thing based on the bit_depth field of the - * png_struct, interpreting values as 8-bit or 16-bit. While the result - * is nominally a 16-bit value if bit depth is 8 then the result is - * 8-bit (as are the arguments.) - */ -png_uint_16 /* PRIVATE */ -png_gamma_correct(png_structp png_ptr, unsigned int value, - png_fixed_point gamma_val) -{ - if (png_ptr->bit_depth == 8) - return png_gamma_8bit_correct(value, gamma_val); - - else - return png_gamma_16bit_correct(value, gamma_val); -} - -/* This is the shared test on whether a gamma value is 'significant' - whether - * it is worth doing gamma correction. - */ -int /* PRIVATE */ -png_gamma_significant(png_fixed_point gamma_val) -{ - return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED || - gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED; -} - -/* Internal function to build a single 16-bit table - the table consists of - * 'num' 256-entry subtables, where 'num' is determined by 'shift' - the amount - * to shift the input values right (or 16-number_of_signifiant_bits). - * - * The caller is responsible for ensuring that the table gets cleaned up on - * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument - * should be somewhere that will be cleaned. - */ -static void -png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable, - PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) -{ - /* Various values derived from 'shift': */ - PNG_CONST unsigned int num = 1U << (8U - shift); - PNG_CONST unsigned int max = (1U << (16U - shift))-1U; - PNG_CONST unsigned int max_by_2 = 1U << (15U-shift); - unsigned int i; - - png_uint_16pp table = *ptable = - (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p)); - - for (i = 0; i < num; i++) - { - png_uint_16p sub_table = table[i] = - (png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16)); - - /* The 'threshold' test is repeated here because it can arise for one of - * the 16-bit tables even if the others don't hit it. - */ - if (png_gamma_significant(gamma_val)) - { - /* The old code would overflow at the end and this would cause the - * 'pow' function to return a result >1, resulting in an - * arithmetic error. This code follows the spec exactly; ig is - * the recovered input sample, it always has 8-16 bits. - * - * We want input * 65535/max, rounded, the arithmetic fits in 32 - * bits (unsigned) so long as max <= 32767. - */ - unsigned int j; - for (j = 0; j < 256; j++) - { - png_uint_32 ig = (j << (8-shift)) + i; -# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED - /* Inline the 'max' scaling operation: */ - double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5); - sub_table[j] = (png_uint_16)d; -# else - if (shift) - ig = (ig * 65535U + max_by_2)/max; - - sub_table[j] = png_gamma_16bit_correct(ig, gamma_val); -# endif - } - } - else - { - /* We must still build a table, but do it the fast way. */ - unsigned int j; - - for (j = 0; j < 256; j++) - { - png_uint_32 ig = (j << (8-shift)) + i; - - if (shift) - ig = (ig * 65535U + max_by_2)/max; - - sub_table[j] = (png_uint_16)ig; - } - } - } -} - -/* NOTE: this function expects the *inverse* of the overall gamma transformation - * required. - */ -static void -png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable, - PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) -{ - PNG_CONST unsigned int num = 1U << (8U - shift); - PNG_CONST unsigned int max = (1U << (16U - shift))-1U; - unsigned int i; - png_uint_32 last; - - png_uint_16pp table = *ptable = - (png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p)); - - /* 'num' is the number of tables and also the number of low bits of the - * input 16-bit value used to select a table. Each table is itself indexed - * by the high 8 bits of the value. - */ - for (i = 0; i < num; i++) - table[i] = (png_uint_16p)png_malloc(png_ptr, - 256 * png_sizeof(png_uint_16)); - - /* 'gamma_val' is set to the reciprocal of the value calculated above, so - * pow(out,g) is an *input* value. 'last' is the last input value set. - * - * In the loop 'i' is used to find output values. Since the output is - * 8-bit there are only 256 possible values. The tables are set up to - * select the closest possible output value for each input by finding - * the input value at the boundary between each pair of output values - * and filling the table up to that boundary with the lower output - * value. - * - * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit - * values the code below uses a 16-bit value in i; the values start at - * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last - * entries are filled with 255). Start i at 128 and fill all 'last' - * table entries <= 'max' - */ - last = 0; - for (i = 0; i < 255; ++i) /* 8-bit output value */ - { - /* Find the corresponding maximum input value */ - png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */ - - /* Find the boundary value in 16 bits: */ - png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val); - - /* Adjust (round) to (16-shift) bits: */ - bound = (bound * max + 32768U)/65535U + 1U; - - while (last < bound) - { - table[last & (0xffU >> shift)][last >> (8U - shift)] = out; - last++; - } - } - - /* And fill in the final entries. */ - while (last < (num << 8)) - { - table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U; - last++; - } -} - -/* Build a single 8-bit table: same as the 16-bit case but much simpler (and - * typically much faster). Note that libpng currently does no sBIT processing - * (apparently contrary to the spec) so a 256-entry table is always generated. - */ -static void -png_build_8bit_table(png_structp png_ptr, png_bytepp ptable, - PNG_CONST png_fixed_point gamma_val) -{ - unsigned int i; - png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256); - - if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++) - table[i] = png_gamma_8bit_correct(i, gamma_val); - - else for (i=0; i<256; ++i) - table[i] = (png_byte)i; -} - -/* Used from png_read_destroy and below to release the memory used by the gamma - * tables. - */ -void /* PRIVATE */ -png_destroy_gamma_table(png_structp png_ptr) -{ - png_free(png_ptr, png_ptr->gamma_table); - png_ptr->gamma_table = NULL; - - if (png_ptr->gamma_16_table != NULL) - { - int i; - int istop = (1 << (8 - png_ptr->gamma_shift)); - for (i = 0; i < istop; i++) - { - png_free(png_ptr, png_ptr->gamma_16_table[i]); - } - png_free(png_ptr, png_ptr->gamma_16_table); - png_ptr->gamma_16_table = NULL; - } - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ - defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) - png_free(png_ptr, png_ptr->gamma_from_1); - png_ptr->gamma_from_1 = NULL; - png_free(png_ptr, png_ptr->gamma_to_1); - png_ptr->gamma_to_1 = NULL; - - if (png_ptr->gamma_16_from_1 != NULL) - { - int i; - int istop = (1 << (8 - png_ptr->gamma_shift)); - for (i = 0; i < istop; i++) - { - png_free(png_ptr, png_ptr->gamma_16_from_1[i]); - } - png_free(png_ptr, png_ptr->gamma_16_from_1); - png_ptr->gamma_16_from_1 = NULL; - } - if (png_ptr->gamma_16_to_1 != NULL) - { - int i; - int istop = (1 << (8 - png_ptr->gamma_shift)); - for (i = 0; i < istop; i++) - { - png_free(png_ptr, png_ptr->gamma_16_to_1[i]); - } - png_free(png_ptr, png_ptr->gamma_16_to_1); - png_ptr->gamma_16_to_1 = NULL; - } -#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ -} - -/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit - * tables, we don't make a full table if we are reducing to 8-bit in - * the future. Note also how the gamma_16 tables are segmented so that - * we don't need to allocate > 64K chunks for a full 16-bit table. - */ -void /* PRIVATE */ -png_build_gamma_table(png_structp png_ptr, int bit_depth) -{ - png_debug(1, "in png_build_gamma_table"); - - /* Remove any existing table; this copes with multiple calls to - * png_read_update_info. The warning is because building the gamma tables - * multiple times is a performance hit - it's harmless but the ability to call - * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible - * to warn if the app introduces such a hit. - */ - if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL) - { - png_warning(png_ptr, "gamma table being rebuilt"); - png_destroy_gamma_table(png_ptr); - } - - if (bit_depth <= 8) - { - png_build_8bit_table(png_ptr, &png_ptr->gamma_table, - png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma, - png_ptr->screen_gamma) : PNG_FP_1); - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ - defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) - if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) - { - png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1, - png_reciprocal(png_ptr->gamma)); - - png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1, - png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : - png_ptr->gamma/* Probably doing rgb_to_gray */); - } -#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ - } - else - { - png_byte shift, sig_bit; - - if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) - { - sig_bit = png_ptr->sig_bit.red; - - if (png_ptr->sig_bit.green > sig_bit) - sig_bit = png_ptr->sig_bit.green; - - if (png_ptr->sig_bit.blue > sig_bit) - sig_bit = png_ptr->sig_bit.blue; - } - else - sig_bit = png_ptr->sig_bit.gray; - - /* 16-bit gamma code uses this equation: - * - * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8] - * - * Where 'iv' is the input color value and 'ov' is the output value - - * pow(iv, gamma). - * - * Thus the gamma table consists of up to 256 256-entry tables. The table - * is selected by the (8-gamma_shift) most significant of the low 8 bits of - * the color value then indexed by the upper 8 bits: - * - * table[low bits][high 8 bits] - * - * So the table 'n' corresponds to all those 'iv' of: - * - * ..<(n+1 << gamma_shift)-1> - * - */ - if (sig_bit > 0 && sig_bit < 16U) - shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */ - - else - shift = 0; /* keep all 16 bits */ - - if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) - { - /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively - * the significant bits in the *input* when the output will - * eventually be 8 bits. By default it is 11. - */ - if (shift < (16U - PNG_MAX_GAMMA_8)) - shift = (16U - PNG_MAX_GAMMA_8); - } - - if (shift > 8U) - shift = 8U; /* Guarantees at least one table! */ - - png_ptr->gamma_shift = shift; - -#ifdef PNG_16BIT_SUPPORTED - /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now - * PNG_COMPOSE). This effectively smashed the background calculation for - * 16-bit output because the 8-bit table assumes the result will be reduced - * to 8 bits. - */ - if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) -#endif - png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift, - png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma, - png_ptr->screen_gamma) : PNG_FP_1); - -#ifdef PNG_16BIT_SUPPORTED - else - png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift, - png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma, - png_ptr->screen_gamma) : PNG_FP_1); -#endif - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ - defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) - if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) - { - png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift, - png_reciprocal(png_ptr->gamma)); - - /* Notice that the '16 from 1' table should be full precision, however - * the lookup on this table still uses gamma_shift, so it can't be. - * TODO: fix this. - */ - png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift, - png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : - png_ptr->gamma/* Probably doing rgb_to_gray */); - } -#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ - } -} -#endif /* READ_GAMMA */ -#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ diff --git a/source/libpng/pngerror.c b/source/libpng/pngerror.c deleted file mode 100644 index ad51f3e..0000000 --- a/source/libpng/pngerror.c +++ /dev/null @@ -1,696 +0,0 @@ - -/* pngerror.c - stub functions for i/o and memory allocation - * - * Last changed in libpng 1.5.8 [February 1, 2011] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file provides a location for all error handling. Users who - * need special error handling are expected to write replacement functions - * and use png_set_error_fn() to use those functions. See the instructions - * at each function. - */ - -#include "pngpriv.h" - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) - -static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr, - png_const_charp error_message)),PNG_NORETURN); - -#ifdef PNG_WARNINGS_SUPPORTED -static void /* PRIVATE */ -png_default_warning PNGARG((png_structp png_ptr, - png_const_charp warning_message)); -#endif /* PNG_WARNINGS_SUPPORTED */ - -/* This function is called whenever there is a fatal error. This function - * should not be changed. If there is a need to handle errors differently, - * you should supply a replacement error function and use png_set_error_fn() - * to replace the error function at run-time. - */ -#ifdef PNG_ERROR_TEXT_SUPPORTED -PNG_FUNCTION(void,PNGAPI -png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN) -{ -#ifdef PNG_ERROR_NUMBERS_SUPPORTED - char msg[16]; - if (png_ptr != NULL) - { - if (png_ptr->flags& - (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) - { - if (*error_message == PNG_LITERAL_SHARP) - { - /* Strip "#nnnn " from beginning of error message. */ - int offset; - for (offset = 1; offset<15; offset++) - if (error_message[offset] == ' ') - break; - - if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) - { - int i; - for (i = 0; i < offset - 1; i++) - msg[i] = error_message[i + 1]; - msg[i - 1] = '\0'; - error_message = msg; - } - - else - error_message += offset; - } - - else - { - if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) - { - msg[0] = '0'; - msg[1] = '\0'; - error_message = msg; - } - } - } - } -#endif - if (png_ptr != NULL && png_ptr->error_fn != NULL) - (*(png_ptr->error_fn))(png_ptr, error_message); - - /* If the custom handler doesn't exist, or if it returns, - use the default handler, which will not return. */ - png_default_error(png_ptr, error_message); -} -#else -PNG_FUNCTION(void,PNGAPI -png_err,(png_structp png_ptr),PNG_NORETURN) -{ - /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed - * erroneously as '\0', instead of the empty string "". This was - * apparently an error, introduced in libpng-1.2.20, and png_default_error - * will crash in this case. - */ - if (png_ptr != NULL && png_ptr->error_fn != NULL) - (*(png_ptr->error_fn))(png_ptr, ""); - - /* If the custom handler doesn't exist, or if it returns, - use the default handler, which will not return. */ - png_default_error(png_ptr, ""); -} -#endif /* PNG_ERROR_TEXT_SUPPORTED */ - -/* Utility to safely appends strings to a buffer. This never errors out so - * error checking is not required in the caller. - */ -size_t -png_safecat(png_charp buffer, size_t bufsize, size_t pos, - png_const_charp string) -{ - if (buffer != NULL && pos < bufsize) - { - if (string != NULL) - while (*string != '\0' && pos < bufsize-1) - buffer[pos++] = *string++; - - buffer[pos] = '\0'; - } - - return pos; -} - -#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED) -/* Utility to dump an unsigned value into a buffer, given a start pointer and - * and end pointer (which should point just *beyond* the end of the buffer!) - * Returns the pointer to the start of the formatted string. - */ -png_charp -png_format_number(png_const_charp start, png_charp end, int format, - png_alloc_size_t number) -{ - int count = 0; /* number of digits output */ - int mincount = 1; /* minimum number required */ - int output = 0; /* digit output (for the fixed point format) */ - - *--end = '\0'; - - /* This is written so that the loop always runs at least once, even with - * number zero. - */ - while (end > start && (number != 0 || count < mincount)) - { - - static const char digits[] = "0123456789ABCDEF"; - - switch (format) - { - case PNG_NUMBER_FORMAT_fixed: - /* Needs five digits (the fraction) */ - mincount = 5; - if (output || number % 10 != 0) - { - *--end = digits[number % 10]; - output = 1; - } - number /= 10; - break; - - case PNG_NUMBER_FORMAT_02u: - /* Expects at least 2 digits. */ - mincount = 2; - /* fall through */ - - case PNG_NUMBER_FORMAT_u: - *--end = digits[number % 10]; - number /= 10; - break; - - case PNG_NUMBER_FORMAT_02x: - /* This format expects at least two digits */ - mincount = 2; - /* fall through */ - - case PNG_NUMBER_FORMAT_x: - *--end = digits[number & 0xf]; - number >>= 4; - break; - - default: /* an error */ - number = 0; - break; - } - - /* Keep track of the number of digits added */ - ++count; - - /* Float a fixed number here: */ - if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start) - { - /* End of the fraction, but maybe nothing was output? In that case - * drop the decimal point. If the number is a true zero handle that - * here. - */ - if (output) - *--end = '.'; - else if (number == 0) /* and !output */ - *--end = '0'; - } - } - - return end; -} -#endif - -#ifdef PNG_WARNINGS_SUPPORTED -/* This function is called whenever there is a non-fatal error. This function - * should not be changed. If there is a need to handle warnings differently, - * you should supply a replacement warning function and use - * png_set_error_fn() to replace the warning function at run-time. - */ -void PNGAPI -png_warning(png_structp png_ptr, png_const_charp warning_message) -{ - int offset = 0; - if (png_ptr != NULL) - { -#ifdef PNG_ERROR_NUMBERS_SUPPORTED - if (png_ptr->flags& - (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) -#endif - { - if (*warning_message == PNG_LITERAL_SHARP) - { - for (offset = 1; offset < 15; offset++) - if (warning_message[offset] == ' ') - break; - } - } - } - if (png_ptr != NULL && png_ptr->warning_fn != NULL) - (*(png_ptr->warning_fn))(png_ptr, warning_message + offset); - else - png_default_warning(png_ptr, warning_message + offset); -} - -/* These functions support 'formatted' warning messages with up to - * PNG_WARNING_PARAMETER_COUNT parameters. In the format string the parameter - * is introduced by @, where 'number' starts at 1. This follows the - * standard established by X/Open for internationalizable error messages. - */ -void -png_warning_parameter(png_warning_parameters p, int number, - png_const_charp string) -{ - if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT) - (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string); -} - -void -png_warning_parameter_unsigned(png_warning_parameters p, int number, int format, - png_alloc_size_t value) -{ - char buffer[PNG_NUMBER_BUFFER_SIZE]; - png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value)); -} - -void -png_warning_parameter_signed(png_warning_parameters p, int number, int format, - png_int_32 value) -{ - png_alloc_size_t u; - png_charp str; - char buffer[PNG_NUMBER_BUFFER_SIZE]; - - /* Avoid overflow by doing the negate in a png_alloc_size_t: */ - u = (png_alloc_size_t)value; - if (value < 0) - u = ~u + 1; - - str = PNG_FORMAT_NUMBER(buffer, format, u); - - if (value < 0 && str > buffer) - *--str = '-'; - - png_warning_parameter(p, number, str); -} - -void -png_formatted_warning(png_structp png_ptr, png_warning_parameters p, - png_const_charp message) -{ - /* The internal buffer is just 192 bytes - enough for all our messages, - * overflow doesn't happen because this code checks! If someone figures - * out how to send us a message longer than 192 bytes, all that will - * happen is that the message will be truncated appropriately. - */ - size_t i = 0; /* Index in the msg[] buffer: */ - char msg[192]; - - /* Each iteration through the following loop writes at most one character - * to msg[i++] then returns here to validate that there is still space for - * the trailing '\0'. It may (in the case of a parameter) read more than - * one character from message[]; it must check for '\0' and continue to the - * test if it finds the end of string. - */ - while (i<(sizeof msg)-1 && *message != '\0') - { - /* '@' at end of string is now just printed (previously it was skipped); - * it is an error in the calling code to terminate the string with @. - */ - if (p != NULL && *message == '@' && message[1] != '\0') - { - int parameter_char = *++message; /* Consume the '@' */ - static const char valid_parameters[] = "123456789"; - int parameter = 0; - - /* Search for the parameter digit, the index in the string is the - * parameter to use. - */ - while (valid_parameters[parameter] != parameter_char && - valid_parameters[parameter] != '\0') - ++parameter; - - /* If the parameter digit is out of range it will just get printed. */ - if (parameter < PNG_WARNING_PARAMETER_COUNT) - { - /* Append this parameter */ - png_const_charp parm = p[parameter]; - png_const_charp pend = p[parameter] + (sizeof p[parameter]); - - /* No need to copy the trailing '\0' here, but there is no guarantee - * that parm[] has been initialized, so there is no guarantee of a - * trailing '\0': - */ - while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend) - msg[i++] = *parm++; - - /* Consume the parameter digit too: */ - ++message; - continue; - } - - /* else not a parameter and there is a character after the @ sign; just - * copy that. This is known not to be '\0' because of the test above. - */ - } - - /* At this point *message can't be '\0', even in the bad parameter case - * above where there is a lone '@' at the end of the message string. - */ - msg[i++] = *message++; - } - - /* i is always less than (sizeof msg), so: */ - msg[i] = '\0'; - - /* And this is the formatted message, it may be larger than - * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these are - * not (currently) formatted. - */ - png_warning(png_ptr, msg); -} -#endif /* PNG_WARNINGS_SUPPORTED */ - -#ifdef PNG_BENIGN_ERRORS_SUPPORTED -void PNGAPI -png_benign_error(png_structp png_ptr, png_const_charp error_message) -{ - if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) - png_warning(png_ptr, error_message); - else - png_error(png_ptr, error_message); -} -#endif - -/* These utilities are used internally to build an error message that relates - * to the current chunk. The chunk name comes from png_ptr->chunk_name, - * this is used to prefix the message. The message is limited in length - * to 63 bytes, the name characters are output as hex digits wrapped in [] - * if the character is invalid. - */ -#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) -static PNG_CONST char png_digit[16] = { - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'A', 'B', 'C', 'D', 'E', 'F' -}; - -#define PNG_MAX_ERROR_TEXT 64 -#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) -static void /* PRIVATE */ -png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp - error_message) -{ - png_uint_32 chunk_name = png_ptr->chunk_name; - int iout = 0, ishift = 24; - - while (ishift >= 0) - { - int c = (int)(chunk_name >> ishift) & 0xff; - - ishift -= 8; - if (isnonalpha(c)) - { - buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET; - buffer[iout++] = png_digit[(c & 0xf0) >> 4]; - buffer[iout++] = png_digit[c & 0x0f]; - buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET; - } - - else - { - buffer[iout++] = (char)c; - } - } - - if (error_message == NULL) - buffer[iout] = '\0'; - - else - { - int iin = 0; - - buffer[iout++] = ':'; - buffer[iout++] = ' '; - - while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0') - buffer[iout++] = error_message[iin++]; - - /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */ - buffer[iout] = '\0'; - } -} -#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */ - -#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) -PNG_FUNCTION(void,PNGAPI -png_chunk_error,(png_structp png_ptr, png_const_charp error_message), - PNG_NORETURN) -{ - char msg[18+PNG_MAX_ERROR_TEXT]; - if (png_ptr == NULL) - png_error(png_ptr, error_message); - - else - { - png_format_buffer(png_ptr, msg, error_message); - png_error(png_ptr, msg); - } -} -#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */ - -#ifdef PNG_WARNINGS_SUPPORTED -void PNGAPI -png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) -{ - char msg[18+PNG_MAX_ERROR_TEXT]; - if (png_ptr == NULL) - png_warning(png_ptr, warning_message); - - else - { - png_format_buffer(png_ptr, msg, warning_message); - png_warning(png_ptr, msg); - } -} -#endif /* PNG_WARNINGS_SUPPORTED */ - -#ifdef PNG_READ_SUPPORTED -#ifdef PNG_BENIGN_ERRORS_SUPPORTED -void PNGAPI -png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message) -{ - if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) - png_chunk_warning(png_ptr, error_message); - - else - png_chunk_error(png_ptr, error_message); -} -#endif -#endif /* PNG_READ_SUPPORTED */ - -#ifdef PNG_ERROR_TEXT_SUPPORTED -#ifdef PNG_FLOATING_POINT_SUPPORTED -PNG_FUNCTION(void, -png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN) -{ -# define fixed_message "fixed point overflow in " -# define fixed_message_ln ((sizeof fixed_message)-1) - int iin; - char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT]; - png_memcpy(msg, fixed_message, fixed_message_ln); - iin = 0; - if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0) - { - msg[fixed_message_ln + iin] = name[iin]; - ++iin; - } - msg[fixed_message_ln + iin] = 0; - png_error(png_ptr, msg); -} -#endif -#endif - -#ifdef PNG_SETJMP_SUPPORTED -/* This API only exists if ANSI-C style error handling is used, - * otherwise it is necessary for png_default_error to be overridden. - */ -jmp_buf* PNGAPI -png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn, - size_t jmp_buf_size) -{ - if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf)) - return NULL; - - png_ptr->longjmp_fn = longjmp_fn; - return &png_ptr->longjmp_buffer; -} -#endif - -/* This is the default error handling function. Note that replacements for - * this function MUST NOT RETURN, or the program will likely crash. This - * function is used by default, or if the program supplies NULL for the - * error function pointer in png_set_error_fn(). - */ -static PNG_FUNCTION(void /* PRIVATE */, -png_default_error,(png_structp png_ptr, png_const_charp error_message), - PNG_NORETURN) -{ -#ifdef PNG_CONSOLE_IO_SUPPORTED -#ifdef PNG_ERROR_NUMBERS_SUPPORTED - /* Check on NULL only added in 1.5.4 */ - if (error_message != NULL && *error_message == PNG_LITERAL_SHARP) - { - /* Strip "#nnnn " from beginning of error message. */ - int offset; - char error_number[16]; - for (offset = 0; offset<15; offset++) - { - error_number[offset] = error_message[offset + 1]; - if (error_message[offset] == ' ') - break; - } - - if ((offset > 1) && (offset < 15)) - { - error_number[offset - 1] = '\0'; - fprintf(stderr, "libpng error no. %s: %s", - error_number, error_message + offset + 1); - fprintf(stderr, PNG_STRING_NEWLINE); - } - - else - { - fprintf(stderr, "libpng error: %s, offset=%d", - error_message, offset); - fprintf(stderr, PNG_STRING_NEWLINE); - } - } - else -#endif - { - fprintf(stderr, "libpng error: %s", error_message ? error_message : - "undefined"); - fprintf(stderr, PNG_STRING_NEWLINE); - } -#else - PNG_UNUSED(error_message) /* Make compiler happy */ -#endif - png_longjmp(png_ptr, 1); -} - -PNG_FUNCTION(void,PNGAPI -png_longjmp,(png_structp png_ptr, int val),/*PNG_NORETURN*/) -{ - debugNetPrintf(2,"%s\n",__FUNCTION__); - #ifdef PNG_SETJMP_SUPPORTED - debugNetPrintf(2,"%sin ifdef PNG_SETJMP_SUPPORTED\n",__FUNCTION__); - - if (png_ptr && png_ptr->longjmp_fn) - { - debugNetPrintf(2,"%spng_ptr is not NULL png_ptr->longjmp_fn\n ",__FUNCTION__); - - # ifdef USE_FAR_KEYWORD - { - debugNetPrintf(2,"%s USE_FAR_KEYWORD\n",__FUNCTION__); - - jmp_buf tmp_jmpbuf; - png_memcpy(tmp_jmpbuf, png_ptr->longjmp_buffer, png_sizeof(jmp_buf)); - png_ptr->longjmp_fn(tmp_jmpbuf, val); - } - - # else - png_ptr->longjmp_fn(png_ptr->longjmp_buffer, val); - debugNetPrintf(2,"%s png_ptr->longjmp_fn\n ",__FUNCTION__); - - # endif - } - #endif - debugNetPrintf(2,"%sABORT\n ",__FUNCTION__); - - /* Here if not setjmp support or if png_ptr is null. */ - PNG_ABORT(); -} - -#ifdef PNG_WARNINGS_SUPPORTED -/* This function is called when there is a warning, but the library thinks - * it can continue anyway. Replacement functions don't have to do anything - * here if you don't want them to. In the default configuration, png_ptr is - * not used, but it is passed in case it may be useful. - */ -static void /* PRIVATE */ -png_default_warning(png_structp png_ptr, png_const_charp warning_message) -{ -#ifdef PNG_CONSOLE_IO_SUPPORTED -# ifdef PNG_ERROR_NUMBERS_SUPPORTED - if (*warning_message == PNG_LITERAL_SHARP) - { - int offset; - char warning_number[16]; - for (offset = 0; offset < 15; offset++) - { - warning_number[offset] = warning_message[offset + 1]; - if (warning_message[offset] == ' ') - break; - } - - if ((offset > 1) && (offset < 15)) - { - warning_number[offset + 1] = '\0'; - fprintf(stderr, "libpng warning no. %s: %s", - warning_number, warning_message + offset); - fprintf(stderr, PNG_STRING_NEWLINE); - } - - else - { - fprintf(stderr, "libpng warning: %s", - warning_message); - fprintf(stderr, PNG_STRING_NEWLINE); - } - } - else -# endif - - { - fprintf(stderr, "libpng warning: %s", warning_message); - fprintf(stderr, PNG_STRING_NEWLINE); - } -#else - PNG_UNUSED(warning_message) /* Make compiler happy */ -#endif - PNG_UNUSED(png_ptr) /* Make compiler happy */ -} -#endif /* PNG_WARNINGS_SUPPORTED */ - -/* This function is called when the application wants to use another method - * of handling errors and warnings. Note that the error function MUST NOT - * return to the calling routine or serious problems will occur. The return - * method used in the default routine calls longjmp(png_ptr->longjmp_buffer, 1) - */ -void PNGAPI -png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warning_fn) -{ - if (png_ptr == NULL) - return; - - png_ptr->error_ptr = error_ptr; - png_ptr->error_fn = error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - png_ptr->warning_fn = warning_fn; -#else - PNG_UNUSED(warning_fn) -#endif -} - - -/* This function returns a pointer to the error_ptr associated with the user - * functions. The application should free any memory associated with this - * pointer before png_write_destroy and png_read_destroy are called. - */ -png_voidp PNGAPI -png_get_error_ptr(png_const_structp png_ptr) -{ - if (png_ptr == NULL) - return NULL; - - return ((png_voidp)png_ptr->error_ptr); -} - - -#ifdef PNG_ERROR_NUMBERS_SUPPORTED -void PNGAPI -png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) -{ - if (png_ptr != NULL) - { - png_ptr->flags &= - ((~(PNG_FLAG_STRIP_ERROR_NUMBERS | - PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); - } -} -#endif -#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngget.c b/source/libpng/pngget.c deleted file mode 100644 index d53c874..0000000 --- a/source/libpng/pngget.c +++ /dev/null @@ -1,1124 +0,0 @@ - -/* pngget.c - retrieval of values from info struct - * - * Last changed in libpng 1.5.7 [December 15, 2011] - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - */ - -#include "pngpriv.h" - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) - -png_uint_32 PNGAPI -png_get_valid(png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_32 flag) -{ - if (png_ptr != NULL && info_ptr != NULL) - return(info_ptr->valid & flag); - - return(0); -} - -png_size_t PNGAPI -png_get_rowbytes(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return(info_ptr->rowbytes); - - return(0); -} - -#ifdef PNG_INFO_IMAGE_SUPPORTED -png_bytepp PNGAPI -png_get_rows(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return(info_ptr->row_pointers); - - return(0); -} -#endif - -#ifdef PNG_EASY_ACCESS_SUPPORTED -/* Easy access to info, added in libpng-0.99 */ -png_uint_32 PNGAPI -png_get_image_width(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->width; - - return (0); -} - -png_uint_32 PNGAPI -png_get_image_height(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->height; - - return (0); -} - -png_byte PNGAPI -png_get_bit_depth(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->bit_depth; - - return (0); -} - -png_byte PNGAPI -png_get_color_type(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->color_type; - - return (0); -} - -png_byte PNGAPI -png_get_filter_type(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->filter_type; - - return (0); -} - -png_byte PNGAPI -png_get_interlace_type(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->interlace_type; - - return (0); -} - -png_byte PNGAPI -png_get_compression_type(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return info_ptr->compression_type; - - return (0); -} - -png_uint_32 PNGAPI -png_get_x_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_pHYs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) - { - png_debug1(1, "in %s retrieval function", - "png_get_x_pixels_per_meter"); - - if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) - return (info_ptr->x_pixels_per_unit); - } -#endif - - return (0); -} - -png_uint_32 PNGAPI -png_get_y_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_pHYs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) - { - png_debug1(1, "in %s retrieval function", - "png_get_y_pixels_per_meter"); - - if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) - return (info_ptr->y_pixels_per_unit); - } -#endif - - return (0); -} - -png_uint_32 PNGAPI -png_get_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_pHYs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) - { - png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter"); - - if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER && - info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit) - return (info_ptr->x_pixels_per_unit); - } -#endif - - return (0); -} - -#ifdef PNG_FLOATING_POINT_SUPPORTED -float PNGAPI -png_get_pixel_aspect_ratio(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_READ_pHYs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) - { - png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); - - if (info_ptr->x_pixels_per_unit != 0) - return ((float)((float)info_ptr->y_pixels_per_unit - /(float)info_ptr->x_pixels_per_unit)); - } -#endif - - return ((float)0.0); -} -#endif - -#ifdef PNG_FIXED_POINT_SUPPORTED -png_fixed_point PNGAPI -png_get_pixel_aspect_ratio_fixed(png_const_structp png_ptr, - png_const_infop info_ptr) -{ -#ifdef PNG_READ_pHYs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs) - && info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 - && info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX - && info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX) - { - png_fixed_point res; - - png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed"); - - /* The following casts work because a PNG 4 byte integer only has a valid - * range of 0..2^31-1; otherwise the cast might overflow. - */ - if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1, - (png_int_32)info_ptr->x_pixels_per_unit)) - return res; - } -#endif - - return 0; -} -#endif - -png_int_32 PNGAPI -png_get_x_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_oFFs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) - { - png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); - - if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) - return (info_ptr->x_offset); - } -#endif - - return (0); -} - -png_int_32 PNGAPI -png_get_y_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_oFFs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) - { - png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); - - if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) - return (info_ptr->y_offset); - } -#endif - - return (0); -} - -png_int_32 PNGAPI -png_get_x_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_oFFs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) - { - png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels"); - - if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) - return (info_ptr->x_offset); - } -#endif - - return (0); -} - -png_int_32 PNGAPI -png_get_y_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr) -{ -#ifdef PNG_oFFs_SUPPORTED - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) - { - png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels"); - - if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) - return (info_ptr->y_offset); - } -#endif - - return (0); -} - -#ifdef PNG_INCH_CONVERSIONS_SUPPORTED -static png_uint_32 -ppi_from_ppm(png_uint_32 ppm) -{ -#if 0 - /* The conversion is *(2.54/100), in binary (32 digits): - * .00000110100000001001110101001001 - */ - png_uint_32 t1001, t1101; - ppm >>= 1; /* .1 */ - t1001 = ppm + (ppm >> 3); /* .1001 */ - t1101 = t1001 + (ppm >> 1); /* .1101 */ - ppm >>= 20; /* .000000000000000000001 */ - t1101 += t1101 >> 15; /* .1101000000000001101 */ - t1001 >>= 11; /* .000000000001001 */ - t1001 += t1001 >> 12; /* .000000000001001000000001001 */ - ppm += t1001; /* .000000000001001000001001001 */ - ppm += t1101; /* .110100000001001110101001001 */ - return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */ -#else - /* The argument is a PNG unsigned integer, so it is not permitted - * to be bigger than 2^31. - */ - png_fixed_point result; - if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127, - 5000)) - return result; - - /* Overflow. */ - return 0; -#endif -} - -png_uint_32 PNGAPI -png_get_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) -{ - return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr)); -} - -png_uint_32 PNGAPI -png_get_x_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) -{ - return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr)); -} - -png_uint_32 PNGAPI -png_get_y_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) -{ - return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr)); -} - -#ifdef PNG_FIXED_POINT_SUPPORTED -static png_fixed_point -png_fixed_inches_from_microns(png_structp png_ptr, png_int_32 microns) -{ - /* Convert from metres * 1,000,000 to inches * 100,000, meters to - * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127. - * Notice that this can overflow - a warning is output and 0 is - * returned. - */ - return png_muldiv_warn(png_ptr, microns, 500, 127); -} - -png_fixed_point PNGAPI -png_get_x_offset_inches_fixed(png_structp png_ptr, - png_const_infop info_ptr) -{ - return png_fixed_inches_from_microns(png_ptr, - png_get_x_offset_microns(png_ptr, info_ptr)); -} -#endif - -#ifdef PNG_FIXED_POINT_SUPPORTED -png_fixed_point PNGAPI -png_get_y_offset_inches_fixed(png_structp png_ptr, - png_const_infop info_ptr) -{ - return png_fixed_inches_from_microns(png_ptr, - png_get_y_offset_microns(png_ptr, info_ptr)); -} -#endif - -#ifdef PNG_FLOATING_POINT_SUPPORTED -float PNGAPI -png_get_x_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr) -{ - /* To avoid the overflow do the conversion directly in floating - * point. - */ - return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937); -} -#endif - -#ifdef PNG_FLOATING_POINT_SUPPORTED -float PNGAPI -png_get_y_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr) -{ - /* To avoid the overflow do the conversion directly in floating - * point. - */ - return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937); -} -#endif - -#ifdef PNG_pHYs_SUPPORTED -png_uint_32 PNGAPI -png_get_pHYs_dpi(png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) -{ - png_uint_32 retval = 0; - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) - { - png_debug1(1, "in %s retrieval function", "pHYs"); - - if (res_x != NULL) - { - *res_x = info_ptr->x_pixels_per_unit; - retval |= PNG_INFO_pHYs; - } - - if (res_y != NULL) - { - *res_y = info_ptr->y_pixels_per_unit; - retval |= PNG_INFO_pHYs; - } - - if (unit_type != NULL) - { - *unit_type = (int)info_ptr->phys_unit_type; - retval |= PNG_INFO_pHYs; - - if (*unit_type == 1) - { - if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); - if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); - } - } - } - - return (retval); -} -#endif /* PNG_pHYs_SUPPORTED */ -#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ - -/* png_get_channels really belongs in here, too, but it's been around longer */ - -#endif /* PNG_EASY_ACCESS_SUPPORTED */ - -png_byte PNGAPI -png_get_channels(png_const_structp png_ptr, png_const_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return(info_ptr->channels); - - return (0); -} - -png_const_bytep PNGAPI -png_get_signature(png_const_structp png_ptr, png_infop info_ptr) -{ - if (png_ptr != NULL && info_ptr != NULL) - return(info_ptr->signature); - - return (NULL); -} - -#ifdef PNG_bKGD_SUPPORTED -png_uint_32 PNGAPI -png_get_bKGD(png_const_structp png_ptr, png_infop info_ptr, - png_color_16p *background) -{ - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) - && background != NULL) - { - png_debug1(1, "in %s retrieval function", "bKGD"); - - *background = &(info_ptr->background); - return (PNG_INFO_bKGD); - } - - return (0); -} -#endif - -#ifdef PNG_cHRM_SUPPORTED -/* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the - * same time to correct the rgb grayscale coefficient defaults obtained from the - * cHRM chunk in 1.5.4 - */ -png_uint_32 PNGFAPI -png_get_cHRM_XYZ_fixed(png_structp png_ptr, png_const_infop info_ptr, - png_fixed_point *int_red_X, png_fixed_point *int_red_Y, - png_fixed_point *int_red_Z, png_fixed_point *int_green_X, - png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, - png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, - png_fixed_point *int_blue_Z) -{ - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) - { - png_xy xy; - png_XYZ XYZ; - - png_debug1(1, "in %s retrieval function", "cHRM_XYZ"); - - xy.whitex = info_ptr->x_white; - xy.whitey = info_ptr->y_white; - xy.redx = info_ptr->x_red; - xy.redy = info_ptr->y_red; - xy.greenx = info_ptr->x_green; - xy.greeny = info_ptr->y_green; - xy.bluex = info_ptr->x_blue; - xy.bluey = info_ptr->y_blue; - - /* The *_checked function handles error reporting, so just return 0 if - * there is a failure here. - */ - if (png_XYZ_from_xy_checked(png_ptr, &XYZ, xy)) - { - if (int_red_X != NULL) - *int_red_X = XYZ.redX; - if (int_red_Y != NULL) - *int_red_Y = XYZ.redY; - if (int_red_Z != NULL) - *int_red_Z = XYZ.redZ; - if (int_green_X != NULL) - *int_green_X = XYZ.greenX; - if (int_green_Y != NULL) - *int_green_Y = XYZ.greenY; - if (int_green_Z != NULL) - *int_green_Z = XYZ.greenZ; - if (int_blue_X != NULL) - *int_blue_X = XYZ.blueX; - if (int_blue_Y != NULL) - *int_blue_Y = XYZ.blueY; - if (int_blue_Z != NULL) - *int_blue_Z = XYZ.blueZ; - - return (PNG_INFO_cHRM); - } - } - - return (0); -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -png_uint_32 PNGAPI -png_get_cHRM(png_const_structp png_ptr, png_const_infop info_ptr, - double *white_x, double *white_y, double *red_x, double *red_y, - double *green_x, double *green_y, double *blue_x, double *blue_y) -{ - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) - { - png_debug1(1, "in %s retrieval function", "cHRM"); - - if (white_x != NULL) - *white_x = png_float(png_ptr, info_ptr->x_white, "cHRM white X"); - if (white_y != NULL) - *white_y = png_float(png_ptr, info_ptr->y_white, "cHRM white Y"); - if (red_x != NULL) - *red_x = png_float(png_ptr, info_ptr->x_red, "cHRM red X"); - if (red_y != NULL) - *red_y = png_float(png_ptr, info_ptr->y_red, "cHRM red Y"); - if (green_x != NULL) - *green_x = png_float(png_ptr, info_ptr->x_green, "cHRM green X"); - if (green_y != NULL) - *green_y = png_float(png_ptr, info_ptr->y_green, "cHRM green Y"); - if (blue_x != NULL) - *blue_x = png_float(png_ptr, info_ptr->x_blue, "cHRM blue X"); - if (blue_y != NULL) - *blue_y = png_float(png_ptr, info_ptr->y_blue, "cHRM blue Y"); - return (PNG_INFO_cHRM); - } - - return (0); -} - -png_uint_32 PNGAPI -png_get_cHRM_XYZ(png_structp png_ptr, png_const_infop info_ptr, - double *red_X, double *red_Y, double *red_Z, double *green_X, - double *green_Y, double *green_Z, double *blue_X, double *blue_Y, - double *blue_Z) -{ - png_XYZ XYZ; - - if (png_get_cHRM_XYZ_fixed(png_ptr, info_ptr, - &XYZ.redX, &XYZ.redY, &XYZ.redZ, &XYZ.greenX, &XYZ.greenY, &XYZ.greenZ, - &XYZ.blueX, &XYZ.blueY, &XYZ.blueZ) & PNG_INFO_cHRM) - { - if (red_X != NULL) - *red_X = png_float(png_ptr, XYZ.redX, "cHRM red X"); - if (red_Y != NULL) - *red_Y = png_float(png_ptr, XYZ.redY, "cHRM red Y"); - if (red_Z != NULL) - *red_Z = png_float(png_ptr, XYZ.redZ, "cHRM red Z"); - if (green_X != NULL) - *green_X = png_float(png_ptr, XYZ.greenX, "cHRM green X"); - if (green_Y != NULL) - *green_Y = png_float(png_ptr, XYZ.greenY, "cHRM green Y"); - if (green_Z != NULL) - *green_Z = png_float(png_ptr, XYZ.greenZ, "cHRM green Z"); - if (blue_X != NULL) - *blue_X = png_float(png_ptr, XYZ.blueX, "cHRM blue X"); - if (blue_Y != NULL) - *blue_Y = png_float(png_ptr, XYZ.blueY, "cHRM blue Y"); - if (blue_Z != NULL) - *blue_Z = png_float(png_ptr, XYZ.blueZ, "cHRM blue Z"); - return (PNG_INFO_cHRM); - } - - return (0); -} -# endif - -# ifdef PNG_FIXED_POINT_SUPPORTED -png_uint_32 PNGAPI -png_get_cHRM_fixed(png_const_structp png_ptr, png_const_infop info_ptr, - png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, - png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, - png_fixed_point *blue_x, png_fixed_point *blue_y) -{ - png_debug1(1, "in %s retrieval function", "cHRM"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) - { - if (white_x != NULL) - *white_x = info_ptr->x_white; - if (white_y != NULL) - *white_y = info_ptr->y_white; - if (red_x != NULL) - *red_x = info_ptr->x_red; - if (red_y != NULL) - *red_y = info_ptr->y_red; - if (green_x != NULL) - *green_x = info_ptr->x_green; - if (green_y != NULL) - *green_y = info_ptr->y_green; - if (blue_x != NULL) - *blue_x = info_ptr->x_blue; - if (blue_y != NULL) - *blue_y = info_ptr->y_blue; - return (PNG_INFO_cHRM); - } - - return (0); -} -# endif -#endif - -#ifdef PNG_gAMA_SUPPORTED -png_uint_32 PNGFAPI -png_get_gAMA_fixed(png_const_structp png_ptr, png_const_infop info_ptr, - png_fixed_point *file_gamma) -{ - png_debug1(1, "in %s retrieval function", "gAMA"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) - && file_gamma != NULL) - { - *file_gamma = info_ptr->gamma; - return (PNG_INFO_gAMA); - } - - return (0); -} -# ifdef PNG_FLOATING_POINT_SUPPORTED -png_uint_32 PNGAPI -png_get_gAMA(png_const_structp png_ptr, png_const_infop info_ptr, - double *file_gamma) -{ - png_fixed_point igamma = 0; - png_uint_32 ok = png_get_gAMA_fixed(png_ptr, info_ptr, &igamma); - - if (ok) - *file_gamma = png_float(png_ptr, igamma, "png_get_gAMA"); - - return ok; -} - -# endif -#endif - -#ifdef PNG_sRGB_SUPPORTED -png_uint_32 PNGAPI -png_get_sRGB(png_const_structp png_ptr, png_const_infop info_ptr, - int *file_srgb_intent) -{ - png_debug1(1, "in %s retrieval function", "sRGB"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) - && file_srgb_intent != NULL) - { - *file_srgb_intent = (int)info_ptr->srgb_intent; - return (PNG_INFO_sRGB); - } - - return (0); -} -#endif - -#ifdef PNG_iCCP_SUPPORTED -png_uint_32 PNGAPI -png_get_iCCP(png_const_structp png_ptr, png_const_infop info_ptr, - png_charpp name, int *compression_type, - png_bytepp profile, png_uint_32 *proflen) -{ - png_debug1(1, "in %s retrieval function", "iCCP"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) - && name != NULL && compression_type != NULL && profile != NULL && - proflen != NULL) - { - *name = info_ptr->iccp_name; - *profile = info_ptr->iccp_profile; - /* Compression_type is a dummy so the API won't have to change - * if we introduce multiple compression types later. - */ - *proflen = info_ptr->iccp_proflen; - *compression_type = info_ptr->iccp_compression; - return (PNG_INFO_iCCP); - } - - return (0); -} -#endif - -#ifdef PNG_sPLT_SUPPORTED -png_uint_32 PNGAPI -png_get_sPLT(png_const_structp png_ptr, png_const_infop info_ptr, - png_sPLT_tpp spalettes) -{ - if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) - { - *spalettes = info_ptr->splt_palettes; - return ((png_uint_32)info_ptr->splt_palettes_num); - } - - return (0); -} -#endif - -#ifdef PNG_hIST_SUPPORTED -png_uint_32 PNGAPI -png_get_hIST(png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_16p *hist) -{ - png_debug1(1, "in %s retrieval function", "hIST"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) - && hist != NULL) - { - *hist = info_ptr->hist; - return (PNG_INFO_hIST); - } - - return (0); -} -#endif - -png_uint_32 PNGAPI -png_get_IHDR(png_structp png_ptr, png_infop info_ptr, - png_uint_32 *width, png_uint_32 *height, int *bit_depth, - int *color_type, int *interlace_type, int *compression_type, - int *filter_type) - -{ - png_debug1(1, "in %s retrieval function", "IHDR"); - - if (png_ptr == NULL || info_ptr == NULL || width == NULL || - height == NULL || bit_depth == NULL || color_type == NULL) - return (0); - - *width = info_ptr->width; - *height = info_ptr->height; - *bit_depth = info_ptr->bit_depth; - *color_type = info_ptr->color_type; - - if (compression_type != NULL) - *compression_type = info_ptr->compression_type; - - if (filter_type != NULL) - *filter_type = info_ptr->filter_type; - - if (interlace_type != NULL) - *interlace_type = info_ptr->interlace_type; - - /* This is redundant if we can be sure that the info_ptr values were all - * assigned in png_set_IHDR(). We do the check anyhow in case an - * application has ignored our advice not to mess with the members - * of info_ptr directly. - */ - png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height, - info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, - info_ptr->compression_type, info_ptr->filter_type); - - return (1); -} - -#ifdef PNG_oFFs_SUPPORTED -png_uint_32 PNGAPI -png_get_oFFs(png_const_structp png_ptr, png_const_infop info_ptr, - png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) -{ - png_debug1(1, "in %s retrieval function", "oFFs"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) - && offset_x != NULL && offset_y != NULL && unit_type != NULL) - { - *offset_x = info_ptr->x_offset; - *offset_y = info_ptr->y_offset; - *unit_type = (int)info_ptr->offset_unit_type; - return (PNG_INFO_oFFs); - } - - return (0); -} -#endif - -#ifdef PNG_pCAL_SUPPORTED -png_uint_32 PNGAPI -png_get_pCAL(png_const_structp png_ptr, png_const_infop info_ptr, - png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, - png_charp *units, png_charpp *params) -{ - png_debug1(1, "in %s retrieval function", "pCAL"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) - && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && - nparams != NULL && units != NULL && params != NULL) - { - *purpose = info_ptr->pcal_purpose; - *X0 = info_ptr->pcal_X0; - *X1 = info_ptr->pcal_X1; - *type = (int)info_ptr->pcal_type; - *nparams = (int)info_ptr->pcal_nparams; - *units = info_ptr->pcal_units; - *params = info_ptr->pcal_params; - return (PNG_INFO_pCAL); - } - - return (0); -} -#endif - -#ifdef PNG_sCAL_SUPPORTED -# ifdef PNG_FIXED_POINT_SUPPORTED -# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED -png_uint_32 PNGAPI -png_get_sCAL_fixed(png_structp png_ptr, png_const_infop info_ptr, - int *unit, png_fixed_point *width, png_fixed_point *height) -{ - if (png_ptr != NULL && info_ptr != NULL && - (info_ptr->valid & PNG_INFO_sCAL)) - { - *unit = info_ptr->scal_unit; - /*TODO: make this work without FP support */ - *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width"); - *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height), - "sCAL height"); - return (PNG_INFO_sCAL); - } - - return(0); -} -# endif /* FLOATING_ARITHMETIC */ -# endif /* FIXED_POINT */ -# ifdef PNG_FLOATING_POINT_SUPPORTED -png_uint_32 PNGAPI -png_get_sCAL(png_const_structp png_ptr, png_const_infop info_ptr, - int *unit, double *width, double *height) -{ - if (png_ptr != NULL && info_ptr != NULL && - (info_ptr->valid & PNG_INFO_sCAL)) - { - *unit = info_ptr->scal_unit; - *width = atof(info_ptr->scal_s_width); - *height = atof(info_ptr->scal_s_height); - return (PNG_INFO_sCAL); - } - - return(0); -} -# endif /* FLOATING POINT */ -png_uint_32 PNGAPI -png_get_sCAL_s(png_const_structp png_ptr, png_const_infop info_ptr, - int *unit, png_charpp width, png_charpp height) -{ - if (png_ptr != NULL && info_ptr != NULL && - (info_ptr->valid & PNG_INFO_sCAL)) - { - *unit = info_ptr->scal_unit; - *width = info_ptr->scal_s_width; - *height = info_ptr->scal_s_height; - return (PNG_INFO_sCAL); - } - - return(0); -} -#endif /* sCAL */ - -#ifdef PNG_pHYs_SUPPORTED -png_uint_32 PNGAPI -png_get_pHYs(png_const_structp png_ptr, png_const_infop info_ptr, - png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) -{ - png_uint_32 retval = 0; - - png_debug1(1, "in %s retrieval function", "pHYs"); - - if (png_ptr != NULL && info_ptr != NULL && - (info_ptr->valid & PNG_INFO_pHYs)) - { - if (res_x != NULL) - { - *res_x = info_ptr->x_pixels_per_unit; - retval |= PNG_INFO_pHYs; - } - - if (res_y != NULL) - { - *res_y = info_ptr->y_pixels_per_unit; - retval |= PNG_INFO_pHYs; - } - - if (unit_type != NULL) - { - *unit_type = (int)info_ptr->phys_unit_type; - retval |= PNG_INFO_pHYs; - } - } - - return (retval); -} -#endif /* pHYs */ - -png_uint_32 PNGAPI -png_get_PLTE(png_const_structp png_ptr, png_const_infop info_ptr, - png_colorp *palette, int *num_palette) -{ - png_debug1(1, "in %s retrieval function", "PLTE"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) - && palette != NULL) - { - *palette = info_ptr->palette; - *num_palette = info_ptr->num_palette; - png_debug1(3, "num_palette = %d", *num_palette); - return (PNG_INFO_PLTE); - } - - return (0); -} - -#ifdef PNG_sBIT_SUPPORTED -png_uint_32 PNGAPI -png_get_sBIT(png_const_structp png_ptr, png_infop info_ptr, - png_color_8p *sig_bit) -{ - png_debug1(1, "in %s retrieval function", "sBIT"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) - && sig_bit != NULL) - { - *sig_bit = &(info_ptr->sig_bit); - return (PNG_INFO_sBIT); - } - - return (0); -} -#endif - -#ifdef PNG_TEXT_SUPPORTED -png_uint_32 PNGAPI -png_get_text(png_const_structp png_ptr, png_const_infop info_ptr, - png_textp *text_ptr, int *num_text) -{ - if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) - { - png_debug1(1, "in 0x%lx retrieval function", - (unsigned long)png_ptr->chunk_name); - - if (text_ptr != NULL) - *text_ptr = info_ptr->text; - - if (num_text != NULL) - *num_text = info_ptr->num_text; - - return ((png_uint_32)info_ptr->num_text); - } - - if (num_text != NULL) - *num_text = 0; - - return(0); -} -#endif - -#ifdef PNG_tIME_SUPPORTED -png_uint_32 PNGAPI -png_get_tIME(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time) -{ - png_debug1(1, "in %s retrieval function", "tIME"); - - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) - && mod_time != NULL) - { - *mod_time = &(info_ptr->mod_time); - return (PNG_INFO_tIME); - } - - return (0); -} -#endif - -#ifdef PNG_tRNS_SUPPORTED -png_uint_32 PNGAPI -png_get_tRNS(png_const_structp png_ptr, png_infop info_ptr, - png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color) -{ - png_uint_32 retval = 0; - if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) - { - png_debug1(1, "in %s retrieval function", "tRNS"); - - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - if (trans_alpha != NULL) - { - *trans_alpha = info_ptr->trans_alpha; - retval |= PNG_INFO_tRNS; - } - - if (trans_color != NULL) - *trans_color = &(info_ptr->trans_color); - } - - else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ - { - if (trans_color != NULL) - { - *trans_color = &(info_ptr->trans_color); - retval |= PNG_INFO_tRNS; - } - - if (trans_alpha != NULL) - *trans_alpha = NULL; - } - - if (num_trans != NULL) - { - *num_trans = info_ptr->num_trans; - retval |= PNG_INFO_tRNS; - } - } - - return (retval); -} -#endif - -#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED -int PNGAPI -png_get_unknown_chunks(png_const_structp png_ptr, png_const_infop info_ptr, - png_unknown_chunkpp unknowns) -{ - if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) - { - *unknowns = info_ptr->unknown_chunks; - return info_ptr->unknown_chunks_num; - } - - return (0); -} -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED -png_byte PNGAPI -png_get_rgb_to_gray_status (png_const_structp png_ptr) -{ - return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); -} -#endif - -#ifdef PNG_USER_CHUNKS_SUPPORTED -png_voidp PNGAPI -png_get_user_chunk_ptr(png_const_structp png_ptr) -{ - return (png_ptr ? png_ptr->user_chunk_ptr : NULL); -} -#endif - -png_size_t PNGAPI -png_get_compression_buffer_size(png_const_structp png_ptr) -{ - return (png_ptr ? png_ptr->zbuf_size : 0); -} - -#ifdef PNG_SET_USER_LIMITS_SUPPORTED -/* These functions were added to libpng 1.2.6 and were enabled - * by default in libpng-1.4.0 */ -png_uint_32 PNGAPI -png_get_user_width_max (png_const_structp png_ptr) -{ - return (png_ptr ? png_ptr->user_width_max : 0); -} - -png_uint_32 PNGAPI -png_get_user_height_max (png_const_structp png_ptr) -{ - return (png_ptr ? png_ptr->user_height_max : 0); -} - -/* This function was added to libpng 1.4.0 */ -png_uint_32 PNGAPI -png_get_chunk_cache_max (png_const_structp png_ptr) -{ - return (png_ptr ? png_ptr->user_chunk_cache_max : 0); -} - -/* This function was added to libpng 1.4.1 */ -png_alloc_size_t PNGAPI -png_get_chunk_malloc_max (png_const_structp png_ptr) -{ - return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); -} -#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ - -/* These functions were added to libpng 1.4.0 */ -#ifdef PNG_IO_STATE_SUPPORTED -png_uint_32 PNGAPI -png_get_io_state (png_structp png_ptr) -{ - return png_ptr->io_state; -} - -png_uint_32 PNGAPI -png_get_io_chunk_type (png_const_structp png_ptr) -{ - return png_ptr->chunk_name; -} - -png_const_bytep PNGAPI -png_get_io_chunk_name (png_structp png_ptr) -{ - PNG_CSTRING_FROM_CHUNK(png_ptr->io_chunk_string, png_ptr->chunk_name); - return png_ptr->io_chunk_string; -} -#endif /* ?PNG_IO_STATE_SUPPORTED */ - -#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngmem.c b/source/libpng/pngmem.c deleted file mode 100644 index 304346b..0000000 --- a/source/libpng/pngmem.c +++ /dev/null @@ -1,728 +0,0 @@ - -/* pngmem.c - stub functions for memory allocation - * - * Last changed in libpng 1.5.7 [December 15, 2011] - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file provides a location for all memory allocation. Users who - * need special memory handling are expected to supply replacement - * functions for png_malloc() and png_free(), and to use - * png_create_read_struct_2() and png_create_write_struct_2() to - * identify the replacement functions. - */ - -#include "pngpriv.h" - - -/* ***************************************************************** */ -/* Added by Paul Pedriana so that we can override default allocation */ - -typedef png_voidp (*png_malloc_ptr_type)(size_t); -typedef void (*png_free_ptr_type)(void*); - -png_malloc_ptr_type g_png_default_malloc_ptr = NULL; -png_free_ptr_type g_png_default_free_ptr = NULL; - -void png_set_default_mem_fn(png_default_malloc_ptr malloc_fn, png_default_free_ptr free_fn) -{ - g_png_default_malloc_ptr = malloc_fn; - g_png_default_free_ptr = free_fn; -} - -/* End of additions by Paul Pedriana */ -/* ***************************************************************** */ - - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) - -/* Borland DOS special memory handler */ -#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) -/* If you change this, be sure to change the one in png.h also */ - -/* Allocate memory for a png_struct. The malloc and memset can be replaced - by a single call to calloc() if this is thought to improve performance. */ -PNG_FUNCTION(png_voidp /* PRIVATE */, -png_create_struct,(int type),PNG_ALLOCATED) -{ -# ifdef PNG_USER_MEM_SUPPORTED - return (png_create_struct_2(type, NULL, NULL)); -} - -/* Alternate version of png_create_struct, for use with user-defined malloc. */ -PNG_FUNCTION(png_voidp /* PRIVATE */, -png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr), - PNG_ALLOCATED) -{ -# endif /* PNG_USER_MEM_SUPPORTED */ - png_size_t size; - png_voidp struct_ptr; - - if (type == PNG_STRUCT_INFO) - size = png_sizeof(png_info); - - else if (type == PNG_STRUCT_PNG) - size = png_sizeof(png_struct); - - else - return (png_get_copyright(NULL)); - -# ifdef PNG_USER_MEM_SUPPORTED - if (malloc_fn != NULL) - { - png_struct dummy_struct; - memset(&dummy_struct, 0, sizeof dummy_struct); - dummy_struct.mem_ptr=mem_ptr; - struct_ptr = (*(malloc_fn))(&dummy_struct, (png_alloc_size_t)size); - } - - else -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (g_png_default_malloc_ptr) - struct_ptr = (png_voidp)(*g_png_default_malloc_ptr)(size); - else - struct_ptr = (png_voidp)farmalloc(size); - - if (struct_ptr != NULL) - png_memset(struct_ptr, 0, size); - - return (struct_ptr); -} - -/* Free memory allocated by a png_create_struct() call */ -void /* PRIVATE */ -png_destroy_struct(png_voidp struct_ptr) -{ -# ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2(struct_ptr, NULL, NULL); -} - -/* Free memory allocated by a png_create_struct() call */ -void /* PRIVATE */ -png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, - png_voidp mem_ptr) -{ -# endif - if (struct_ptr != NULL) - { -# ifdef PNG_USER_MEM_SUPPORTED - if (free_fn != NULL) - { - png_struct dummy_struct; - memset(&dummy_struct, 0, sizeof dummy_struct); - dummy_struct.mem_ptr=mem_ptr; - (*(free_fn))(&dummy_struct, struct_ptr); - return; - } - -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (g_png_default_free_ptr) - (*g_png_default_free_ptr)(struct_ptr); - else - farfree (struct_ptr); - } -} - -/* Allocate memory. For reasonable files, size should never exceed - * 64K. However, zlib may allocate more then 64K if you don't tell - * it not to. See zconf.h and png.h for more information. zlib does - * need to allocate exactly 64K, so whatever you call here must - * have the ability to do that. - * - * Borland seems to have a problem in DOS mode for exactly 64K. - * It gives you a segment with an offset of 8 (perhaps to store its - * memory stuff). zlib doesn't like this at all, so we have to - * detect and deal with it. This code should not be needed in - * Windows or OS/2 modes, and only in 16 bit mode. This code has - * been updated by Alexander Lehmann for version 0.89 to waste less - * memory. - * - * Note that we can't use png_size_t for the "size" declaration, - * since on some systems a png_size_t is a 16-bit quantity, and as a - * result, we would be truncating potentially larger memory requests - * (which should cause a fatal error) and introducing major problems. - */ -PNG_FUNCTION(png_voidp,PNGAPI -png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ret; - - ret = (png_malloc(png_ptr, size)); - - if (ret != NULL) - png_memset(ret,0,(png_size_t)size); - - return (ret); -} - -PNG_FUNCTION(png_voidp,PNGAPI -png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ret; - - if (png_ptr == NULL || size == 0) - return (NULL); - -# ifdef PNG_USER_MEM_SUPPORTED - if (png_ptr->malloc_fn != NULL) - ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size)); - - else - ret = (png_malloc_default(png_ptr, size)); - - if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out of memory"); - - return (ret); -} - -PNG_FUNCTION(png_voidp,PNGAPI -png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ret; -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (png_ptr == NULL || size == 0) - return (NULL); - -# ifdef PNG_MAX_MALLOC_64K - if (size > (png_uint_32)65536L) - { - png_warning(png_ptr, "Cannot Allocate > 64K"); - ret = NULL; - } - - else -# endif - - if (size != (size_t)size) - ret = NULL; - - else if (size == (png_uint_32)65536L) - { - if (png_ptr->offset_table == NULL) - { - /* Try to see if we need to do any of this fancy stuff */ - if (g_png_default_malloc_ptr) - ret = (*g_png_default_malloc_ptr)((size_t)size); - else - ret = farmalloc(size); - - if (ret == NULL || ((png_size_t)ret & 0xffff)) - { - int num_blocks; - png_uint_32 total_size; - png_bytep table; - int i, mem_level, window_bits; - png_byte huge * hptr; - int window_bits - - if (ret != NULL) - { - farfree(ret); - ret = NULL; - } - - window_bits = - png_ptr->zlib_window_bits >= png_ptr->zlib_text_window_bits ? - png_ptr->zlib_window_bits : png_ptr->zlib_text_window_bits; - - if (window_bits > 14) - num_blocks = (int)(1 << (window_bits - 14)); - - else - num_blocks = 1; - - mem_level = - png_ptr->zlib_mem_level >= png_ptr->zlib_text_mem_level ? - png_ptr->zlib_mem_level : png_ptr->zlib_text_mem_level; - - if (mem_level >= 7) - num_blocks += (int)(1 << (mem_level - 7)); - - else - num_blocks++; - - total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; - - table = farmalloc(total_size); - - if (table == NULL) - { -# ifndef PNG_USER_MEM_SUPPORTED - if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */ - - else - png_warning(png_ptr, "Out Of Memory"); -# endif - return (NULL); - } - - if ((png_size_t)table & 0xfff0) - { -# ifndef PNG_USER_MEM_SUPPORTED - if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, - "Farmalloc didn't return normalized pointer"); - - else - png_warning(png_ptr, - "Farmalloc didn't return normalized pointer"); -# endif - return (NULL); - } - - png_ptr->offset_table = table; - png_ptr->offset_table_ptr = farmalloc(num_blocks * - png_sizeof(png_bytep)); - - if (png_ptr->offset_table_ptr == NULL) - { -# ifndef PNG_USER_MEM_SUPPORTED - if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */ - - else - png_warning(png_ptr, "Out Of memory"); -# endif - return (NULL); - } - - hptr = (png_byte huge *)table; - if ((png_size_t)hptr & 0xf) - { - hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L); - hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */ - } - - for (i = 0; i < num_blocks; i++) - { - png_ptr->offset_table_ptr[i] = (png_bytep)hptr; - hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */ - } - - png_ptr->offset_table_number = num_blocks; - png_ptr->offset_table_count = 0; - png_ptr->offset_table_count_free = 0; - } - } - - if (png_ptr->offset_table_count >= png_ptr->offset_table_number) - { -# ifndef PNG_USER_MEM_SUPPORTED - if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out of Memory"); /* Note "O" and "M" */ - - else - png_warning(png_ptr, "Out of Memory"); -# endif - return (NULL); - } - - ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; - } - - else - { - if (g_png_default_malloc_ptr) - ret = (*g_png_default_malloc_ptr)((size_t)size); - else - ret = farmalloc(size); - } - -# ifndef PNG_USER_MEM_SUPPORTED - if (ret == NULL) - { - if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */ - - else - png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */ - } -# endif - - return (ret); -} - -/* Free a pointer allocated by png_malloc(). In the default - * configuration, png_ptr is not used, but is passed in case it - * is needed. If ptr is NULL, return without taking any action. - */ -void PNGAPI -png_free(png_structp png_ptr, png_voidp ptr) -{ - if (png_ptr == NULL || ptr == NULL) - return; - -# ifdef PNG_USER_MEM_SUPPORTED - if (png_ptr->free_fn != NULL) - { - (*(png_ptr->free_fn))(png_ptr, ptr); - return; - } - - else - png_free_default(png_ptr, ptr); -} - -void PNGAPI -png_free_default(png_structp png_ptr, png_voidp ptr) -{ -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (png_ptr == NULL || ptr == NULL) - return; - - if (png_ptr->offset_table != NULL) - { - int i; - - for (i = 0; i < png_ptr->offset_table_count; i++) - { - if (ptr == png_ptr->offset_table_ptr[i]) - { - ptr = NULL; - png_ptr->offset_table_count_free++; - break; - } - } - if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) - { - farfree(png_ptr->offset_table); - farfree(png_ptr->offset_table_ptr); - png_ptr->offset_table = NULL; - png_ptr->offset_table_ptr = NULL; - } - } - - if (ptr != NULL) - { - if (g_png_default_free_ptr) - (*g_png_default_free_ptr)(ptr); - else - farfree(ptr); - } -} - -#else /* Not the Borland DOS special memory handler */ - -/* Allocate memory for a png_struct or a png_info. The malloc and - memset can be replaced by a single call to calloc() if this is thought - to improve performance noticably. */ -PNG_FUNCTION(png_voidp /* PRIVATE */, -png_create_struct,(int type),PNG_ALLOCATED) -{ -# ifdef PNG_USER_MEM_SUPPORTED - return (png_create_struct_2(type, NULL, NULL)); -} - -/* Allocate memory for a png_struct or a png_info. The malloc and - memset can be replaced by a single call to calloc() if this is thought - to improve performance noticably. */ -PNG_FUNCTION(png_voidp /* PRIVATE */, -png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr), - PNG_ALLOCATED) -{ -# endif /* PNG_USER_MEM_SUPPORTED */ - png_size_t size; - png_voidp struct_ptr; - - if (type == PNG_STRUCT_INFO) - size = png_sizeof(png_info); - - else if (type == PNG_STRUCT_PNG) - size = png_sizeof(png_struct); - - else - return (NULL); - -# ifdef PNG_USER_MEM_SUPPORTED - if (malloc_fn != NULL) - { - png_struct dummy_struct; - png_structp png_ptr = &dummy_struct; - png_ptr->mem_ptr=mem_ptr; - struct_ptr = (*(malloc_fn))(png_ptr, size); - - if (struct_ptr != NULL) - png_memset(struct_ptr, 0, size); - - return (struct_ptr); - } -# endif /* PNG_USER_MEM_SUPPORTED */ - if (g_png_default_malloc_ptr) - struct_ptr = (png_voidp)(*g_png_default_malloc_ptr)(size); - else - { -# if defined(__TURBOC__) && !defined(__FLAT__) - struct_ptr = (png_voidp)farmalloc(size); -# else -# if defined(_MSC_VER) && defined(MAXSEG_64K) - struct_ptr = (png_voidp)halloc(size, 1); -# else - struct_ptr = (png_voidp)malloc(size); -# endif -# endif - } - if (struct_ptr != NULL) - png_memset(struct_ptr, 0, size); - - return (struct_ptr); -} - - -/* Free memory allocated by a png_create_struct() call */ -void /* PRIVATE */ -png_destroy_struct(png_voidp struct_ptr) -{ -# ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2(struct_ptr, NULL, NULL); -} - -/* Free memory allocated by a png_create_struct() call */ -void /* PRIVATE */ -png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, - png_voidp mem_ptr) -{ -# endif /* PNG_USER_MEM_SUPPORTED */ - if (struct_ptr != NULL) - { -# ifdef PNG_USER_MEM_SUPPORTED - if (free_fn != NULL) - { - png_struct dummy_struct; - png_structp png_ptr = &dummy_struct; - png_ptr->mem_ptr=mem_ptr; - (*(free_fn))(png_ptr, struct_ptr); - return; - } -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (g_png_default_free_ptr) - (*g_png_default_free_ptr)(struct_ptr); - else - { -# if defined(__TURBOC__) && !defined(__FLAT__) - farfree(struct_ptr); -# else -# if defined(_MSC_VER) && defined(MAXSEG_64K) - hfree(struct_ptr); - -# else - free(struct_ptr); - -# endif -# endif - } - - } -} - -/* Allocate memory. For reasonable files, size should never exceed - * 64K. However, zlib may allocate more then 64K if you don't tell - * it not to. See zconf.h and png.h for more information. zlib does - * need to allocate exactly 64K, so whatever you call here must - * have the ability to do that. - */ - -PNG_FUNCTION(png_voidp,PNGAPI -png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ret; - - ret = (png_malloc(png_ptr, size)); - - if (ret != NULL) - png_memset(ret,0,(png_size_t)size); - - return (ret); -} - -PNG_FUNCTION(png_voidp,PNGAPI -png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ret; - -# ifdef PNG_USER_MEM_SUPPORTED - if (png_ptr == NULL || size == 0) - return (NULL); - - if (png_ptr->malloc_fn != NULL) - ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); - - else - ret = (png_malloc_default(png_ptr, size)); - - if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out of Memory"); - - return (ret); -} - -PNG_FUNCTION(png_voidp,PNGAPI -png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ret; -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (png_ptr == NULL || size == 0) - return (NULL); - -# ifdef PNG_MAX_MALLOC_64K - if (size > (png_uint_32)65536L) - { -# ifndef PNG_USER_MEM_SUPPORTED - if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Cannot Allocate > 64K"); - - else -# endif - return NULL; - } -# endif - - /* Check for overflow */ - if (g_png_default_malloc_ptr) - ret = (*g_png_default_malloc_ptr)((size_t)size); - else - { -# if defined(__TURBOC__) && !defined(__FLAT__) - - if (size != (unsigned long)size) - ret = NULL; - - else - ret = farmalloc(size); - -# else -# if defined(_MSC_VER) && defined(MAXSEG_64K) - if (size != (unsigned long)size) - ret = NULL; - - else - ret = halloc(size, 1); - -# else - if (size != (size_t)size) - ret = NULL; - - else - ret = malloc((size_t)size); -# endif -# endif - } -# ifndef PNG_USER_MEM_SUPPORTED - if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) - png_error(png_ptr, "Out of Memory"); -# endif - - return (ret); -} - -/* Free a pointer allocated by png_malloc(). If ptr is NULL, return - * without taking any action. - */ -void PNGAPI -png_free(png_structp png_ptr, png_voidp ptr) -{ - if (png_ptr == NULL || ptr == NULL) - return; - -# ifdef PNG_USER_MEM_SUPPORTED - if (png_ptr->free_fn != NULL) - { - (*(png_ptr->free_fn))(png_ptr, ptr); - return; - } - - else - png_free_default(png_ptr, ptr); -} - -void PNGAPI -png_free_default(png_structp png_ptr, png_voidp ptr) -{ - if (png_ptr == NULL || ptr == NULL) - return; - -# endif /* PNG_USER_MEM_SUPPORTED */ - - if (g_png_default_free_ptr) - (*g_png_default_free_ptr)(ptr); - else - { -# if defined(__TURBOC__) && !defined(__FLAT__) - farfree(ptr); - -# else -# if defined(_MSC_VER) && defined(MAXSEG_64K) - hfree(ptr); - -# else - free(ptr); - -# endif -# endif - } -} -#endif /* Not Borland DOS special memory handler */ - -/* This function was added at libpng version 1.2.3. The png_malloc_warn() - * function will set up png_malloc() to issue a png_warning and return NULL - * instead of issuing a png_error, if it fails to allocate the requested - * memory. - */ -PNG_FUNCTION(png_voidp,PNGAPI -png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) -{ - png_voidp ptr; - png_uint_32 save_flags; - if (png_ptr == NULL) - return (NULL); - - save_flags = png_ptr->flags; - png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; - ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); - png_ptr->flags=save_flags; - return(ptr); -} - - -#ifdef PNG_USER_MEM_SUPPORTED -/* This function is called when the application wants to use another method - * of allocating and freeing memory. - */ -void PNGAPI -png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr - malloc_fn, png_free_ptr free_fn) -{ - if (png_ptr != NULL) - { - png_ptr->mem_ptr = mem_ptr; - png_ptr->malloc_fn = malloc_fn; - png_ptr->free_fn = free_fn; - } -} - -/* This function returns a pointer to the mem_ptr associated with the user - * functions. The application should free any memory associated with this - * pointer before png_write_destroy and png_read_destroy are called. - */ -png_voidp PNGAPI -png_get_mem_ptr(png_const_structp png_ptr) -{ - if (png_ptr == NULL) - return (NULL); - - return ((png_voidp)png_ptr->mem_ptr); -} -#endif /* PNG_USER_MEM_SUPPORTED */ -#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngpread.c b/source/libpng/pngpread.c deleted file mode 100644 index c5fe0a2..0000000 --- a/source/libpng/pngpread.c +++ /dev/null @@ -1,1314 +0,0 @@ - -/* pngpread.c - read a png file in push mode - * - * Last changed in libpng 1.5.9 [February 18, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -#include "pngpriv.h" - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED - -/* Push model modes */ -#define PNG_READ_SIG_MODE 0 -#define PNG_READ_CHUNK_MODE 1 -#define PNG_READ_IDAT_MODE 2 -#define PNG_SKIP_MODE 3 -#define PNG_READ_tEXt_MODE 4 -#define PNG_READ_zTXt_MODE 5 -#define PNG_READ_DONE_MODE 6 -#define PNG_READ_iTXt_MODE 7 -#define PNG_ERROR_MODE 8 - -void PNGAPI -png_process_data(png_structp png_ptr, png_infop info_ptr, - png_bytep buffer, png_size_t buffer_size) -{ - if (png_ptr == NULL || info_ptr == NULL) - return; - - png_push_restore_buffer(png_ptr, buffer, buffer_size); - - while (png_ptr->buffer_size) - { - png_process_some_data(png_ptr, info_ptr); - } -} - -png_size_t PNGAPI -png_process_data_pause(png_structp png_ptr, int save) -{ - if (png_ptr != NULL) - { - /* It's easiest for the caller if we do the save, then the caller doesn't - * have to supply the same data again: - */ - if (save) - png_push_save_buffer(png_ptr); - else - { - /* This includes any pending saved bytes: */ - png_size_t remaining = png_ptr->buffer_size; - png_ptr->buffer_size = 0; - - /* So subtract the saved buffer size, unless all the data - * is actually 'saved', in which case we just return 0 - */ - if (png_ptr->save_buffer_size < remaining) - return remaining - png_ptr->save_buffer_size; - } - } - - return 0; -} - -png_uint_32 PNGAPI -png_process_data_skip(png_structp png_ptr) -{ - png_uint_32 remaining = 0; - - if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE && - png_ptr->skip_length > 0) - { - /* At the end of png_process_data the buffer size must be 0 (see the loop - * above) so we can detect a broken call here: - */ - if (png_ptr->buffer_size != 0) - png_error(png_ptr, - "png_process_data_skip called inside png_process_data"); - - /* If is impossible for there to be a saved buffer at this point - - * otherwise we could not be in SKIP mode. This will also happen if - * png_process_skip is called inside png_process_data (but only very - * rarely.) - */ - if (png_ptr->save_buffer_size != 0) - png_error(png_ptr, "png_process_data_skip called with saved data"); - - remaining = png_ptr->skip_length; - png_ptr->skip_length = 0; - png_ptr->process_mode = PNG_READ_CHUNK_MODE; - } - - return remaining; -} - -/* What we do with the incoming data depends on what we were previously - * doing before we ran out of data... - */ -void /* PRIVATE */ -png_process_some_data(png_structp png_ptr, png_infop info_ptr) -{ - if (png_ptr == NULL) - return; - - switch (png_ptr->process_mode) - { - case PNG_READ_SIG_MODE: - { - png_push_read_sig(png_ptr, info_ptr); - break; - } - - case PNG_READ_CHUNK_MODE: - { - png_push_read_chunk(png_ptr, info_ptr); - break; - } - - case PNG_READ_IDAT_MODE: - { - png_push_read_IDAT(png_ptr); - break; - } - - case PNG_SKIP_MODE: - { - png_push_crc_finish(png_ptr); - break; - } - - default: - { - png_ptr->buffer_size = 0; - break; - } - } -} - -/* Read any remaining signature bytes from the stream and compare them with - * the correct PNG signature. It is possible that this routine is called - * with bytes already read from the signature, either because they have been - * checked by the calling application, or because of multiple calls to this - * routine. - */ -void /* PRIVATE */ -png_push_read_sig(png_structp png_ptr, png_infop info_ptr) -{ - png_size_t num_checked = png_ptr->sig_bytes, - num_to_check = 8 - num_checked; - - if (png_ptr->buffer_size < num_to_check) - { - num_to_check = png_ptr->buffer_size; - } - - png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), - num_to_check); - png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check); - - if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) - { - if (num_checked < 4 && - png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) - png_error(png_ptr, "Not a PNG file"); - - else - png_error(png_ptr, "PNG file corrupted by ASCII conversion"); - } - - else - { - if (png_ptr->sig_bytes >= 8) - { - png_ptr->process_mode = PNG_READ_CHUNK_MODE; - } - } -} - -void /* PRIVATE */ -png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) -{ - png_uint_32 chunk_name; - - /* First we make sure we have enough data for the 4 byte chunk name - * and the 4 byte chunk length before proceeding with decoding the - * chunk data. To fully decode each of these chunks, we also make - * sure we have enough data in the buffer for the 4 byte CRC at the - * end of every chunk (except IDAT, which is handled separately). - */ - if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) - { - png_byte chunk_length[4]; - png_byte chunk_tag[4]; - - if (png_ptr->buffer_size < 8) - { - png_push_save_buffer(png_ptr); - return; - } - - png_push_fill_buffer(png_ptr, chunk_length, 4); - png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length); - png_reset_crc(png_ptr); - png_crc_read(png_ptr, chunk_tag, 4); - png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag); - png_check_chunk_name(png_ptr, png_ptr->chunk_name); - png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; - } - - chunk_name = png_ptr->chunk_name; - - if (chunk_name == png_IDAT) - { - /* This is here above the if/else case statement below because if the - * unknown handling marks 'IDAT' as unknown then the IDAT handling case is - * completely skipped. - * - * TODO: there must be a better way of doing this. - */ - if (png_ptr->mode & PNG_AFTER_IDAT) - png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; - } - - if (chunk_name == png_IHDR) - { - if (png_ptr->push_length != 13) - png_error(png_ptr, "Invalid IHDR length"); - - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); - } - - else if (chunk_name == png_IEND) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); - - png_ptr->process_mode = PNG_READ_DONE_MODE; - png_push_have_end(png_ptr, info_ptr); - } - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - else if (png_chunk_unknown_handling(png_ptr, chunk_name)) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - if (chunk_name == png_IDAT) - png_ptr->mode |= PNG_HAVE_IDAT; - - png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); - - if (chunk_name == png_PLTE) - png_ptr->mode |= PNG_HAVE_PLTE; - - else if (chunk_name == png_IDAT) - { - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before IDAT"); - - else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && - !(png_ptr->mode & PNG_HAVE_PLTE)) - png_error(png_ptr, "Missing PLTE before IDAT"); - } - } - -#endif - else if (chunk_name == png_PLTE) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); - } - - else if (chunk_name == png_IDAT) - { - /* If we reach an IDAT chunk, this means we have read all of the - * header chunks, and we can start reading the image (or if this - * is called after the image has been read - we have an error). - */ - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before IDAT"); - - else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && - !(png_ptr->mode & PNG_HAVE_PLTE)) - png_error(png_ptr, "Missing PLTE before IDAT"); - - if (png_ptr->mode & PNG_HAVE_IDAT) - { - if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) - if (png_ptr->push_length == 0) - return; - - if (png_ptr->mode & PNG_AFTER_IDAT) - png_benign_error(png_ptr, "Too many IDATs found"); - } - - png_ptr->idat_size = png_ptr->push_length; - png_ptr->mode |= PNG_HAVE_IDAT; - png_ptr->process_mode = PNG_READ_IDAT_MODE; - png_push_have_info(png_ptr, info_ptr); - png_ptr->zstream.avail_out = - (uInt) PNG_ROWBYTES(png_ptr->pixel_depth, - png_ptr->iwidth) + 1; - png_ptr->zstream.next_out = png_ptr->row_buf; - return; - } - -#ifdef PNG_READ_gAMA_SUPPORTED - else if (png_ptr->chunk_name == png_gAMA) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_sBIT_SUPPORTED - else if (png_ptr->chunk_name == png_sBIT) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_cHRM_SUPPORTED - else if (png_ptr->chunk_name == png_cHRM) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_sRGB_SUPPORTED - else if (chunk_name == png_sRGB) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_iCCP_SUPPORTED - else if (png_ptr->chunk_name == png_iCCP) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_sPLT_SUPPORTED - else if (chunk_name == png_sPLT) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_tRNS_SUPPORTED - else if (chunk_name == png_tRNS) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_bKGD_SUPPORTED - else if (chunk_name == png_bKGD) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_hIST_SUPPORTED - else if (chunk_name == png_hIST) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_pHYs_SUPPORTED - else if (chunk_name == png_pHYs) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_oFFs_SUPPORTED - else if (chunk_name == png_oFFs) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); - } -#endif - -#ifdef PNG_READ_pCAL_SUPPORTED - else if (chunk_name == png_pCAL) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_sCAL_SUPPORTED - else if (chunk_name == png_sCAL) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_tIME_SUPPORTED - else if (chunk_name == png_tIME) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_tEXt_SUPPORTED - else if (chunk_name == png_tEXt) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_zTXt_SUPPORTED - else if (chunk_name == png_zTXt) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif -#ifdef PNG_READ_iTXt_SUPPORTED - else if (chunk_name == png_iTXt) - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - - png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); - } - -#endif - else - { - if (png_ptr->push_length + 4 > png_ptr->buffer_size) - { - png_push_save_buffer(png_ptr); - return; - } - png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); - } - - png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; -} - -void /* PRIVATE */ -png_push_crc_skip(png_structp png_ptr, png_uint_32 skip) -{ - png_ptr->process_mode = PNG_SKIP_MODE; - png_ptr->skip_length = skip; -} - -void /* PRIVATE */ -png_push_crc_finish(png_structp png_ptr) -{ - if (png_ptr->skip_length && png_ptr->save_buffer_size) - { - png_size_t save_size = png_ptr->save_buffer_size; - png_uint_32 skip_length = png_ptr->skip_length; - - /* We want the smaller of 'skip_length' and 'save_buffer_size', but - * they are of different types and we don't know which variable has the - * fewest bits. Carefully select the smaller and cast it to the type of - * the larger - this cannot overflow. Do not cast in the following test - * - it will break on either 16 or 64 bit platforms. - */ - if (skip_length < save_size) - save_size = (png_size_t)skip_length; - - else - skip_length = (png_uint_32)save_size; - - png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); - - png_ptr->skip_length -= skip_length; - png_ptr->buffer_size -= save_size; - png_ptr->save_buffer_size -= save_size; - png_ptr->save_buffer_ptr += save_size; - } - - if (png_ptr->skip_length && png_ptr->current_buffer_size) - { - png_size_t save_size = png_ptr->current_buffer_size; - png_uint_32 skip_length = png_ptr->skip_length; - - /* We want the smaller of 'skip_length' and 'current_buffer_size', here, - * the same problem exists as above and the same solution. - */ - if (skip_length < save_size) - save_size = (png_size_t)skip_length; - - else - skip_length = (png_uint_32)save_size; - - png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); - - png_ptr->skip_length -= skip_length; - png_ptr->buffer_size -= save_size; - png_ptr->current_buffer_size -= save_size; - png_ptr->current_buffer_ptr += save_size; - } - - if (!png_ptr->skip_length) - { - if (png_ptr->buffer_size < 4) - { - png_push_save_buffer(png_ptr); - return; - } - - png_crc_finish(png_ptr, 0); - png_ptr->process_mode = PNG_READ_CHUNK_MODE; - } -} - -void PNGCBAPI -png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) -{ - png_bytep ptr; - - if (png_ptr == NULL) - return; - - ptr = buffer; - - if (png_ptr->save_buffer_size) - { - png_size_t save_size; - - if (length < png_ptr->save_buffer_size) - save_size = length; - - else - save_size = png_ptr->save_buffer_size; - - png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); - length -= save_size; - ptr += save_size; - png_ptr->buffer_size -= save_size; - png_ptr->save_buffer_size -= save_size; - png_ptr->save_buffer_ptr += save_size; - } - - if (length && png_ptr->current_buffer_size) - { - png_size_t save_size; - - if (length < png_ptr->current_buffer_size) - save_size = length; - - else - save_size = png_ptr->current_buffer_size; - - png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size); - png_ptr->buffer_size -= save_size; - png_ptr->current_buffer_size -= save_size; - png_ptr->current_buffer_ptr += save_size; - } -} - -void /* PRIVATE */ -png_push_save_buffer(png_structp png_ptr) -{ - if (png_ptr->save_buffer_size) - { - if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) - { - png_size_t i, istop; - png_bytep sp; - png_bytep dp; - - istop = png_ptr->save_buffer_size; - - for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; - i < istop; i++, sp++, dp++) - { - *dp = *sp; - } - } - } - - if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > - png_ptr->save_buffer_max) - { - png_size_t new_max; - png_bytep old_buffer; - - if (png_ptr->save_buffer_size > PNG_SIZE_MAX - - (png_ptr->current_buffer_size + 256)) - { - png_error(png_ptr, "Potential overflow of save_buffer"); - } - - new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; - old_buffer = png_ptr->save_buffer; - png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr, new_max); - - if (png_ptr->save_buffer == NULL) - { - png_free(png_ptr, old_buffer); - png_error(png_ptr, "Insufficient memory for save_buffer"); - } - - png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); - png_free(png_ptr, old_buffer); - png_ptr->save_buffer_max = new_max; - } - - if (png_ptr->current_buffer_size) - { - png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, - png_ptr->current_buffer_ptr, png_ptr->current_buffer_size); - png_ptr->save_buffer_size += png_ptr->current_buffer_size; - png_ptr->current_buffer_size = 0; - } - - png_ptr->save_buffer_ptr = png_ptr->save_buffer; - png_ptr->buffer_size = 0; -} - -void /* PRIVATE */ -png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, - png_size_t buffer_length) -{ - png_ptr->current_buffer = buffer; - png_ptr->current_buffer_size = buffer_length; - png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size; - png_ptr->current_buffer_ptr = png_ptr->current_buffer; -} - -void /* PRIVATE */ -png_push_read_IDAT(png_structp png_ptr) -{ - if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) - { - png_byte chunk_length[4]; - png_byte chunk_tag[4]; - - /* TODO: this code can be commoned up with the same code in push_read */ - if (png_ptr->buffer_size < 8) - { - png_push_save_buffer(png_ptr); - return; - } - - png_push_fill_buffer(png_ptr, chunk_length, 4); - png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length); - png_reset_crc(png_ptr); - png_crc_read(png_ptr, chunk_tag, 4); - png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag); - png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; - - if (png_ptr->chunk_name != png_IDAT) - { - png_ptr->process_mode = PNG_READ_CHUNK_MODE; - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) - png_error(png_ptr, "Not enough compressed data"); - - return; - } - - png_ptr->idat_size = png_ptr->push_length; - } - - if (png_ptr->idat_size && png_ptr->save_buffer_size) - { - png_size_t save_size = png_ptr->save_buffer_size; - png_uint_32 idat_size = png_ptr->idat_size; - - /* We want the smaller of 'idat_size' and 'current_buffer_size', but they - * are of different types and we don't know which variable has the fewest - * bits. Carefully select the smaller and cast it to the type of the - * larger - this cannot overflow. Do not cast in the following test - it - * will break on either 16 or 64 bit platforms. - */ - if (idat_size < save_size) - save_size = (png_size_t)idat_size; - - else - idat_size = (png_uint_32)save_size; - - png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); - - png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); - - png_ptr->idat_size -= idat_size; - png_ptr->buffer_size -= save_size; - png_ptr->save_buffer_size -= save_size; - png_ptr->save_buffer_ptr += save_size; - } - - if (png_ptr->idat_size && png_ptr->current_buffer_size) - { - png_size_t save_size = png_ptr->current_buffer_size; - png_uint_32 idat_size = png_ptr->idat_size; - - /* We want the smaller of 'idat_size' and 'current_buffer_size', but they - * are of different types and we don't know which variable has the fewest - * bits. Carefully select the smaller and cast it to the type of the - * larger - this cannot overflow. - */ - if (idat_size < save_size) - save_size = (png_size_t)idat_size; - - else - idat_size = (png_uint_32)save_size; - - png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); - - png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); - - png_ptr->idat_size -= idat_size; - png_ptr->buffer_size -= save_size; - png_ptr->current_buffer_size -= save_size; - png_ptr->current_buffer_ptr += save_size; - } - - if (!png_ptr->idat_size) - { - if (png_ptr->buffer_size < 4) - { - png_push_save_buffer(png_ptr); - return; - } - - png_crc_finish(png_ptr, 0); - png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; - png_ptr->mode |= PNG_AFTER_IDAT; - } -} - -void /* PRIVATE */ -png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, - png_size_t buffer_length) -{ - /* The caller checks for a non-zero buffer length. */ - if (!(buffer_length > 0) || buffer == NULL) - png_error(png_ptr, "No IDAT data (internal error)"); - - /* This routine must process all the data it has been given - * before returning, calling the row callback as required to - * handle the uncompressed results. - */ - png_ptr->zstream.next_in = buffer; - png_ptr->zstream.avail_in = (uInt)buffer_length; - - /* Keep going until the decompressed data is all processed - * or the stream marked as finished. - */ - while (png_ptr->zstream.avail_in > 0 && - !(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) - { - int ret; - - /* We have data for zlib, but we must check that zlib - * has someplace to put the results. It doesn't matter - * if we don't expect any results -- it may be the input - * data is just the LZ end code. - */ - if (!(png_ptr->zstream.avail_out > 0)) - { - png_ptr->zstream.avail_out = - (uInt) PNG_ROWBYTES(png_ptr->pixel_depth, - png_ptr->iwidth) + 1; - - png_ptr->zstream.next_out = png_ptr->row_buf; - } - - /* Using Z_SYNC_FLUSH here means that an unterminated - * LZ stream (a stream with a missing end code) can still - * be handled, otherwise (Z_NO_FLUSH) a future zlib - * implementation might defer output and therefore - * change the current behavior (see comments in inflate.c - * for why this doesn't happen at present with zlib 1.2.5). - */ - ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH); - - /* Check for any failure before proceeding. */ - if (ret != Z_OK && ret != Z_STREAM_END) - { - /* Terminate the decompression. */ - png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; - - /* This may be a truncated stream (missing or - * damaged end code). Treat that as a warning. - */ - if (png_ptr->row_number >= png_ptr->num_rows || - png_ptr->pass > 6) - png_warning(png_ptr, "Truncated compressed data in IDAT"); - - else - png_error(png_ptr, "Decompression error in IDAT"); - - /* Skip the check on unprocessed input */ - return; - } - - /* Did inflate output any data? */ - if (png_ptr->zstream.next_out != png_ptr->row_buf) - { - /* Is this unexpected data after the last row? - * If it is, artificially terminate the LZ output - * here. - */ - if (png_ptr->row_number >= png_ptr->num_rows || - png_ptr->pass > 6) - { - /* Extra data. */ - png_warning(png_ptr, "Extra compressed data in IDAT"); - png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; - - /* Do no more processing; skip the unprocessed - * input check below. - */ - return; - } - - /* Do we have a complete row? */ - if (png_ptr->zstream.avail_out == 0) - png_push_process_row(png_ptr); - } - - /* And check for the end of the stream. */ - if (ret == Z_STREAM_END) - png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; - } - - /* All the data should have been processed, if anything - * is left at this point we have bytes of IDAT data - * after the zlib end code. - */ - if (png_ptr->zstream.avail_in > 0) - png_warning(png_ptr, "Extra compression data in IDAT"); -} - -void /* PRIVATE */ -png_push_process_row(png_structp png_ptr) -{ - /* 1.5.6: row_info moved out of png_struct to a local here. */ - png_row_info row_info; - - row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */ - row_info.color_type = png_ptr->color_type; - row_info.bit_depth = png_ptr->bit_depth; - row_info.channels = png_ptr->channels; - row_info.pixel_depth = png_ptr->pixel_depth; - row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); - - if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE) - { - if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST) - png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1, - png_ptr->prev_row + 1, png_ptr->row_buf[0]); - else - png_error(png_ptr, "bad adaptive filter value"); - } - - /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before - * 1.5.6, while the buffer really is this big in current versions of libpng - * it may not be in the future, so this was changed just to copy the - * interlaced row count: - */ - png_memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED - if (png_ptr->transformations) - png_do_read_transformations(png_ptr, &row_info); -#endif - - /* The transformed pixel depth should match the depth now in row_info. */ - if (png_ptr->transformed_pixel_depth == 0) - { - png_ptr->transformed_pixel_depth = row_info.pixel_depth; - if (row_info.pixel_depth > png_ptr->maximum_pixel_depth) - png_error(png_ptr, "progressive row overflow"); - } - - else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth) - png_error(png_ptr, "internal progressive row size calculation error"); - - -#ifdef PNG_READ_INTERLACING_SUPPORTED - /* Blow up interlaced rows to full size */ - if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) - { - if (png_ptr->pass < 6) - png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, - png_ptr->transformations); - - switch (png_ptr->pass) - { - case 0: - { - int i; - for (i = 0; i < 8 && png_ptr->pass == 0; i++) - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */ - } - - if (png_ptr->pass == 2) /* Pass 1 might be empty */ - { - for (i = 0; i < 4 && png_ptr->pass == 2; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - } - - if (png_ptr->pass == 4 && png_ptr->height <= 4) - { - for (i = 0; i < 2 && png_ptr->pass == 4; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - } - - if (png_ptr->pass == 6 && png_ptr->height <= 4) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - - break; - } - - case 1: - { - int i; - for (i = 0; i < 8 && png_ptr->pass == 1; i++) - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - } - - if (png_ptr->pass == 2) /* Skip top 4 generated rows */ - { - for (i = 0; i < 4 && png_ptr->pass == 2; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - } - - break; - } - - case 2: - { - int i; - - for (i = 0; i < 4 && png_ptr->pass == 2; i++) - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - } - - for (i = 0; i < 4 && png_ptr->pass == 2; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - - if (png_ptr->pass == 4) /* Pass 3 might be empty */ - { - for (i = 0; i < 2 && png_ptr->pass == 4; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - } - - break; - } - - case 3: - { - int i; - - for (i = 0; i < 4 && png_ptr->pass == 3; i++) - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - } - - if (png_ptr->pass == 4) /* Skip top two generated rows */ - { - for (i = 0; i < 2 && png_ptr->pass == 4; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - } - - break; - } - - case 4: - { - int i; - - for (i = 0; i < 2 && png_ptr->pass == 4; i++) - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - } - - for (i = 0; i < 2 && png_ptr->pass == 4; i++) - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - - if (png_ptr->pass == 6) /* Pass 5 might be empty */ - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - - break; - } - - case 5: - { - int i; - - for (i = 0; i < 2 && png_ptr->pass == 5; i++) - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - } - - if (png_ptr->pass == 6) /* Skip top generated row */ - { - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - - break; - } - - default: - case 6: - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - - if (png_ptr->pass != 6) - break; - - png_push_have_row(png_ptr, NULL); - png_read_push_finish_row(png_ptr); - } - } - } - else -#endif - { - png_push_have_row(png_ptr, png_ptr->row_buf + 1); - png_read_push_finish_row(png_ptr); - } -} - -void /* PRIVATE */ -png_read_push_finish_row(png_structp png_ptr) -{ -#ifdef PNG_READ_INTERLACING_SUPPORTED - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - - /* Start of interlace block */ - static PNG_CONST png_byte FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; - - /* Offset to next interlace block */ - static PNG_CONST png_byte FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; - - /* Start of interlace block in the y direction */ - static PNG_CONST png_byte FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; - - /* Offset to next interlace block in the y direction */ - static PNG_CONST png_byte FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; - - /* Height of interlace block. This is not currently used - if you need - * it, uncomment it here and in png.h - static PNG_CONST png_byte FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; - */ -#endif - - png_ptr->row_number++; - if (png_ptr->row_number < png_ptr->num_rows) - return; - -#ifdef PNG_READ_INTERLACING_SUPPORTED - if (png_ptr->interlaced) - { - png_ptr->row_number = 0; - png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); - - do - { - png_ptr->pass++; - if ((png_ptr->pass == 1 && png_ptr->width < 5) || - (png_ptr->pass == 3 && png_ptr->width < 3) || - (png_ptr->pass == 5 && png_ptr->width < 2)) - png_ptr->pass++; - - if (png_ptr->pass > 7) - png_ptr->pass--; - - if (png_ptr->pass >= 7) - break; - - png_ptr->iwidth = (png_ptr->width + - png_pass_inc[png_ptr->pass] - 1 - - png_pass_start[png_ptr->pass]) / - png_pass_inc[png_ptr->pass]; - - if (png_ptr->transformations & PNG_INTERLACE) - break; - - png_ptr->num_rows = (png_ptr->height + - png_pass_yinc[png_ptr->pass] - 1 - - png_pass_ystart[png_ptr->pass]) / - png_pass_yinc[png_ptr->pass]; - - } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); - } -#endif /* PNG_READ_INTERLACING_SUPPORTED */ -} - -void /* PRIVATE */ -png_push_have_info(png_structp png_ptr, png_infop info_ptr) -{ - if (png_ptr->info_fn != NULL) - (*(png_ptr->info_fn))(png_ptr, info_ptr); -} - -void /* PRIVATE */ -png_push_have_end(png_structp png_ptr, png_infop info_ptr) -{ - if (png_ptr->end_fn != NULL) - (*(png_ptr->end_fn))(png_ptr, info_ptr); -} - -void /* PRIVATE */ -png_push_have_row(png_structp png_ptr, png_bytep row) -{ - if (png_ptr->row_fn != NULL) - (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, - (int)png_ptr->pass); -} - -#ifdef PNG_READ_INTERLACING_SUPPORTED -void PNGAPI -png_progressive_combine_row (png_structp png_ptr, png_bytep old_row, - png_const_bytep new_row) -{ - if (png_ptr == NULL) - return; - - /* new_row is a flag here - if it is NULL then the app callback was called - * from an empty row (see the calls to png_struct::row_fn below), otherwise - * it must be png_ptr->row_buf+1 - */ - if (new_row != NULL) - png_combine_row(png_ptr, old_row, 1/*display*/); -} -#endif /* PNG_READ_INTERLACING_SUPPORTED */ - -void PNGAPI -png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, - png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, - png_progressive_end_ptr end_fn) -{ - if (png_ptr == NULL) - return; - - png_ptr->info_fn = info_fn; - png_ptr->row_fn = row_fn; - png_ptr->end_fn = end_fn; - - png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer); -} - -png_voidp PNGAPI -png_get_progressive_ptr(png_const_structp png_ptr) -{ - if (png_ptr == NULL) - return (NULL); - - return png_ptr->io_ptr; -} -#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ diff --git a/source/libpng/pngread.c b/source/libpng/pngread.c deleted file mode 100644 index ae1678b..0000000 --- a/source/libpng/pngread.c +++ /dev/null @@ -1,1305 +0,0 @@ - -/* pngread.c - read a PNG file - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file contains routines that an application calls directly to - * read a PNG file or stream. - */ - -#include "pngpriv.h" - -#ifdef PNG_READ_SUPPORTED - -/* Create a PNG structure for reading, and allocate any memory needed. */ -PNG_FUNCTION(png_structp,PNGAPI -png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) -{ - -#ifdef PNG_USER_MEM_SUPPORTED - return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, - warn_fn, NULL, NULL, NULL)); -} - -/* Alternate create PNG structure for reading, and allocate any memory - * needed. - */ -PNG_FUNCTION(png_structp,PNGAPI -png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, - png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) -{ -#endif /* PNG_USER_MEM_SUPPORTED */ - -#ifdef PNG_SETJMP_SUPPORTED - volatile -#endif - png_structp png_ptr; - volatile int png_cleanup_needed = 0; - -#ifdef PNG_SETJMP_SUPPORTED -#ifdef USE_FAR_KEYWORD - jmp_buf tmp_jmpbuf; -#endif -#endif - - png_debug(1, "in png_create_read_struct"); - -#ifdef PNG_USER_MEM_SUPPORTED - png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, - malloc_fn, mem_ptr); -#else - png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); -#endif - if (png_ptr == NULL) - return (NULL); - - /* Added at libpng-1.2.6 */ -#ifdef PNG_USER_LIMITS_SUPPORTED - png_ptr->user_width_max = PNG_USER_WIDTH_MAX; - png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; - - /* Added at libpng-1.2.43 and 1.4.0 */ - png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; - - /* Added at libpng-1.2.43 and 1.4.1 */ - png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; -#endif - -#ifdef PNG_SETJMP_SUPPORTED -/* Applications that neglect to set up their own setjmp() and then - * encounter a png_error() will longjmp here. Since the jmpbuf is - * then meaningless we abort instead of returning. - */ -#ifdef USE_FAR_KEYWORD - if (setjmp(tmp_jmpbuf)) -#else - if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */ -#endif - PNG_ABORT(); -#ifdef USE_FAR_KEYWORD - png_memcpy(png_jmpbuf(png_ptr), tmp_jmpbuf, png_sizeof(jmp_buf)); -#endif -#endif /* PNG_SETJMP_SUPPORTED */ - -#ifdef PNG_USER_MEM_SUPPORTED - png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); -#endif - - png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); - - /* Call the general version checker (shared with read and write code): */ - if (!png_user_version_check(png_ptr, user_png_ver)) - png_cleanup_needed = 1; - - if (!png_cleanup_needed) - { - /* Initialize zbuf - compression buffer */ - png_ptr->zbuf_size = PNG_ZBUF_SIZE; - png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, png_ptr->zbuf_size); - - if (png_ptr->zbuf == NULL) - png_cleanup_needed = 1; - } - - png_ptr->zstream.zalloc = png_zalloc; - png_ptr->zstream.zfree = png_zfree; - png_ptr->zstream.opaque = (voidpf)png_ptr; - - if (!png_cleanup_needed) - { - switch (inflateInit(&png_ptr->zstream)) - { - case Z_OK: - break; /* Do nothing */ - - case Z_MEM_ERROR: - png_warning(png_ptr, "zlib memory error"); - png_cleanup_needed = 1; - break; - - case Z_STREAM_ERROR: - png_warning(png_ptr, "zlib stream error"); - png_cleanup_needed = 1; - break; - - case Z_VERSION_ERROR: - png_warning(png_ptr, "zlib version error"); - png_cleanup_needed = 1; - break; - - default: png_warning(png_ptr, "Unknown zlib error"); - png_cleanup_needed = 1; - } - } - - if (png_cleanup_needed) - { - /* Clean up PNG structure and deallocate any memory. */ - png_free(png_ptr, png_ptr->zbuf); - png_ptr->zbuf = NULL; -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)png_ptr, - (png_free_ptr)free_fn, (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)png_ptr); -#endif - return (NULL); - } - - png_ptr->zstream.next_out = png_ptr->zbuf; - png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; - - png_set_read_fn(png_ptr, NULL, NULL); - - - return (png_ptr); -} - - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read the information before the actual image data. This has been - * changed in v0.90 to allow reading a file that already has the magic - * bytes read from the stream. You can tell libpng how many bytes have - * been read from the beginning of the stream (up to the maximum of 8) - * via png_set_sig_bytes(), and we will only check the remaining bytes - * here. The application can then have access to the signature bytes we - * read if it is determined that this isn't a valid PNG file. - */ -void PNGAPI -png_read_info(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_read_info"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - /* Read and check the PNG file signature. */ - png_read_sig(png_ptr, info_ptr); - - for (;;) - { - png_uint_32 length = png_read_chunk_header(png_ptr); - png_uint_32 chunk_name = png_ptr->chunk_name; - - /* This should be a binary subdivision search or a hash for - * matching the chunk name rather than a linear search. - */ - if (chunk_name == png_IDAT) - if (png_ptr->mode & PNG_AFTER_IDAT) - png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; - - if (chunk_name == png_IHDR) - png_handle_IHDR(png_ptr, info_ptr, length); - - else if (chunk_name == png_IEND) - png_handle_IEND(png_ptr, info_ptr, length); - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - else if (png_chunk_unknown_handling(png_ptr, chunk_name) != - PNG_HANDLE_CHUNK_AS_DEFAULT) - { - if (chunk_name == png_IDAT) - png_ptr->mode |= PNG_HAVE_IDAT; - - png_handle_unknown(png_ptr, info_ptr, length); - - if (chunk_name == png_PLTE) - png_ptr->mode |= PNG_HAVE_PLTE; - - else if (chunk_name == png_IDAT) - { - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before IDAT"); - - else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && - !(png_ptr->mode & PNG_HAVE_PLTE)) - png_error(png_ptr, "Missing PLTE before IDAT"); - - break; - } - } -#endif - else if (chunk_name == png_PLTE) - png_handle_PLTE(png_ptr, info_ptr, length); - - else if (chunk_name == png_IDAT) - { - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before IDAT"); - - else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && - !(png_ptr->mode & PNG_HAVE_PLTE)) - png_error(png_ptr, "Missing PLTE before IDAT"); - - png_ptr->idat_size = length; - png_ptr->mode |= PNG_HAVE_IDAT; - break; - } - -#ifdef PNG_READ_bKGD_SUPPORTED - else if (chunk_name == png_bKGD) - png_handle_bKGD(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_cHRM_SUPPORTED - else if (chunk_name == png_cHRM) - png_handle_cHRM(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_gAMA_SUPPORTED - else if (chunk_name == png_gAMA) - png_handle_gAMA(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_hIST_SUPPORTED - else if (chunk_name == png_hIST) - png_handle_hIST(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_oFFs_SUPPORTED - else if (chunk_name == png_oFFs) - png_handle_oFFs(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_pCAL_SUPPORTED - else if (chunk_name == png_pCAL) - png_handle_pCAL(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sCAL_SUPPORTED - else if (chunk_name == png_sCAL) - png_handle_sCAL(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_pHYs_SUPPORTED - else if (chunk_name == png_pHYs) - png_handle_pHYs(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sBIT_SUPPORTED - else if (chunk_name == png_sBIT) - png_handle_sBIT(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sRGB_SUPPORTED - else if (chunk_name == png_sRGB) - png_handle_sRGB(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_iCCP_SUPPORTED - else if (chunk_name == png_iCCP) - png_handle_iCCP(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sPLT_SUPPORTED - else if (chunk_name == png_sPLT) - png_handle_sPLT(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_tEXt_SUPPORTED - else if (chunk_name == png_tEXt) - png_handle_tEXt(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_tIME_SUPPORTED - else if (chunk_name == png_tIME) - png_handle_tIME(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_tRNS_SUPPORTED - else if (chunk_name == png_tRNS) - png_handle_tRNS(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_zTXt_SUPPORTED - else if (chunk_name == png_zTXt) - png_handle_zTXt(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_iTXt_SUPPORTED - else if (chunk_name == png_iTXt) - png_handle_iTXt(png_ptr, info_ptr, length); -#endif - - else - png_handle_unknown(png_ptr, info_ptr, length); - } -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -/* Optional call to update the users info_ptr structure */ -void PNGAPI -png_read_update_info(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_read_update_info"); - - if (png_ptr == NULL) - return; - - png_read_start_row(png_ptr); - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED - png_read_transform_info(png_ptr, info_ptr); -#else - PNG_UNUSED(info_ptr) -#endif -} - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Initialize palette, background, etc, after transformations - * are set, but before any reading takes place. This allows - * the user to obtain a gamma-corrected palette, for example. - * If the user doesn't call this, we will do it ourselves. - */ -void PNGAPI -png_start_read_image(png_structp png_ptr) -{ - png_debug(1, "in png_start_read_image"); - - if (png_ptr != NULL) - png_read_start_row(png_ptr); -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -void PNGAPI -png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) -{ - int ret; - - png_row_info row_info; - - if (png_ptr == NULL) - return; - - png_debug2(1, "in png_read_row (row %lu, pass %d)", - (unsigned long)png_ptr->row_number, png_ptr->pass); - - /* png_read_start_row sets the information (in particular iwidth) for this - * interlace pass. - */ - if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) - png_read_start_row(png_ptr); - - /* 1.5.6: row_info moved out of png_struct to a local here. */ - row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */ - row_info.color_type = png_ptr->color_type; - row_info.bit_depth = png_ptr->bit_depth; - row_info.channels = png_ptr->channels; - row_info.pixel_depth = png_ptr->pixel_depth; - row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); - - if (png_ptr->row_number == 0 && png_ptr->pass == 0) - { - /* Check for transforms that have been set but were defined out */ -#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) - if (png_ptr->transformations & PNG_INVERT_MONO) - png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined"); -#endif - -#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) - if (png_ptr->transformations & PNG_FILLER) - png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined"); -#endif - -#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ - !defined(PNG_READ_PACKSWAP_SUPPORTED) - if (png_ptr->transformations & PNG_PACKSWAP) - png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined"); -#endif - -#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) - if (png_ptr->transformations & PNG_PACK) - png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined"); -#endif - -#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) - if (png_ptr->transformations & PNG_SHIFT) - png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined"); -#endif - -#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) - if (png_ptr->transformations & PNG_BGR) - png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined"); -#endif - -#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) - if (png_ptr->transformations & PNG_SWAP_BYTES) - png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined"); -#endif - } - -#ifdef PNG_READ_INTERLACING_SUPPORTED - /* If interlaced and we do not need a new row, combine row and return. - * Notice that the pixels we have from previous rows have been transformed - * already; we can only combine like with like (transformed or - * untransformed) and, because of the libpng API for interlaced images, this - * means we must transform before de-interlacing. - */ - if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) - { - switch (png_ptr->pass) - { - case 0: - if (png_ptr->row_number & 0x07) - { - if (dsp_row != NULL) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - png_read_finish_row(png_ptr); - return; - } - break; - - case 1: - if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) - { - if (dsp_row != NULL) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - - png_read_finish_row(png_ptr); - return; - } - break; - - case 2: - if ((png_ptr->row_number & 0x07) != 4) - { - if (dsp_row != NULL && (png_ptr->row_number & 4)) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - - png_read_finish_row(png_ptr); - return; - } - break; - - case 3: - if ((png_ptr->row_number & 3) || png_ptr->width < 3) - { - if (dsp_row != NULL) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - - png_read_finish_row(png_ptr); - return; - } - break; - - case 4: - if ((png_ptr->row_number & 3) != 2) - { - if (dsp_row != NULL && (png_ptr->row_number & 2)) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - - png_read_finish_row(png_ptr); - return; - } - break; - case 5: - if ((png_ptr->row_number & 1) || png_ptr->width < 2) - { - if (dsp_row != NULL) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - - png_read_finish_row(png_ptr); - return; - } - break; - - default: - case 6: - if (!(png_ptr->row_number & 1)) - { - png_read_finish_row(png_ptr); - return; - } - break; - } - } -#endif - - if (!(png_ptr->mode & PNG_HAVE_IDAT)) - png_error(png_ptr, "Invalid attempt to read row data"); - - png_ptr->zstream.next_out = png_ptr->row_buf; - png_ptr->zstream.avail_out = - (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth, - png_ptr->iwidth) + 1); - - do - { - if (!(png_ptr->zstream.avail_in)) - { - while (!png_ptr->idat_size) - { - png_crc_finish(png_ptr, 0); - - png_ptr->idat_size = png_read_chunk_header(png_ptr); - if (png_ptr->chunk_name != png_IDAT) - png_error(png_ptr, "Not enough image data"); - } - png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; - png_ptr->zstream.next_in = png_ptr->zbuf; - if (png_ptr->zbuf_size > png_ptr->idat_size) - png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; - png_crc_read(png_ptr, png_ptr->zbuf, - (png_size_t)png_ptr->zstream.avail_in); - png_ptr->idat_size -= png_ptr->zstream.avail_in; - } - - ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); - - if (ret == Z_STREAM_END) - { - if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || - png_ptr->idat_size) - png_benign_error(png_ptr, "Extra compressed data"); - png_ptr->mode |= PNG_AFTER_IDAT; - png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; - break; - } - - if (ret != Z_OK) - png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : - "Decompression error"); - - } while (png_ptr->zstream.avail_out); - - if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE) - { - if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST) - png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1, - png_ptr->prev_row + 1, png_ptr->row_buf[0]); - else - png_error(png_ptr, "bad adaptive filter value"); - } - - /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before - * 1.5.6, while the buffer really is this big in current versions of libpng - * it may not be in the future, so this was changed just to copy the - * interlaced count: - */ - png_memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1); - -#ifdef PNG_MNG_FEATURES_SUPPORTED - if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && - (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) - { - /* Intrapixel differencing */ - png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1); - } -#endif - - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED - if (png_ptr->transformations) - png_do_read_transformations(png_ptr, &row_info); -#endif - - /* The transformed pixel depth should match the depth now in row_info. */ - if (png_ptr->transformed_pixel_depth == 0) - { - png_ptr->transformed_pixel_depth = row_info.pixel_depth; - if (row_info.pixel_depth > png_ptr->maximum_pixel_depth) - png_error(png_ptr, "sequential row overflow"); - } - - else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth) - png_error(png_ptr, "internal sequential row size calculation error"); - -#ifdef PNG_READ_INTERLACING_SUPPORTED - /* Blow up interlaced rows to full size */ - if (png_ptr->interlaced && - (png_ptr->transformations & PNG_INTERLACE)) - { - if (png_ptr->pass < 6) - png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, - png_ptr->transformations); - - if (dsp_row != NULL) - png_combine_row(png_ptr, dsp_row, 1/*display*/); - - if (row != NULL) - png_combine_row(png_ptr, row, 0/*row*/); - } - - else -#endif - { - if (row != NULL) - png_combine_row(png_ptr, row, -1/*ignored*/); - - if (dsp_row != NULL) - png_combine_row(png_ptr, dsp_row, -1/*ignored*/); - } - png_read_finish_row(png_ptr); - - if (png_ptr->read_row_fn != NULL) - (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read one or more rows of image data. If the image is interlaced, - * and png_set_interlace_handling() has been called, the rows need to - * contain the contents of the rows from the previous pass. If the - * image has alpha or transparency, and png_handle_alpha()[*] has been - * called, the rows contents must be initialized to the contents of the - * screen. - * - * "row" holds the actual image, and pixels are placed in it - * as they arrive. If the image is displayed after each pass, it will - * appear to "sparkle" in. "display_row" can be used to display a - * "chunky" progressive image, with finer detail added as it becomes - * available. If you do not want this "chunky" display, you may pass - * NULL for display_row. If you do not want the sparkle display, and - * you have not called png_handle_alpha(), you may pass NULL for rows. - * If you have called png_handle_alpha(), and the image has either an - * alpha channel or a transparency chunk, you must provide a buffer for - * rows. In this case, you do not have to provide a display_row buffer - * also, but you may. If the image is not interlaced, or if you have - * not called png_set_interlace_handling(), the display_row buffer will - * be ignored, so pass NULL to it. - * - * [*] png_handle_alpha() does not exist yet, as of this version of libpng - */ - -void PNGAPI -png_read_rows(png_structp png_ptr, png_bytepp row, - png_bytepp display_row, png_uint_32 num_rows) -{ - png_uint_32 i; - png_bytepp rp; - png_bytepp dp; - - png_debug(1, "in png_read_rows"); - - if (png_ptr == NULL) - return; - - rp = row; - dp = display_row; - if (rp != NULL && dp != NULL) - for (i = 0; i < num_rows; i++) - { - png_bytep rptr = *rp++; - png_bytep dptr = *dp++; - - png_read_row(png_ptr, rptr, dptr); - } - - else if (rp != NULL) - for (i = 0; i < num_rows; i++) - { - png_bytep rptr = *rp; - png_read_row(png_ptr, rptr, NULL); - rp++; - } - - else if (dp != NULL) - for (i = 0; i < num_rows; i++) - { - png_bytep dptr = *dp; - png_read_row(png_ptr, NULL, dptr); - dp++; - } -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read the entire image. If the image has an alpha channel or a tRNS - * chunk, and you have called png_handle_alpha()[*], you will need to - * initialize the image to the current image that PNG will be overlaying. - * We set the num_rows again here, in case it was incorrectly set in - * png_read_start_row() by a call to png_read_update_info() or - * png_start_read_image() if png_set_interlace_handling() wasn't called - * prior to either of these functions like it should have been. You can - * only call this function once. If you desire to have an image for - * each pass of a interlaced image, use png_read_rows() instead. - * - * [*] png_handle_alpha() does not exist yet, as of this version of libpng - */ -void PNGAPI -png_read_image(png_structp png_ptr, png_bytepp image) -{ - png_uint_32 i, image_height; - int pass, j; - png_bytepp rp; - - png_debug(1, "in png_read_image"); - - if (png_ptr == NULL) - return; - -#ifdef PNG_READ_INTERLACING_SUPPORTED - if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) - { - pass = png_set_interlace_handling(png_ptr); - /* And make sure transforms are initialized. */ - png_start_read_image(png_ptr); - } - else - { - if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE)) - { - /* Caller called png_start_read_image or png_read_update_info without - * first turning on the PNG_INTERLACE transform. We can fix this here, - * but the caller should do it! - */ - png_warning(png_ptr, "Interlace handling should be turned on when " - "using png_read_image"); - /* Make sure this is set correctly */ - png_ptr->num_rows = png_ptr->height; - } - - /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in - * the above error case. - */ - pass = png_set_interlace_handling(png_ptr); - } -#else - if (png_ptr->interlaced) - png_error(png_ptr, - "Cannot read interlaced image -- interlace handler disabled"); - - pass = 1; -#endif - - image_height=png_ptr->height; - - for (j = 0; j < pass; j++) - { - rp = image; - for (i = 0; i < image_height; i++) - { - png_read_row(png_ptr, *rp, NULL); - rp++; - } - } -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -/* Read the end of the PNG file. Will not read past the end of the - * file, will verify the end is accurate, and will read any comments - * or time information at the end of the file, if info is not NULL. - */ -void PNGAPI -png_read_end(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_read_end"); - - if (png_ptr == NULL) - return; - - png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ - -#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED - /* Report invalid palette index; added at libng-1.5.10 */ - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && - png_ptr->num_palette_max > png_ptr->num_palette) - png_benign_error(png_ptr, "Read palette index exceeding num_palette"); -#endif - - do - { - png_uint_32 length = png_read_chunk_header(png_ptr); - png_uint_32 chunk_name = png_ptr->chunk_name; - - if (chunk_name == png_IHDR) - png_handle_IHDR(png_ptr, info_ptr, length); - - else if (chunk_name == png_IEND) - png_handle_IEND(png_ptr, info_ptr, length); - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - else if (png_chunk_unknown_handling(png_ptr, chunk_name) != - PNG_HANDLE_CHUNK_AS_DEFAULT) - { - if (chunk_name == png_IDAT) - { - if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) - png_benign_error(png_ptr, "Too many IDATs found"); - } - png_handle_unknown(png_ptr, info_ptr, length); - if (chunk_name == png_PLTE) - png_ptr->mode |= PNG_HAVE_PLTE; - } -#endif - - else if (chunk_name == png_IDAT) - { - /* Zero length IDATs are legal after the last IDAT has been - * read, but not after other chunks have been read. - */ - if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) - png_benign_error(png_ptr, "Too many IDATs found"); - - png_crc_finish(png_ptr, length); - } - else if (chunk_name == png_PLTE) - png_handle_PLTE(png_ptr, info_ptr, length); - -#ifdef PNG_READ_bKGD_SUPPORTED - else if (chunk_name == png_bKGD) - png_handle_bKGD(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_cHRM_SUPPORTED - else if (chunk_name == png_cHRM) - png_handle_cHRM(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_gAMA_SUPPORTED - else if (chunk_name == png_gAMA) - png_handle_gAMA(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_hIST_SUPPORTED - else if (chunk_name == png_hIST) - png_handle_hIST(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_oFFs_SUPPORTED - else if (chunk_name == png_oFFs) - png_handle_oFFs(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_pCAL_SUPPORTED - else if (chunk_name == png_pCAL) - png_handle_pCAL(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sCAL_SUPPORTED - else if (chunk_name == png_sCAL) - png_handle_sCAL(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_pHYs_SUPPORTED - else if (chunk_name == png_pHYs) - png_handle_pHYs(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sBIT_SUPPORTED - else if (chunk_name == png_sBIT) - png_handle_sBIT(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sRGB_SUPPORTED - else if (chunk_name == png_sRGB) - png_handle_sRGB(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_iCCP_SUPPORTED - else if (chunk_name == png_iCCP) - png_handle_iCCP(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_sPLT_SUPPORTED - else if (chunk_name == png_sPLT) - png_handle_sPLT(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_tEXt_SUPPORTED - else if (chunk_name == png_tEXt) - png_handle_tEXt(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_tIME_SUPPORTED - else if (chunk_name == png_tIME) - png_handle_tIME(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_tRNS_SUPPORTED - else if (chunk_name == png_tRNS) - png_handle_tRNS(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_zTXt_SUPPORTED - else if (chunk_name == png_zTXt) - png_handle_zTXt(png_ptr, info_ptr, length); -#endif - -#ifdef PNG_READ_iTXt_SUPPORTED - else if (chunk_name == png_iTXt) - png_handle_iTXt(png_ptr, info_ptr, length); -#endif - - else - png_handle_unknown(png_ptr, info_ptr, length); - } while (!(png_ptr->mode & PNG_HAVE_IEND)); -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -/* Free all memory used by the read */ -void PNGAPI -png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, - png_infopp end_info_ptr_ptr) -{ - png_structp png_ptr = NULL; - png_infop info_ptr = NULL, end_info_ptr = NULL; -#ifdef PNG_USER_MEM_SUPPORTED - png_free_ptr free_fn = NULL; - png_voidp mem_ptr = NULL; -#endif - - png_debug(1, "in png_destroy_read_struct"); - - if (png_ptr_ptr != NULL) - png_ptr = *png_ptr_ptr; - if (png_ptr == NULL) - return; - -#ifdef PNG_USER_MEM_SUPPORTED - free_fn = png_ptr->free_fn; - mem_ptr = png_ptr->mem_ptr; -#endif - - if (info_ptr_ptr != NULL) - info_ptr = *info_ptr_ptr; - - if (end_info_ptr_ptr != NULL) - end_info_ptr = *end_info_ptr_ptr; - - png_read_destroy(png_ptr, info_ptr, end_info_ptr); - - if (info_ptr != NULL) - { -#ifdef PNG_TEXT_SUPPORTED - png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); -#endif - -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, - (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)info_ptr); -#endif - *info_ptr_ptr = NULL; - } - - if (end_info_ptr != NULL) - { -#ifdef PNG_READ_TEXT_SUPPORTED - png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); -#endif -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, - (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)end_info_ptr); -#endif - *end_info_ptr_ptr = NULL; - } - - if (png_ptr != NULL) - { -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, - (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)png_ptr); -#endif - *png_ptr_ptr = NULL; - } -} - -/* Free all memory used by the read (old method) */ -void /* PRIVATE */ -png_read_destroy(png_structp png_ptr, png_infop info_ptr, - png_infop end_info_ptr) -{ -#ifdef PNG_SETJMP_SUPPORTED - jmp_buf tmp_jmp; -#endif - png_error_ptr error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - png_error_ptr warning_fn; -#endif - png_voidp error_ptr; -#ifdef PNG_USER_MEM_SUPPORTED - png_free_ptr free_fn; -#endif - - png_debug(1, "in png_read_destroy"); - - if (info_ptr != NULL) - png_info_destroy(png_ptr, info_ptr); - - if (end_info_ptr != NULL) - png_info_destroy(png_ptr, end_info_ptr); - -#ifdef PNG_READ_GAMMA_SUPPORTED - png_destroy_gamma_table(png_ptr); -#endif - - png_free(png_ptr, png_ptr->zbuf); - png_free(png_ptr, png_ptr->big_row_buf); - png_free(png_ptr, png_ptr->big_prev_row); - png_free(png_ptr, png_ptr->chunkdata); - -#ifdef PNG_READ_QUANTIZE_SUPPORTED - png_free(png_ptr, png_ptr->palette_lookup); - png_free(png_ptr, png_ptr->quantize_index); -#endif - - if (png_ptr->free_me & PNG_FREE_PLTE) - png_zfree((voidpf)png_ptr, (voidpf)png_ptr->palette); - png_ptr->free_me &= ~PNG_FREE_PLTE; - -#if defined(PNG_tRNS_SUPPORTED) || \ - defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - if (png_ptr->free_me & PNG_FREE_TRNS) - png_free(png_ptr, png_ptr->trans_alpha); - png_ptr->free_me &= ~PNG_FREE_TRNS; -#endif - -#ifdef PNG_READ_hIST_SUPPORTED - if (png_ptr->free_me & PNG_FREE_HIST) - png_free(png_ptr, png_ptr->hist); - png_ptr->free_me &= ~PNG_FREE_HIST; -#endif - - inflateEnd(&png_ptr->zstream); - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED - png_free(png_ptr, png_ptr->save_buffer); -#endif - - /* Save the important info out of the png_struct, in case it is - * being used again. - */ -#ifdef PNG_SETJMP_SUPPORTED - png_memcpy(tmp_jmp, png_ptr->longjmp_buffer, png_sizeof(jmp_buf)); -#endif - - error_fn = png_ptr->error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - warning_fn = png_ptr->warning_fn; -#endif - error_ptr = png_ptr->error_ptr; -#ifdef PNG_USER_MEM_SUPPORTED - free_fn = png_ptr->free_fn; -#endif - - png_memset(png_ptr, 0, png_sizeof(png_struct)); - - png_ptr->error_fn = error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - png_ptr->warning_fn = warning_fn; -#endif - png_ptr->error_ptr = error_ptr; -#ifdef PNG_USER_MEM_SUPPORTED - png_ptr->free_fn = free_fn; -#endif - -#ifdef PNG_SETJMP_SUPPORTED - png_memcpy(png_ptr->longjmp_buffer, tmp_jmp, png_sizeof(jmp_buf)); -#endif - -} - -void PNGAPI -png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) -{ - if (png_ptr == NULL) - return; - - png_ptr->read_row_fn = read_row_fn; -} - - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -#ifdef PNG_INFO_IMAGE_SUPPORTED -void PNGAPI -png_read_png(png_structp png_ptr, png_infop info_ptr, - int transforms, - voidp params) -{ - int row; - - if (png_ptr == NULL || info_ptr == NULL) - return; - - /* png_read_info() gives us all of the information from the - * PNG file before the first IDAT (image data chunk). - */ - png_read_info(png_ptr, info_ptr); - if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) - png_error(png_ptr, "Image is too high to process with png_read_png()"); - - /* -------------- image transformations start here ------------------- */ - -#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED - /* Tell libpng to strip 16-bit/color files down to 8 bits per color. - */ - if (transforms & PNG_TRANSFORM_SCALE_16) - { - /* Added at libpng-1.5.4. "strip_16" produces the same result that it - * did in earlier versions, while "scale_16" is now more accurate. - */ - png_set_scale_16(png_ptr); - } -#endif - -#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED - /* If both SCALE and STRIP are required pngrtran will effectively cancel the - * latter by doing SCALE first. This is ok and allows apps not to check for - * which is supported to get the right answer. - */ - if (transforms & PNG_TRANSFORM_STRIP_16) - png_set_strip_16(png_ptr); -#endif - -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED - /* Strip alpha bytes from the input data without combining with - * the background (not recommended). - */ - if (transforms & PNG_TRANSFORM_STRIP_ALPHA) - png_set_strip_alpha(png_ptr); -#endif - -#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) - /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single - * byte into separate bytes (useful for paletted and grayscale images). - */ - if (transforms & PNG_TRANSFORM_PACKING) - png_set_packing(png_ptr); -#endif - -#ifdef PNG_READ_PACKSWAP_SUPPORTED - /* Change the order of packed pixels to least significant bit first - * (not useful if you are using png_set_packing). - */ - if (transforms & PNG_TRANSFORM_PACKSWAP) - png_set_packswap(png_ptr); -#endif - -#ifdef PNG_READ_EXPAND_SUPPORTED - /* Expand paletted colors into true RGB triplets - * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel - * Expand paletted or RGB images with transparency to full alpha - * channels so the data will be available as RGBA quartets. - */ - if (transforms & PNG_TRANSFORM_EXPAND) - if ((png_ptr->bit_depth < 8) || - (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || - (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) - png_set_expand(png_ptr); -#endif - - /* We don't handle background color or gamma transformation or quantizing. - */ - -#ifdef PNG_READ_INVERT_SUPPORTED - /* Invert monochrome files to have 0 as white and 1 as black - */ - if (transforms & PNG_TRANSFORM_INVERT_MONO) - png_set_invert_mono(png_ptr); -#endif - -#ifdef PNG_READ_SHIFT_SUPPORTED - /* If you want to shift the pixel values from the range [0,255] or - * [0,65535] to the original [0,7] or [0,31], or whatever range the - * colors were originally in: - */ - if ((transforms & PNG_TRANSFORM_SHIFT) - && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) - { - png_color_8p sig_bit; - - png_get_sBIT(png_ptr, info_ptr, &sig_bit); - png_set_shift(png_ptr, sig_bit); - } -#endif - -#ifdef PNG_READ_BGR_SUPPORTED - /* Flip the RGB pixels to BGR (or RGBA to BGRA) */ - if (transforms & PNG_TRANSFORM_BGR) - png_set_bgr(png_ptr); -#endif - -#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED - /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ - if (transforms & PNG_TRANSFORM_SWAP_ALPHA) - png_set_swap_alpha(png_ptr); -#endif - -#ifdef PNG_READ_SWAP_SUPPORTED - /* Swap bytes of 16-bit files to least significant byte first */ - if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) - png_set_swap(png_ptr); -#endif - -/* Added at libpng-1.2.41 */ -#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED - /* Invert the alpha channel from opacity to transparency */ - if (transforms & PNG_TRANSFORM_INVERT_ALPHA) - png_set_invert_alpha(png_ptr); -#endif - -/* Added at libpng-1.2.41 */ -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED - /* Expand grayscale image to RGB */ - if (transforms & PNG_TRANSFORM_GRAY_TO_RGB) - png_set_gray_to_rgb(png_ptr); -#endif - -/* Added at libpng-1.5.4 */ -#ifdef PNG_READ_EXPAND_16_SUPPORTED - if (transforms & PNG_TRANSFORM_EXPAND_16) - png_set_expand_16(png_ptr); -#endif - - /* We don't handle adding filler bytes */ - - /* We use png_read_image and rely on that for interlace handling, but we also - * call png_read_update_info therefore must turn on interlace handling now: - */ - (void)png_set_interlace_handling(png_ptr); - - /* Optional call to gamma correct and add the background to the palette - * and update info structure. REQUIRED if you are expecting libpng to - * update the palette for you (i.e., you selected such a transform above). - */ - png_read_update_info(png_ptr, info_ptr); - - /* -------------- image transformations end here ------------------- */ - - png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); - if (info_ptr->row_pointers == NULL) - { - png_uint_32 iptr; - - info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, - info_ptr->height * png_sizeof(png_bytep)); - for (iptr=0; iptrheight; iptr++) - info_ptr->row_pointers[iptr] = NULL; - - info_ptr->free_me |= PNG_FREE_ROWS; - - for (row = 0; row < (int)info_ptr->height; row++) - info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, - png_get_rowbytes(png_ptr, info_ptr)); - } - - png_read_image(png_ptr, info_ptr->row_pointers); - info_ptr->valid |= PNG_INFO_IDAT; - - /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ - png_read_end(png_ptr, info_ptr); - - PNG_UNUSED(transforms) /* Quiet compiler warnings */ - PNG_UNUSED(params) - -} -#endif /* PNG_INFO_IMAGE_SUPPORTED */ -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ -#endif /* PNG_READ_SUPPORTED */ diff --git a/source/libpng/pngrio.c b/source/libpng/pngrio.c deleted file mode 100644 index d0d9d8a..0000000 --- a/source/libpng/pngrio.c +++ /dev/null @@ -1,176 +0,0 @@ - -/* pngrio.c - functions for data input - * - * Last changed in libpng 1.5.0 [January 6, 2011] - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file provides a location for all input. Users who need - * special handling are expected to write a function that has the same - * arguments as this and performs a similar function, but that possibly - * has a different input method. Note that you shouldn't change this - * function, but rather write a replacement function and then make - * libpng use it at run time with png_set_read_fn(...). - */ - -#include "pngpriv.h" - -#ifdef PNG_READ_SUPPORTED - -/* Read the data from whatever input you are using. The default routine - * reads from a file pointer. Note that this routine sometimes gets called - * with very small lengths, so you should implement some kind of simple - * buffering if you are using unbuffered reads. This should never be asked - * to read more then 64K on a 16 bit machine. - */ -void /* PRIVATE */ -png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) -{ - png_debug1(4, "reading %d bytes", (int)length); - - if (png_ptr->read_data_fn != NULL) - (*(png_ptr->read_data_fn))(png_ptr, data, length); - - else - png_error(png_ptr, "Call to NULL read function"); -} - -#ifdef PNG_STDIO_SUPPORTED -/* This is the function that does the actual reading of data. If you are - * not reading from a standard C stream, you should create a replacement - * read_data function and use it at run time with png_set_read_fn(), rather - * than changing the library. - */ -# ifndef USE_FAR_KEYWORD -void PNGCBAPI -png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) -{ - png_size_t check; - - if (png_ptr == NULL) - return; - - /* fread() returns 0 on error, so it is OK to store this in a png_size_t - * instead of an int, which is what fread() actually returns. - */ - check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr); - - if (check != length) - png_error(png_ptr, "Read Error"); -} -# else -/* This is the model-independent version. Since the standard I/O library - can't handle far buffers in the medium and small models, we have to copy - the data. -*/ - -#define NEAR_BUF_SIZE 1024 -#define MIN(a,b) (a <= b ? a : b) - -static void PNGCBAPI -png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) -{ - png_size_t check; - png_byte *n_data; - png_FILE_p io_ptr; - - if (png_ptr == NULL) - return; - - /* Check if data really is near. If so, use usual code. */ - n_data = (png_byte *)CVT_PTR_NOCHECK(data); - io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); - - if ((png_bytep)n_data == data) - { - check = fread(n_data, 1, length, io_ptr); - } - - else - { - png_byte buf[NEAR_BUF_SIZE]; - png_size_t read, remaining, err; - check = 0; - remaining = length; - - do - { - read = MIN(NEAR_BUF_SIZE, remaining); - err = fread(buf, 1, read, io_ptr); - png_memcpy(data, buf, read); /* copy far buffer to near buffer */ - - if (err != read) - break; - - else - check += err; - - data += read; - remaining -= read; - } - while (remaining != 0); - } - - if ((png_uint_32)check != (png_uint_32)length) - png_error(png_ptr, "read Error"); -} -# endif -#endif - -/* This function allows the application to supply a new input function - * for libpng if standard C streams aren't being used. - * - * This function takes as its arguments: - * - * png_ptr - pointer to a png input data structure - * - * io_ptr - pointer to user supplied structure containing info about - * the input functions. May be NULL. - * - * read_data_fn - pointer to a new input function that takes as its - * arguments a pointer to a png_struct, a pointer to - * a location where input data can be stored, and a 32-bit - * unsigned int that is the number of bytes to be read. - * To exit and output any fatal error messages the new write - * function should call png_error(png_ptr, "Error msg"). - * May be NULL, in which case libpng's default function will - * be used. - */ -void PNGAPI -png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, - png_rw_ptr read_data_fn) -{ - if (png_ptr == NULL) - return; - - png_ptr->io_ptr = io_ptr; - -#ifdef PNG_STDIO_SUPPORTED - if (read_data_fn != NULL) - png_ptr->read_data_fn = read_data_fn; - - else - png_ptr->read_data_fn = png_default_read_data; -#else - png_ptr->read_data_fn = read_data_fn; -#endif - - /* It is an error to write to a read device */ - if (png_ptr->write_data_fn != NULL) - { - png_ptr->write_data_fn = NULL; - png_warning(png_ptr, - "Can't set both read_data_fn and write_data_fn in the" - " same structure"); - } - -#ifdef PNG_WRITE_FLUSH_SUPPORTED - png_ptr->output_flush_fn = NULL; -#endif -} -#endif /* PNG_READ_SUPPORTED */ diff --git a/source/libpng/pngrtran.c b/source/libpng/pngrtran.c deleted file mode 100644 index 6ec9089..0000000 --- a/source/libpng/pngrtran.c +++ /dev/null @@ -1,5032 +0,0 @@ - -/* pngrtran.c - transforms the data in a row for PNG readers - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file contains functions optionally called by an application - * in order to tell libpng how to handle data when reading a PNG. - * Transformations that are used in both reading and writing are - * in pngtrans.c. - */ - -#include "pngpriv.h" - -#ifdef PNG_READ_SUPPORTED - -/* Set the action on getting a CRC error for an ancillary or critical chunk. */ -void PNGAPI -png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) -{ - png_debug(1, "in png_set_crc_action"); - - if (png_ptr == NULL) - return; - - /* Tell libpng how we react to CRC errors in critical chunks */ - switch (crit_action) - { - case PNG_CRC_NO_CHANGE: /* Leave setting as is */ - break; - - case PNG_CRC_WARN_USE: /* Warn/use data */ - png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; - png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; - break; - - case PNG_CRC_QUIET_USE: /* Quiet/use data */ - png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; - png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | - PNG_FLAG_CRC_CRITICAL_IGNORE; - break; - - case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */ - png_warning(png_ptr, - "Can't discard critical data on CRC error"); - case PNG_CRC_ERROR_QUIT: /* Error/quit */ - - case PNG_CRC_DEFAULT: - default: - png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; - break; - } - - /* Tell libpng how we react to CRC errors in ancillary chunks */ - switch (ancil_action) - { - case PNG_CRC_NO_CHANGE: /* Leave setting as is */ - break; - - case PNG_CRC_WARN_USE: /* Warn/use data */ - png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; - png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; - break; - - case PNG_CRC_QUIET_USE: /* Quiet/use data */ - png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; - png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | - PNG_FLAG_CRC_ANCILLARY_NOWARN; - break; - - case PNG_CRC_ERROR_QUIT: /* Error/quit */ - png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; - png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; - break; - - case PNG_CRC_WARN_DISCARD: /* Warn/discard data */ - - case PNG_CRC_DEFAULT: - default: - png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; - break; - } -} - -#ifdef PNG_READ_BACKGROUND_SUPPORTED -/* Handle alpha and tRNS via a background color */ -void PNGFAPI -png_set_background_fixed(png_structp png_ptr, - png_const_color_16p background_color, int background_gamma_code, - int need_expand, png_fixed_point background_gamma) -{ - png_debug(1, "in png_set_background_fixed"); - - if (png_ptr == NULL) - return; - - if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) - { - png_warning(png_ptr, "Application must supply a known background gamma"); - return; - } - - png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA; - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - - png_memcpy(&(png_ptr->background), background_color, - png_sizeof(png_color_16)); - png_ptr->background_gamma = background_gamma; - png_ptr->background_gamma_type = (png_byte)(background_gamma_code); - if (need_expand) - png_ptr->transformations |= PNG_BACKGROUND_EXPAND; - else - png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_background(png_structp png_ptr, - png_const_color_16p background_color, int background_gamma_code, - int need_expand, double background_gamma) -{ - png_set_background_fixed(png_ptr, background_color, background_gamma_code, - need_expand, png_fixed(png_ptr, background_gamma, "png_set_background")); -} -# endif /* FLOATING_POINT */ -#endif /* READ_BACKGROUND */ - -/* Scale 16-bit depth files to 8-bit depth. If both of these are set then the - * one that pngrtran does first (scale) happens. This is necessary to allow the - * TRANSFORM and API behavior to be somewhat consistent, and it's simpler. - */ -#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED -void PNGAPI -png_set_scale_16(png_structp png_ptr) -{ - png_debug(1, "in png_set_scale_16"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_SCALE_16_TO_8; -} -#endif - -#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED -/* Chop 16-bit depth files to 8-bit depth */ -void PNGAPI -png_set_strip_16(png_structp png_ptr) -{ - png_debug(1, "in png_set_strip_16"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_16_TO_8; -} -#endif - -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED -void PNGAPI -png_set_strip_alpha(png_structp png_ptr) -{ - png_debug(1, "in png_set_strip_alpha"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_STRIP_ALPHA; -} -#endif - -#if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED) -static png_fixed_point -translate_gamma_flags(png_structp png_ptr, png_fixed_point output_gamma, - int is_screen) -{ - /* Check for flag values. The main reason for having the old Mac value as a - * flag is that it is pretty near impossible to work out what the correct - * value is from Apple documentation - a working Mac system is needed to - * discover the value! - */ - if (output_gamma == PNG_DEFAULT_sRGB || - output_gamma == PNG_FP_1 / PNG_DEFAULT_sRGB) - { - /* If there is no sRGB support this just sets the gamma to the standard - * sRGB value. (This is a side effect of using this function!) - */ -# ifdef PNG_READ_sRGB_SUPPORTED - png_ptr->flags |= PNG_FLAG_ASSUME_sRGB; -# endif - if (is_screen) - output_gamma = PNG_GAMMA_sRGB; - else - output_gamma = PNG_GAMMA_sRGB_INVERSE; - } - - else if (output_gamma == PNG_GAMMA_MAC_18 || - output_gamma == PNG_FP_1 / PNG_GAMMA_MAC_18) - { - if (is_screen) - output_gamma = PNG_GAMMA_MAC_OLD; - else - output_gamma = PNG_GAMMA_MAC_INVERSE; - } - - return output_gamma; -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -static png_fixed_point -convert_gamma_value(png_structp png_ptr, double output_gamma) -{ - /* The following silently ignores cases where fixed point (times 100,000) - * gamma values are passed to the floating point API. This is safe and it - * means the fixed point constants work just fine with the floating point - * API. The alternative would just lead to undetected errors and spurious - * bug reports. Negative values fail inside the _fixed API unless they - * correspond to the flag values. - */ - if (output_gamma > 0 && output_gamma < 128) - output_gamma *= PNG_FP_1; - - /* This preserves -1 and -2 exactly: */ - output_gamma = floor(output_gamma + .5); - - if (output_gamma > PNG_FP_MAX || output_gamma < PNG_FP_MIN) - png_fixed_error(png_ptr, "gamma value"); - - return (png_fixed_point)output_gamma; -} -# endif -#endif /* READ_ALPHA_MODE || READ_GAMMA */ - -#ifdef PNG_READ_ALPHA_MODE_SUPPORTED -void PNGFAPI -png_set_alpha_mode_fixed(png_structp png_ptr, int mode, - png_fixed_point output_gamma) -{ - int compose = 0; - png_fixed_point file_gamma; - - png_debug(1, "in png_set_alpha_mode"); - - if (png_ptr == NULL) - return; - - output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/); - - /* Validate the value to ensure it is in a reasonable range. The value - * is expected to be 1 or greater, but this range test allows for some - * viewing correction values. The intent is to weed out users of this API - * who use the inverse of the gamma value accidentally! Since some of these - * values are reasonable this may have to be changed. - */ - if (output_gamma < 70000 || output_gamma > 300000) - png_error(png_ptr, "output gamma out of expected range"); - - /* The default file gamma is the inverse of the output gamma; the output - * gamma may be changed below so get the file value first: - */ - file_gamma = png_reciprocal(output_gamma); - - /* There are really 8 possibilities here, composed of any combination - * of: - * - * premultiply the color channels - * do not encode non-opaque pixels - * encode the alpha as well as the color channels - * - * The differences disappear if the input/output ('screen') gamma is 1.0, - * because then the encoding is a no-op and there is only the choice of - * premultiplying the color channels or not. - * - * png_set_alpha_mode and png_set_background interact because both use - * png_compose to do the work. Calling both is only useful when - * png_set_alpha_mode is used to set the default mode - PNG_ALPHA_PNG - along - * with a default gamma value. Otherwise PNG_COMPOSE must not be set. - */ - switch (mode) - { - case PNG_ALPHA_PNG: /* default: png standard */ - /* No compose, but it may be set by png_set_background! */ - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - break; - - case PNG_ALPHA_ASSOCIATED: /* color channels premultiplied */ - compose = 1; - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - /* The output is linear: */ - output_gamma = PNG_FP_1; - break; - - case PNG_ALPHA_OPTIMIZED: /* associated, non-opaque pixels linear */ - compose = 1; - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA; - /* output_gamma records the encoding of opaque pixels! */ - break; - - case PNG_ALPHA_BROKEN: /* associated, non-linear, alpha encoded */ - compose = 1; - png_ptr->transformations |= PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - break; - - default: - png_error(png_ptr, "invalid alpha mode"); - } - - /* Only set the default gamma if the file gamma has not been set (this has - * the side effect that the gamma in a second call to png_set_alpha_mode will - * be ignored.) - */ - if (png_ptr->gamma == 0) - png_ptr->gamma = file_gamma; - - /* But always set the output gamma: */ - png_ptr->screen_gamma = output_gamma; - - /* Finally, if pre-multiplying, set the background fields to achieve the - * desired result. - */ - if (compose) - { - /* And obtain alpha pre-multiplication by composing on black: */ - png_memset(&png_ptr->background, 0, sizeof png_ptr->background); - png_ptr->background_gamma = png_ptr->gamma; /* just in case */ - png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE; - png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; - - if (png_ptr->transformations & PNG_COMPOSE) - png_error(png_ptr, - "conflicting calls to set alpha mode and background"); - - png_ptr->transformations |= PNG_COMPOSE; - } - - /* New API, make sure apps call the correct initializers: */ - png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED; -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_alpha_mode(png_structp png_ptr, int mode, double output_gamma) -{ - png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr, - output_gamma)); -} -# endif -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED -/* Dither file to 8-bit. Supply a palette, the current number - * of elements in the palette, the maximum number of elements - * allowed, and a histogram if possible. If the current number - * of colors is greater then the maximum number, the palette will be - * modified to fit in the maximum number. "full_quantize" indicates - * whether we need a quantizing cube set up for RGB images, or if we - * simply are reducing the number of colors in a paletted image. - */ - -typedef struct png_dsort_struct -{ - struct png_dsort_struct FAR * next; - png_byte left; - png_byte right; -} png_dsort; -typedef png_dsort FAR * png_dsortp; -typedef png_dsort FAR * FAR * png_dsortpp; - -void PNGAPI -png_set_quantize(png_structp png_ptr, png_colorp palette, - int num_palette, int maximum_colors, png_const_uint_16p histogram, - int full_quantize) -{ - png_debug(1, "in png_set_quantize"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_QUANTIZE; - - if (!full_quantize) - { - int i; - - png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr, - (png_uint_32)(num_palette * png_sizeof(png_byte))); - for (i = 0; i < num_palette; i++) - png_ptr->quantize_index[i] = (png_byte)i; - } - - if (num_palette > maximum_colors) - { - if (histogram != NULL) - { - /* This is easy enough, just throw out the least used colors. - * Perhaps not the best solution, but good enough. - */ - - int i; - - /* Initialize an array to sort colors */ - png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr, - (png_uint_32)(num_palette * png_sizeof(png_byte))); - - /* Initialize the quantize_sort array */ - for (i = 0; i < num_palette; i++) - png_ptr->quantize_sort[i] = (png_byte)i; - - /* Find the least used palette entries by starting a - * bubble sort, and running it until we have sorted - * out enough colors. Note that we don't care about - * sorting all the colors, just finding which are - * least used. - */ - - for (i = num_palette - 1; i >= maximum_colors; i--) - { - int done; /* To stop early if the list is pre-sorted */ - int j; - - done = 1; - for (j = 0; j < i; j++) - { - if (histogram[png_ptr->quantize_sort[j]] - < histogram[png_ptr->quantize_sort[j + 1]]) - { - png_byte t; - - t = png_ptr->quantize_sort[j]; - png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1]; - png_ptr->quantize_sort[j + 1] = t; - done = 0; - } - } - - if (done) - break; - } - - /* Swap the palette around, and set up a table, if necessary */ - if (full_quantize) - { - int j = num_palette; - - /* Put all the useful colors within the max, but don't - * move the others. - */ - for (i = 0; i < maximum_colors; i++) - { - if ((int)png_ptr->quantize_sort[i] >= maximum_colors) - { - do - j--; - while ((int)png_ptr->quantize_sort[j] >= maximum_colors); - - palette[i] = palette[j]; - } - } - } - else - { - int j = num_palette; - - /* Move all the used colors inside the max limit, and - * develop a translation table. - */ - for (i = 0; i < maximum_colors; i++) - { - /* Only move the colors we need to */ - if ((int)png_ptr->quantize_sort[i] >= maximum_colors) - { - png_color tmp_color; - - do - j--; - while ((int)png_ptr->quantize_sort[j] >= maximum_colors); - - tmp_color = palette[j]; - palette[j] = palette[i]; - palette[i] = tmp_color; - /* Indicate where the color went */ - png_ptr->quantize_index[j] = (png_byte)i; - png_ptr->quantize_index[i] = (png_byte)j; - } - } - - /* Find closest color for those colors we are not using */ - for (i = 0; i < num_palette; i++) - { - if ((int)png_ptr->quantize_index[i] >= maximum_colors) - { - int min_d, k, min_k, d_index; - - /* Find the closest color to one we threw out */ - d_index = png_ptr->quantize_index[i]; - min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); - for (k = 1, min_k = 0; k < maximum_colors; k++) - { - int d; - - d = PNG_COLOR_DIST(palette[d_index], palette[k]); - - if (d < min_d) - { - min_d = d; - min_k = k; - } - } - /* Point to closest color */ - png_ptr->quantize_index[i] = (png_byte)min_k; - } - } - } - png_free(png_ptr, png_ptr->quantize_sort); - png_ptr->quantize_sort = NULL; - } - else - { - /* This is much harder to do simply (and quickly). Perhaps - * we need to go through a median cut routine, but those - * don't always behave themselves with only a few colors - * as input. So we will just find the closest two colors, - * and throw out one of them (chosen somewhat randomly). - * [We don't understand this at all, so if someone wants to - * work on improving it, be our guest - AED, GRP] - */ - int i; - int max_d; - int num_new_palette; - png_dsortp t; - png_dsortpp hash; - - t = NULL; - - /* Initialize palette index arrays */ - png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, - (png_uint_32)(num_palette * png_sizeof(png_byte))); - png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, - (png_uint_32)(num_palette * png_sizeof(png_byte))); - - /* Initialize the sort array */ - for (i = 0; i < num_palette; i++) - { - png_ptr->index_to_palette[i] = (png_byte)i; - png_ptr->palette_to_index[i] = (png_byte)i; - } - - hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 * - png_sizeof(png_dsortp))); - - num_new_palette = num_palette; - - /* Initial wild guess at how far apart the farthest pixel - * pair we will be eliminating will be. Larger - * numbers mean more areas will be allocated, Smaller - * numbers run the risk of not saving enough data, and - * having to do this all over again. - * - * I have not done extensive checking on this number. - */ - max_d = 96; - - while (num_new_palette > maximum_colors) - { - for (i = 0; i < num_new_palette - 1; i++) - { - int j; - - for (j = i + 1; j < num_new_palette; j++) - { - int d; - - d = PNG_COLOR_DIST(palette[i], palette[j]); - - if (d <= max_d) - { - - t = (png_dsortp)png_malloc_warn(png_ptr, - (png_uint_32)(png_sizeof(png_dsort))); - - if (t == NULL) - break; - - t->next = hash[d]; - t->left = (png_byte)i; - t->right = (png_byte)j; - hash[d] = t; - } - } - if (t == NULL) - break; - } - - if (t != NULL) - for (i = 0; i <= max_d; i++) - { - if (hash[i] != NULL) - { - png_dsortp p; - - for (p = hash[i]; p; p = p->next) - { - if ((int)png_ptr->index_to_palette[p->left] - < num_new_palette && - (int)png_ptr->index_to_palette[p->right] - < num_new_palette) - { - int j, next_j; - - if (num_new_palette & 0x01) - { - j = p->left; - next_j = p->right; - } - else - { - j = p->right; - next_j = p->left; - } - - num_new_palette--; - palette[png_ptr->index_to_palette[j]] - = palette[num_new_palette]; - if (!full_quantize) - { - int k; - - for (k = 0; k < num_palette; k++) - { - if (png_ptr->quantize_index[k] == - png_ptr->index_to_palette[j]) - png_ptr->quantize_index[k] = - png_ptr->index_to_palette[next_j]; - - if ((int)png_ptr->quantize_index[k] == - num_new_palette) - png_ptr->quantize_index[k] = - png_ptr->index_to_palette[j]; - } - } - - png_ptr->index_to_palette[png_ptr->palette_to_index - [num_new_palette]] = png_ptr->index_to_palette[j]; - - png_ptr->palette_to_index[png_ptr->index_to_palette[j]] - = png_ptr->palette_to_index[num_new_palette]; - - png_ptr->index_to_palette[j] = - (png_byte)num_new_palette; - - png_ptr->palette_to_index[num_new_palette] = - (png_byte)j; - } - if (num_new_palette <= maximum_colors) - break; - } - if (num_new_palette <= maximum_colors) - break; - } - } - - for (i = 0; i < 769; i++) - { - if (hash[i] != NULL) - { - png_dsortp p = hash[i]; - while (p) - { - t = p->next; - png_free(png_ptr, p); - p = t; - } - } - hash[i] = 0; - } - max_d += 96; - } - png_free(png_ptr, hash); - png_free(png_ptr, png_ptr->palette_to_index); - png_free(png_ptr, png_ptr->index_to_palette); - png_ptr->palette_to_index = NULL; - png_ptr->index_to_palette = NULL; - } - num_palette = maximum_colors; - } - if (png_ptr->palette == NULL) - { - png_ptr->palette = palette; - } - png_ptr->num_palette = (png_uint_16)num_palette; - - if (full_quantize) - { - int i; - png_bytep distance; - int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS + - PNG_QUANTIZE_BLUE_BITS; - int num_red = (1 << PNG_QUANTIZE_RED_BITS); - int num_green = (1 << PNG_QUANTIZE_GREEN_BITS); - int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS); - png_size_t num_entries = ((png_size_t)1 << total_bits); - - png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr, - (png_uint_32)(num_entries * png_sizeof(png_byte))); - - distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * - png_sizeof(png_byte))); - - png_memset(distance, 0xff, num_entries * png_sizeof(png_byte)); - - for (i = 0; i < num_palette; i++) - { - int ir, ig, ib; - int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS)); - int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS)); - int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS)); - - for (ir = 0; ir < num_red; ir++) - { - /* int dr = abs(ir - r); */ - int dr = ((ir > r) ? ir - r : r - ir); - int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS + - PNG_QUANTIZE_GREEN_BITS)); - - for (ig = 0; ig < num_green; ig++) - { - /* int dg = abs(ig - g); */ - int dg = ((ig > g) ? ig - g : g - ig); - int dt = dr + dg; - int dm = ((dr > dg) ? dr : dg); - int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS); - - for (ib = 0; ib < num_blue; ib++) - { - int d_index = index_g | ib; - /* int db = abs(ib - b); */ - int db = ((ib > b) ? ib - b : b - ib); - int dmax = ((dm > db) ? dm : db); - int d = dmax + dt + db; - - if (d < (int)distance[d_index]) - { - distance[d_index] = (png_byte)d; - png_ptr->palette_lookup[d_index] = (png_byte)i; - } - } - } - } - } - - png_free(png_ptr, distance); - } -} -#endif /* PNG_READ_QUANTIZE_SUPPORTED */ - -#ifdef PNG_READ_GAMMA_SUPPORTED -void PNGFAPI -png_set_gamma_fixed(png_structp png_ptr, png_fixed_point scrn_gamma, - png_fixed_point file_gamma) -{ - png_debug(1, "in png_set_gamma_fixed"); - - if (png_ptr == NULL) - return; - - /* New in libpng-1.5.4 - reserve particular negative values as flags. */ - scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/); - file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/); - -#if PNG_LIBPNG_VER >= 10600 - /* Checking the gamma values for being >0 was added in 1.5.4 along with the - * premultiplied alpha support; this actually hides an undocumented feature - * of the previous implementation which allowed gamma processing to be - * disabled in background handling. There is no evidence (so far) that this - * was being used; however, png_set_background itself accepted and must still - * accept '0' for the gamma value it takes, because it isn't always used. - * - * Since this is an API change (albeit a very minor one that removes an - * undocumented API feature) it will not be made until libpng-1.6.0. - */ - if (file_gamma <= 0) - png_error(png_ptr, "invalid file gamma in png_set_gamma"); - - if (scrn_gamma <= 0) - png_error(png_ptr, "invalid screen gamma in png_set_gamma"); -#endif - - /* Set the gamma values unconditionally - this overrides the value in the PNG - * file if a gAMA chunk was present. png_set_alpha_mode provides a - * different, easier, way to default the file gamma. - */ - png_ptr->gamma = file_gamma; - png_ptr->screen_gamma = scrn_gamma; -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) -{ - png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma), - convert_gamma_value(png_ptr, file_gamma)); -} -# endif /* FLOATING_POINT_SUPPORTED */ -#endif /* READ_GAMMA */ - -#ifdef PNG_READ_EXPAND_SUPPORTED -/* Expand paletted images to RGB, expand grayscale images of - * less than 8-bit depth to 8-bit depth, and expand tRNS chunks - * to alpha channels. - */ -void PNGAPI -png_set_expand(png_structp png_ptr) -{ - png_debug(1, "in png_set_expand"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); - png_ptr->flags &= ~PNG_FLAG_ROW_INIT; -} - -/* GRR 19990627: the following three functions currently are identical - * to png_set_expand(). However, it is entirely reasonable that someone - * might wish to expand an indexed image to RGB but *not* expand a single, - * fully transparent palette entry to a full alpha channel--perhaps instead - * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace - * the transparent color with a particular RGB value, or drop tRNS entirely. - * IOW, a future version of the library may make the transformations flag - * a bit more fine-grained, with separate bits for each of these three - * functions. - * - * More to the point, these functions make it obvious what libpng will be - * doing, whereas "expand" can (and does) mean any number of things. - * - * GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified - * to expand only the sample depth but not to expand the tRNS to alpha - * and its name was changed to png_set_expand_gray_1_2_4_to_8(). - */ - -/* Expand paletted images to RGB. */ -void PNGAPI -png_set_palette_to_rgb(png_structp png_ptr) -{ - png_debug(1, "in png_set_palette_to_rgb"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); - png_ptr->flags &= ~PNG_FLAG_ROW_INIT; -} - -/* Expand grayscale images of less than 8-bit depth to 8 bits. */ -void PNGAPI -png_set_expand_gray_1_2_4_to_8(png_structp png_ptr) -{ - png_debug(1, "in png_set_expand_gray_1_2_4_to_8"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_EXPAND; - png_ptr->flags &= ~PNG_FLAG_ROW_INIT; -} - - - -/* Expand tRNS chunks to alpha channels. */ -void PNGAPI -png_set_tRNS_to_alpha(png_structp png_ptr) -{ - png_debug(1, "in png_set_tRNS_to_alpha"); - - png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); - png_ptr->flags &= ~PNG_FLAG_ROW_INIT; -} -#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ - -#ifdef PNG_READ_EXPAND_16_SUPPORTED -/* Expand to 16-bit channels, expand the tRNS chunk too (because otherwise - * it may not work correctly.) - */ -void PNGAPI -png_set_expand_16(png_structp png_ptr) -{ - png_debug(1, "in png_set_expand_16"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS); - png_ptr->flags &= ~PNG_FLAG_ROW_INIT; - - /* New API, make sure apps call the correct initializers: */ - png_ptr->flags |= PNG_FLAG_DETECT_UNINITIALIZED; -} -#endif - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED -void PNGAPI -png_set_gray_to_rgb(png_structp png_ptr) -{ - png_debug(1, "in png_set_gray_to_rgb"); - - if (png_ptr != NULL) - { - /* Because rgb must be 8 bits or more: */ - png_set_expand_gray_1_2_4_to_8(png_ptr); - png_ptr->transformations |= PNG_GRAY_TO_RGB; - png_ptr->flags &= ~PNG_FLAG_ROW_INIT; - } -} -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED -void PNGFAPI -png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, - png_fixed_point red, png_fixed_point green) -{ - png_debug(1, "in png_set_rgb_to_gray"); - - if (png_ptr == NULL) - return; - - switch(error_action) - { - case PNG_ERROR_ACTION_NONE: - png_ptr->transformations |= PNG_RGB_TO_GRAY; - break; - - case PNG_ERROR_ACTION_WARN: - png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; - break; - - case PNG_ERROR_ACTION_ERROR: - png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; - break; - - default: - png_error(png_ptr, "invalid error action to rgb_to_gray"); - break; - } - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -#ifdef PNG_READ_EXPAND_SUPPORTED - png_ptr->transformations |= PNG_EXPAND; -#else - { - png_warning(png_ptr, - "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED"); - - png_ptr->transformations &= ~PNG_RGB_TO_GRAY; - } -#endif - { - if (red >= 0 && green >= 0 && red + green <= PNG_FP_1) - { - png_uint_16 red_int, green_int; - - /* NOTE: this calculation does not round, but this behavior is retained - * for consistency, the inaccuracy is very small. The code here always - * overwrites the coefficients, regardless of whether they have been - * defaulted or set already. - */ - red_int = (png_uint_16)(((png_uint_32)red*32768)/100000); - green_int = (png_uint_16)(((png_uint_32)green*32768)/100000); - - png_ptr->rgb_to_gray_red_coeff = red_int; - png_ptr->rgb_to_gray_green_coeff = green_int; - png_ptr->rgb_to_gray_coefficients_set = 1; - } - - else - { - if (red >= 0 && green >= 0) - png_warning(png_ptr, - "ignoring out of range rgb_to_gray coefficients"); - - /* Use the defaults, from the cHRM chunk if set, else the historical - * values which are close to the sRGB/HDTV/ITU-Rec 709 values. See - * png_do_rgb_to_gray for more discussion of the values. In this case - * the coefficients are not marked as 'set' and are not overwritten if - * something has already provided a default. - */ - if (png_ptr->rgb_to_gray_red_coeff == 0 && - png_ptr->rgb_to_gray_green_coeff == 0) - { - png_ptr->rgb_to_gray_red_coeff = 6968; - png_ptr->rgb_to_gray_green_coeff = 23434; - /* png_ptr->rgb_to_gray_blue_coeff = 2366; */ - } - } - } -} - -#ifdef PNG_FLOATING_POINT_SUPPORTED -/* Convert a RGB image to a grayscale of the same width. This allows us, - * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. - */ - -void PNGAPI -png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, - double green) -{ - if (png_ptr == NULL) - return; - - png_set_rgb_to_gray_fixed(png_ptr, error_action, - png_fixed(png_ptr, red, "rgb to gray red coefficient"), - png_fixed(png_ptr, green, "rgb to gray green coefficient")); -} -#endif /* FLOATING POINT */ - -#endif - -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -void PNGAPI -png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr - read_user_transform_fn) -{ - png_debug(1, "in png_set_read_user_transform_fn"); - - if (png_ptr == NULL) - return; - -#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED - png_ptr->transformations |= PNG_USER_TRANSFORM; - png_ptr->read_user_transform_fn = read_user_transform_fn; -#endif -} -#endif - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED -#ifdef PNG_READ_GAMMA_SUPPORTED -/* In the case of gamma transformations only do transformations on images where - * the [file] gamma and screen_gamma are not close reciprocals, otherwise it - * slows things down slightly, and also needlessly introduces small errors. - */ -static int /* PRIVATE */ -png_gamma_threshold(png_fixed_point screen_gamma, png_fixed_point file_gamma) -{ - /* PNG_GAMMA_THRESHOLD is the threshold for performing gamma - * correction as a difference of the overall transform from 1.0 - * - * We want to compare the threshold with s*f - 1, if we get - * overflow here it is because of wacky gamma values so we - * turn on processing anyway. - */ - png_fixed_point gtest; - return !png_muldiv(>est, screen_gamma, file_gamma, PNG_FP_1) || - png_gamma_significant(gtest); -} -#endif - -/* Initialize everything needed for the read. This includes modifying - * the palette. - */ - -/*For the moment 'png_init_palette_transformations' and - * 'png_init_rgb_transformations' only do some flag canceling optimizations. - * The intent is that these two routines should have palette or rgb operations - * extracted from 'png_init_read_transformations'. - */ -static void /* PRIVATE */ -png_init_palette_transformations(png_structp png_ptr) -{ - /* Called to handle the (input) palette case. In png_do_read_transformations - * the first step is to expand the palette if requested, so this code must - * take care to only make changes that are invariant with respect to the - * palette expansion, or only do them if there is no expansion. - * - * STRIP_ALPHA has already been handled in the caller (by setting num_trans - * to 0.) - */ - int input_has_alpha = 0; - int input_has_transparency = 0; - - if (png_ptr->num_trans > 0) - { - int i; - - /* Ignore if all the entries are opaque (unlikely!) */ - for (i=0; inum_trans; ++i) - if (png_ptr->trans_alpha[i] == 255) - continue; - else if (png_ptr->trans_alpha[i] == 0) - input_has_transparency = 1; - else - input_has_alpha = 1; - } - - /* If no alpha we can optimize. */ - if (!input_has_alpha) - { - /* Any alpha means background and associative alpha processing is - * required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA - * and ENCODE_ALPHA are irrelevant. - */ - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - - if (!input_has_transparency) - png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); - } - -#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) - /* png_set_background handling - deals with the complexity of whether the - * background color is in the file format or the screen format in the case - * where an 'expand' will happen. - */ - - /* The following code cannot be entered in the alpha pre-multiplication case - * because PNG_BACKGROUND_EXPAND is cancelled below. - */ - if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && - (png_ptr->transformations & PNG_EXPAND)) - { - { - png_ptr->background.red = - png_ptr->palette[png_ptr->background.index].red; - png_ptr->background.green = - png_ptr->palette[png_ptr->background.index].green; - png_ptr->background.blue = - png_ptr->palette[png_ptr->background.index].blue; - -#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED - if (png_ptr->transformations & PNG_INVERT_ALPHA) - { - if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) - { - /* Invert the alpha channel (in tRNS) unless the pixels are - * going to be expanded, in which case leave it for later - */ - int i, istop = png_ptr->num_trans; - - for (i=0; itrans_alpha[i] = (png_byte)(255 - - png_ptr->trans_alpha[i]); - } - } -#endif /* PNG_READ_INVERT_ALPHA_SUPPORTED */ - } - } /* background expand and (therefore) no alpha association. */ -#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ -} - -static void /* PRIVATE */ -png_init_rgb_transformations(png_structp png_ptr) -{ - /* Added to libpng-1.5.4: check the color type to determine whether there - * is any alpha or transparency in the image and simply cancel the - * background and alpha mode stuff if there isn't. - */ - int input_has_alpha = (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0; - int input_has_transparency = png_ptr->num_trans > 0; - - /* If no alpha we can optimize. */ - if (!input_has_alpha) - { - /* Any alpha means background and associative alpha processing is - * required, however if the alpha is 0 or 1 throughout OPTIIMIZE_ALPHA - * and ENCODE_ALPHA are irrelevant. - */ -# ifdef PNG_READ_ALPHA_MODE_SUPPORTED - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; -# endif - - if (!input_has_transparency) - png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); - } - -#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) - /* png_set_background handling - deals with the complexity of whether the - * background color is in the file format or the screen format in the case - * where an 'expand' will happen. - */ - - /* The following code cannot be entered in the alpha pre-multiplication case - * because PNG_BACKGROUND_EXPAND is cancelled below. - */ - if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && - (png_ptr->transformations & PNG_EXPAND) && - !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) - /* i.e., GRAY or GRAY_ALPHA */ - { - { - /* Expand background and tRNS chunks */ - int gray = png_ptr->background.gray; - int trans_gray = png_ptr->trans_color.gray; - - switch (png_ptr->bit_depth) - { - case 1: - gray *= 0xff; - trans_gray *= 0xff; - break; - - case 2: - gray *= 0x55; - trans_gray *= 0x55; - break; - - case 4: - gray *= 0x11; - trans_gray *= 0x11; - break; - - default: - - case 8: - /* Already 8 bits, fall through */ - - case 16: - /* Already a full 16 bits */ - break; - } - - png_ptr->background.red = png_ptr->background.green = - png_ptr->background.blue = (png_uint_16)gray; - - if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) - { - png_ptr->trans_color.red = png_ptr->trans_color.green = - png_ptr->trans_color.blue = (png_uint_16)trans_gray; - } - } - } /* background expand and (therefore) no alpha association. */ -#endif /* PNG_READ_EXPAND_SUPPORTED && PNG_READ_BACKGROUND_SUPPORTED */ -} - -void /* PRIVATE */ -png_init_read_transformations(png_structp png_ptr) -{ - png_debug(1, "in png_init_read_transformations"); - - /* This internal function is called from png_read_start_row in pngrutil.c - * and it is called before the 'rowbytes' calculation is done, so the code - * in here can change or update the transformations flags. - * - * First do updates that do not depend on the details of the PNG image data - * being processed. - */ - -#ifdef PNG_READ_GAMMA_SUPPORTED - /* Prior to 1.5.4 these tests were performed from png_set_gamma, 1.5.4 adds - * png_set_alpha_mode and this is another source for a default file gamma so - * the test needs to be performed later - here. In addition prior to 1.5.4 - * the tests were repeated for the PALETTE color type here - this is no - * longer necessary (and doesn't seem to have been necessary before.) - */ - { - /* The following temporary indicates if overall gamma correction is - * required. - */ - int gamma_correction = 0; - - if (png_ptr->gamma != 0) /* has been set */ - { - if (png_ptr->screen_gamma != 0) /* screen set too */ - gamma_correction = png_gamma_threshold(png_ptr->gamma, - png_ptr->screen_gamma); - - else - /* Assume the output matches the input; a long time default behavior - * of libpng, although the standard has nothing to say about this. - */ - png_ptr->screen_gamma = png_reciprocal(png_ptr->gamma); - } - - else if (png_ptr->screen_gamma != 0) - /* The converse - assume the file matches the screen, note that this - * perhaps undesireable default can (from 1.5.4) be changed by calling - * png_set_alpha_mode (even if the alpha handling mode isn't required - * or isn't changed from the default.) - */ - png_ptr->gamma = png_reciprocal(png_ptr->screen_gamma); - - else /* neither are set */ - /* Just in case the following prevents any processing - file and screen - * are both assumed to be linear and there is no way to introduce a - * third gamma value other than png_set_background with 'UNIQUE', and, - * prior to 1.5.4 - */ - png_ptr->screen_gamma = png_ptr->gamma = PNG_FP_1; - - /* Now turn the gamma transformation on or off as appropriate. Notice - * that PNG_GAMMA just refers to the file->screen correction. Alpha - * composition may independently cause gamma correction because it needs - * linear data (e.g. if the file has a gAMA chunk but the screen gamma - * hasn't been specified.) In any case this flag may get turned off in - * the code immediately below if the transform can be handled outside the - * row loop. - */ - if (gamma_correction) - png_ptr->transformations |= PNG_GAMMA; - - else - png_ptr->transformations &= ~PNG_GAMMA; - } -#endif - - /* Certain transformations have the effect of preventing other - * transformations that happen afterward in png_do_read_transformations, - * resolve the interdependencies here. From the code of - * png_do_read_transformations the order is: - * - * 1) PNG_EXPAND (including PNG_EXPAND_tRNS) - * 2) PNG_STRIP_ALPHA (if no compose) - * 3) PNG_RGB_TO_GRAY - * 4) PNG_GRAY_TO_RGB iff !PNG_BACKGROUND_IS_GRAY - * 5) PNG_COMPOSE - * 6) PNG_GAMMA - * 7) PNG_STRIP_ALPHA (if compose) - * 8) PNG_ENCODE_ALPHA - * 9) PNG_SCALE_16_TO_8 - * 10) PNG_16_TO_8 - * 11) PNG_QUANTIZE (converts to palette) - * 12) PNG_EXPAND_16 - * 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY - * 14) PNG_INVERT_MONO - * 15) PNG_SHIFT - * 16) PNG_PACK - * 17) PNG_BGR - * 18) PNG_PACKSWAP - * 19) PNG_FILLER (includes PNG_ADD_ALPHA) - * 20) PNG_INVERT_ALPHA - * 21) PNG_SWAP_ALPHA - * 22) PNG_SWAP_BYTES - * 23) PNG_USER_TRANSFORM [must be last] - */ -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED - if ((png_ptr->transformations & PNG_STRIP_ALPHA) && - !(png_ptr->transformations & PNG_COMPOSE)) - { - /* Stripping the alpha channel happens immediately after the 'expand' - * transformations, before all other transformation, so it cancels out - * the alpha handling. It has the side effect negating the effect of - * PNG_EXPAND_tRNS too: - */ - png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA | - PNG_EXPAND_tRNS); - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - - /* Kill the tRNS chunk itself too. Prior to 1.5.4 this did not happen - * so transparency information would remain just so long as it wasn't - * expanded. This produces unexpected API changes if the set of things - * that do PNG_EXPAND_tRNS changes (perfectly possible given the - * documentation - which says ask for what you want, accept what you - * get.) This makes the behavior consistent from 1.5.4: - */ - png_ptr->num_trans = 0; - } -#endif /* STRIP_ALPHA supported, no COMPOSE */ - -#ifdef PNG_READ_ALPHA_MODE_SUPPORTED - /* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA - * settings will have no effect. - */ - if (!png_gamma_significant(png_ptr->screen_gamma)) - { - png_ptr->transformations &= ~PNG_ENCODE_ALPHA; - png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; - } -#endif - -#if defined(PNG_READ_EXPAND_SUPPORTED) && \ - defined(PNG_READ_BACKGROUND_SUPPORTED) && \ - defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) - /* Detect gray background and attempt to enable optimization for - * gray --> RGB case. - * - * Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or - * RGB_ALPHA (in which case need_expand is superfluous anyway), the - * background color might actually be gray yet not be flagged as such. - * This is not a problem for the current code, which uses - * PNG_BACKGROUND_IS_GRAY only to decide when to do the - * png_do_gray_to_rgb() transformation. - * - * TODO: this code needs to be revised to avoid the complexity and - * interdependencies. The color type of the background should be recorded in - * png_set_background, along with the bit depth, then the code has a record - * of exactly what color space the background is currently in. - */ - if (png_ptr->transformations & PNG_BACKGROUND_EXPAND) - { - /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if - * the file was grayscale the background value is gray. - */ - if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) - png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; - } - - else if (png_ptr->transformations & PNG_COMPOSE) - { - /* PNG_COMPOSE: png_set_background was called with need_expand false, - * so the color is in the color space of the output or png_set_alpha_mode - * was called and the color is black. Ignore RGB_TO_GRAY because that - * happens before GRAY_TO_RGB. - */ - if (png_ptr->transformations & PNG_GRAY_TO_RGB) - { - if (png_ptr->background.red == png_ptr->background.green && - png_ptr->background.red == png_ptr->background.blue) - { - png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; - png_ptr->background.gray = png_ptr->background.red; - } - } - } -#endif /* PNG_READ_GRAY_TO_RGB_SUPPORTED (etc) */ - - /* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations - * can be performed directly on the palette, and some (such as rgb to gray) - * can be optimized inside the palette. This is particularly true of the - * composite (background and alpha) stuff, which can be pretty much all done - * in the palette even if the result is expanded to RGB or gray afterward. - * - * NOTE: this is Not Yet Implemented, the code behaves as in 1.5.1 and - * earlier and the palette stuff is actually handled on the first row. This - * leads to the reported bug that the palette returned by png_get_PLTE is not - * updated. - */ - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - png_init_palette_transformations(png_ptr); - - else - png_init_rgb_transformations(png_ptr); - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ - defined(PNG_READ_EXPAND_16_SUPPORTED) - if ((png_ptr->transformations & PNG_EXPAND_16) && - (png_ptr->transformations & PNG_COMPOSE) && - !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && - png_ptr->bit_depth != 16) - { - /* TODO: fix this. Because the expand_16 operation is after the compose - * handling the background color must be 8, not 16, bits deep, but the - * application will supply a 16-bit value so reduce it here. - * - * The PNG_BACKGROUND_EXPAND code above does not expand to 16 bits at - * present, so that case is ok (until do_expand_16 is moved.) - * - * NOTE: this discards the low 16 bits of the user supplied background - * color, but until expand_16 works properly there is no choice! - */ -# define CHOP(x) (x)=((png_uint_16)(((png_uint_32)(x)*255+32895) >> 16)) - CHOP(png_ptr->background.red); - CHOP(png_ptr->background.green); - CHOP(png_ptr->background.blue); - CHOP(png_ptr->background.gray); -# undef CHOP - } -#endif /* PNG_READ_BACKGROUND_SUPPORTED && PNG_READ_EXPAND_16_SUPPORTED */ - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ - (defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \ - defined(PNG_READ_STRIP_16_TO_8_SUPPORTED)) - if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) && - (png_ptr->transformations & PNG_COMPOSE) && - !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && - png_ptr->bit_depth == 16) - { - /* On the other hand, if a 16-bit file is to be reduced to 8-bits per - * component this will also happen after PNG_COMPOSE and so the background - * color must be pre-expanded here. - * - * TODO: fix this too. - */ - png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257); - png_ptr->background.green = - (png_uint_16)(png_ptr->background.green * 257); - png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257); - png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257); - } -#endif - - /* NOTE: below 'PNG_READ_ALPHA_MODE_SUPPORTED' is presumed to also enable the - * background support (see the comments in scripts/pnglibconf.dfa), this - * allows pre-multiplication of the alpha channel to be implemented as - * compositing on black. This is probably sub-optimal and has been done in - * 1.5.4 betas simply to enable external critique and testing (i.e. to - * implement the new API quickly, without lots of internal changes.) - */ - -#ifdef PNG_READ_GAMMA_SUPPORTED -# ifdef PNG_READ_BACKGROUND_SUPPORTED - /* Includes ALPHA_MODE */ - png_ptr->background_1 = png_ptr->background; -# endif - - /* This needs to change - in the palette image case a whole set of tables are - * built when it would be quicker to just calculate the correct value for - * each palette entry directly. Also, the test is too tricky - why check - * PNG_RGB_TO_GRAY if PNG_GAMMA is not set? The answer seems to be that - * PNG_GAMMA is cancelled even if the gamma is known? The test excludes the - * PNG_COMPOSE case, so apparently if there is no *overall* gamma correction - * the gamma tables will not be built even if composition is required on a - * gamma encoded value. - * - * In 1.5.4 this is addressed below by an additional check on the individual - * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the - * tables. - */ - if ((png_ptr->transformations & PNG_GAMMA) - || ((png_ptr->transformations & PNG_RGB_TO_GRAY) - && (png_gamma_significant(png_ptr->gamma) || - png_gamma_significant(png_ptr->screen_gamma))) - || ((png_ptr->transformations & PNG_COMPOSE) - && (png_gamma_significant(png_ptr->gamma) - || png_gamma_significant(png_ptr->screen_gamma) -# ifdef PNG_READ_BACKGROUND_SUPPORTED - || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE - && png_gamma_significant(png_ptr->background_gamma)) -# endif - )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) - && png_gamma_significant(png_ptr->screen_gamma)) - ) - { - png_build_gamma_table(png_ptr, png_ptr->bit_depth); - -#ifdef PNG_READ_BACKGROUND_SUPPORTED - if (png_ptr->transformations & PNG_COMPOSE) - { - /* Issue a warning about this combination: because RGB_TO_GRAY is - * optimized to do the gamma transform if present yet do_background has - * to do the same thing if both options are set a - * double-gamma-correction happens. This is true in all versions of - * libpng to date. - */ - if (png_ptr->transformations & PNG_RGB_TO_GRAY) - png_warning(png_ptr, - "libpng does not support gamma+background+rgb_to_gray"); - - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - /* We don't get to here unless there is a tRNS chunk with non-opaque - * entries - see the checking code at the start of this function. - */ - png_color back, back_1; - png_colorp palette = png_ptr->palette; - int num_palette = png_ptr->num_palette; - int i; - if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) - { - - back.red = png_ptr->gamma_table[png_ptr->background.red]; - back.green = png_ptr->gamma_table[png_ptr->background.green]; - back.blue = png_ptr->gamma_table[png_ptr->background.blue]; - - back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; - back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; - back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; - } - else - { - png_fixed_point g, gs; - - switch (png_ptr->background_gamma_type) - { - case PNG_BACKGROUND_GAMMA_SCREEN: - g = (png_ptr->screen_gamma); - gs = PNG_FP_1; - break; - - case PNG_BACKGROUND_GAMMA_FILE: - g = png_reciprocal(png_ptr->gamma); - gs = png_reciprocal2(png_ptr->gamma, - png_ptr->screen_gamma); - break; - - case PNG_BACKGROUND_GAMMA_UNIQUE: - g = png_reciprocal(png_ptr->background_gamma); - gs = png_reciprocal2(png_ptr->background_gamma, - png_ptr->screen_gamma); - break; - default: - g = PNG_FP_1; /* back_1 */ - gs = PNG_FP_1; /* back */ - break; - } - - if (png_gamma_significant(gs)) - { - back.red = png_gamma_8bit_correct(png_ptr->background.red, - gs); - back.green = png_gamma_8bit_correct(png_ptr->background.green, - gs); - back.blue = png_gamma_8bit_correct(png_ptr->background.blue, - gs); - } - - else - { - back.red = (png_byte)png_ptr->background.red; - back.green = (png_byte)png_ptr->background.green; - back.blue = (png_byte)png_ptr->background.blue; - } - - if (png_gamma_significant(g)) - { - back_1.red = png_gamma_8bit_correct(png_ptr->background.red, - g); - back_1.green = png_gamma_8bit_correct( - png_ptr->background.green, g); - back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue, - g); - } - - else - { - back_1.red = (png_byte)png_ptr->background.red; - back_1.green = (png_byte)png_ptr->background.green; - back_1.blue = (png_byte)png_ptr->background.blue; - } - } - - for (i = 0; i < num_palette; i++) - { - if (i < (int)png_ptr->num_trans && - png_ptr->trans_alpha[i] != 0xff) - { - if (png_ptr->trans_alpha[i] == 0) - { - palette[i] = back; - } - else /* if (png_ptr->trans_alpha[i] != 0xff) */ - { - png_byte v, w; - - v = png_ptr->gamma_to_1[palette[i].red]; - png_composite(w, v, png_ptr->trans_alpha[i], back_1.red); - palette[i].red = png_ptr->gamma_from_1[w]; - - v = png_ptr->gamma_to_1[palette[i].green]; - png_composite(w, v, png_ptr->trans_alpha[i], back_1.green); - palette[i].green = png_ptr->gamma_from_1[w]; - - v = png_ptr->gamma_to_1[palette[i].blue]; - png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue); - palette[i].blue = png_ptr->gamma_from_1[w]; - } - } - else - { - palette[i].red = png_ptr->gamma_table[palette[i].red]; - palette[i].green = png_ptr->gamma_table[palette[i].green]; - palette[i].blue = png_ptr->gamma_table[palette[i].blue]; - } - } - - /* Prevent the transformations being done again. - * - * NOTE: this is highly dubious; it removes the transformations in - * place. This seems inconsistent with the general treatment of the - * transformations elsewhere. - */ - png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA); - } /* color_type == PNG_COLOR_TYPE_PALETTE */ - - /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ - else /* color_type != PNG_COLOR_TYPE_PALETTE */ - { - int gs_sig, g_sig; - png_fixed_point g = PNG_FP_1; /* Correction to linear */ - png_fixed_point gs = PNG_FP_1; /* Correction to screen */ - - switch (png_ptr->background_gamma_type) - { - case PNG_BACKGROUND_GAMMA_SCREEN: - g = png_ptr->screen_gamma; - /* gs = PNG_FP_1; */ - break; - - case PNG_BACKGROUND_GAMMA_FILE: - g = png_reciprocal(png_ptr->gamma); - gs = png_reciprocal2(png_ptr->gamma, png_ptr->screen_gamma); - break; - - case PNG_BACKGROUND_GAMMA_UNIQUE: - g = png_reciprocal(png_ptr->background_gamma); - gs = png_reciprocal2(png_ptr->background_gamma, - png_ptr->screen_gamma); - break; - - default: - png_error(png_ptr, "invalid background gamma type"); - } - - g_sig = png_gamma_significant(g); - gs_sig = png_gamma_significant(gs); - - if (g_sig) - png_ptr->background_1.gray = png_gamma_correct(png_ptr, - png_ptr->background.gray, g); - - if (gs_sig) - png_ptr->background.gray = png_gamma_correct(png_ptr, - png_ptr->background.gray, gs); - - if ((png_ptr->background.red != png_ptr->background.green) || - (png_ptr->background.red != png_ptr->background.blue) || - (png_ptr->background.red != png_ptr->background.gray)) - { - /* RGB or RGBA with color background */ - if (g_sig) - { - png_ptr->background_1.red = png_gamma_correct(png_ptr, - png_ptr->background.red, g); - - png_ptr->background_1.green = png_gamma_correct(png_ptr, - png_ptr->background.green, g); - - png_ptr->background_1.blue = png_gamma_correct(png_ptr, - png_ptr->background.blue, g); - } - - if (gs_sig) - { - png_ptr->background.red = png_gamma_correct(png_ptr, - png_ptr->background.red, gs); - - png_ptr->background.green = png_gamma_correct(png_ptr, - png_ptr->background.green, gs); - - png_ptr->background.blue = png_gamma_correct(png_ptr, - png_ptr->background.blue, gs); - } - } - - else - { - /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ - png_ptr->background_1.red = png_ptr->background_1.green - = png_ptr->background_1.blue = png_ptr->background_1.gray; - - png_ptr->background.red = png_ptr->background.green - = png_ptr->background.blue = png_ptr->background.gray; - } - - /* The background is now in screen gamma: */ - png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN; - } /* color_type != PNG_COLOR_TYPE_PALETTE */ - }/* png_ptr->transformations & PNG_BACKGROUND */ - - else - /* Transformation does not include PNG_BACKGROUND */ -#endif /* PNG_READ_BACKGROUND_SUPPORTED */ - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - /* RGB_TO_GRAY needs to have non-gamma-corrected values! */ - && ((png_ptr->transformations & PNG_EXPAND) == 0 || - (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0) -#endif - ) - { - png_colorp palette = png_ptr->palette; - int num_palette = png_ptr->num_palette; - int i; - - /*NOTE: there are other transformations that should probably be in here - * too. - */ - for (i = 0; i < num_palette; i++) - { - palette[i].red = png_ptr->gamma_table[palette[i].red]; - palette[i].green = png_ptr->gamma_table[palette[i].green]; - palette[i].blue = png_ptr->gamma_table[palette[i].blue]; - } - - /* Done the gamma correction. */ - png_ptr->transformations &= ~PNG_GAMMA; - } /* color_type == PALETTE && !PNG_BACKGROUND transformation */ - } -#ifdef PNG_READ_BACKGROUND_SUPPORTED - else -#endif -#endif /* PNG_READ_GAMMA_SUPPORTED */ - -#ifdef PNG_READ_BACKGROUND_SUPPORTED - /* No GAMMA transformation (see the hanging else 4 lines above) */ - if ((png_ptr->transformations & PNG_COMPOSE) && - (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) - { - int i; - int istop = (int)png_ptr->num_trans; - png_color back; - png_colorp palette = png_ptr->palette; - - back.red = (png_byte)png_ptr->background.red; - back.green = (png_byte)png_ptr->background.green; - back.blue = (png_byte)png_ptr->background.blue; - - for (i = 0; i < istop; i++) - { - if (png_ptr->trans_alpha[i] == 0) - { - palette[i] = back; - } - - else if (png_ptr->trans_alpha[i] != 0xff) - { - /* The png_composite() macro is defined in png.h */ - png_composite(palette[i].red, palette[i].red, - png_ptr->trans_alpha[i], back.red); - - png_composite(palette[i].green, palette[i].green, - png_ptr->trans_alpha[i], back.green); - - png_composite(palette[i].blue, palette[i].blue, - png_ptr->trans_alpha[i], back.blue); - } - } - - png_ptr->transformations &= ~PNG_COMPOSE; - } -#endif /* PNG_READ_BACKGROUND_SUPPORTED */ - -#ifdef PNG_READ_SHIFT_SUPPORTED - if ((png_ptr->transformations & PNG_SHIFT) && - !(png_ptr->transformations & PNG_EXPAND) && - (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) - { - int i; - int istop = png_ptr->num_palette; - int shift = 8 - png_ptr->sig_bit.red; - - png_ptr->transformations &= ~PNG_SHIFT; - - /* significant bits can be in the range 1 to 7 for a meaninful result, if - * the number of significant bits is 0 then no shift is done (this is an - * error condition which is silently ignored.) - */ - if (shift > 0 && shift < 8) for (i=0; ipalette[i].red; - - component >>= shift; - png_ptr->palette[i].red = (png_byte)component; - } - - shift = 8 - png_ptr->sig_bit.green; - if (shift > 0 && shift < 8) for (i=0; ipalette[i].green; - - component >>= shift; - png_ptr->palette[i].green = (png_byte)component; - } - - shift = 8 - png_ptr->sig_bit.blue; - if (shift > 0 && shift < 8) for (i=0; ipalette[i].blue; - - component >>= shift; - png_ptr->palette[i].blue = (png_byte)component; - } - } -#endif /* PNG_READ_SHIFT_SUPPORTED */ -} - -/* Modify the info structure to reflect the transformations. The - * info should be updated so a PNG file could be written with it, - * assuming the transformations result in valid PNG data. - */ -void /* PRIVATE */ -png_read_transform_info(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_read_transform_info"); - -#ifdef PNG_READ_EXPAND_SUPPORTED - if (png_ptr->transformations & PNG_EXPAND) - { - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - /* This check must match what actually happens in - * png_do_expand_palette; if it ever checks the tRNS chunk to see if - * it is all opaque we must do the same (at present it does not.) - */ - if (png_ptr->num_trans > 0) - info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; - - else - info_ptr->color_type = PNG_COLOR_TYPE_RGB; - - info_ptr->bit_depth = 8; - info_ptr->num_trans = 0; - } - else - { - if (png_ptr->num_trans) - { - if (png_ptr->transformations & PNG_EXPAND_tRNS) - info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; - } - if (info_ptr->bit_depth < 8) - info_ptr->bit_depth = 8; - - info_ptr->num_trans = 0; - } - } -#endif - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ - defined(PNG_READ_ALPHA_MODE_SUPPORTED) - /* The following is almost certainly wrong unless the background value is in - * the screen space! - */ - if (png_ptr->transformations & PNG_COMPOSE) - info_ptr->background = png_ptr->background; -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED - /* The following used to be conditional on PNG_GAMMA (prior to 1.5.4), - * however it seems that the code in png_init_read_transformations, which has - * been called before this from png_read_update_info->png_read_start_row - * sometimes does the gamma transform and cancels the flag. - */ - info_ptr->gamma = png_ptr->gamma; -#endif - - if (info_ptr->bit_depth == 16) - { -# ifdef PNG_READ_16BIT_SUPPORTED -# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED - if (png_ptr->transformations & PNG_SCALE_16_TO_8) - info_ptr->bit_depth = 8; -# endif - -# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED - if (png_ptr->transformations & PNG_16_TO_8) - info_ptr->bit_depth = 8; -# endif - -# else - /* No 16 bit support: force chopping 16-bit input down to 8, in this case - * the app program can chose if both APIs are available by setting the - * correct scaling to use. - */ -# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED - /* For compatibility with previous versions use the strip method by - * default. This code works because if PNG_SCALE_16_TO_8 is already - * set the code below will do that in preference to the chop. - */ - png_ptr->transformations |= PNG_16_TO_8; - info_ptr->bit_depth = 8; -# else - -# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED - png_ptr->transformations |= PNG_SCALE_16_TO_8; - info_ptr->bit_depth = 8; -# else - - CONFIGURATION ERROR: you must enable at least one 16 to 8 method -# endif -# endif -#endif /* !READ_16BIT_SUPPORTED */ - } - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED - if (png_ptr->transformations & PNG_GRAY_TO_RGB) - info_ptr->color_type = (png_byte)(info_ptr->color_type | - PNG_COLOR_MASK_COLOR); -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - if (png_ptr->transformations & PNG_RGB_TO_GRAY) - info_ptr->color_type = (png_byte)(info_ptr->color_type & - ~PNG_COLOR_MASK_COLOR); -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED - if (png_ptr->transformations & PNG_QUANTIZE) - { - if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || - (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && - png_ptr->palette_lookup && info_ptr->bit_depth == 8) - { - info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; - } - } -#endif - -#ifdef PNG_READ_EXPAND_16_SUPPORTED - if (png_ptr->transformations & PNG_EXPAND_16 && info_ptr->bit_depth == 8 && - info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) - { - info_ptr->bit_depth = 16; - } -#endif - -#ifdef PNG_READ_PACK_SUPPORTED - if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) - info_ptr->bit_depth = 8; -#endif - - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - info_ptr->channels = 1; - - else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) - info_ptr->channels = 3; - - else - info_ptr->channels = 1; - -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED - if (png_ptr->transformations & PNG_STRIP_ALPHA) - { - info_ptr->color_type = (png_byte)(info_ptr->color_type & - ~PNG_COLOR_MASK_ALPHA); - info_ptr->num_trans = 0; - } -#endif - - if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) - info_ptr->channels++; - -#ifdef PNG_READ_FILLER_SUPPORTED - /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ - if ((png_ptr->transformations & PNG_FILLER) && - ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || - (info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) - { - info_ptr->channels++; - /* If adding a true alpha channel not just filler */ - if (png_ptr->transformations & PNG_ADD_ALPHA) - info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; - } -#endif - -#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ -defined(PNG_READ_USER_TRANSFORM_SUPPORTED) - if (png_ptr->transformations & PNG_USER_TRANSFORM) - { - if (info_ptr->bit_depth < png_ptr->user_transform_depth) - info_ptr->bit_depth = png_ptr->user_transform_depth; - - if (info_ptr->channels < png_ptr->user_transform_channels) - info_ptr->channels = png_ptr->user_transform_channels; - } -#endif - - info_ptr->pixel_depth = (png_byte)(info_ptr->channels * - info_ptr->bit_depth); - - info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width); - - /* Adding in 1.5.4: cache the above value in png_struct so that we can later - * check in png_rowbytes that the user buffer won't get overwritten. Note - * that the field is not always set - if png_read_update_info isn't called - * the application has to either not do any transforms or get the calculation - * right itself. - */ - png_ptr->info_rowbytes = info_ptr->rowbytes; - -#ifndef PNG_READ_EXPAND_SUPPORTED - if (png_ptr) - return; -#endif -} - -/* Transform the row. The order of transformations is significant, - * and is very touchy. If you add a transformation, take care to - * decide how it fits in with the other transformations here. - */ -void /* PRIVATE */ -png_do_read_transformations(png_structp png_ptr, png_row_infop row_info) -{ - png_debug(1, "in png_do_read_transformations"); - - if (png_ptr->row_buf == NULL) - { - /* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this - * error is incredibly rare and incredibly easy to debug without this - * information. - */ - png_error(png_ptr, "NULL row buffer"); - } - - /* The following is debugging; prior to 1.5.4 the code was never compiled in; - * in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro - * PNG_WARN_UNINITIALIZED_ROW removed. In 1.5 the new flag is set only for - * selected new APIs to ensure that there is no API change. - */ - if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 && - !(png_ptr->flags & PNG_FLAG_ROW_INIT)) - { - /* Application has failed to call either png_read_start_image() or - * png_read_update_info() after setting transforms that expand pixels. - * This check added to libpng-1.2.19 (but not enabled until 1.5.4). - */ - png_error(png_ptr, "Uninitialized row"); - } - -#ifdef PNG_READ_EXPAND_SUPPORTED - if (png_ptr->transformations & PNG_EXPAND) - { - if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) - { - png_do_expand_palette(row_info, png_ptr->row_buf + 1, - png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans); - } - - else - { - if (png_ptr->num_trans && - (png_ptr->transformations & PNG_EXPAND_tRNS)) - png_do_expand(row_info, png_ptr->row_buf + 1, - &(png_ptr->trans_color)); - - else - png_do_expand(row_info, png_ptr->row_buf + 1, - NULL); - } - } -#endif - -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED - if ((png_ptr->transformations & PNG_STRIP_ALPHA) && - !(png_ptr->transformations & PNG_COMPOSE) && - (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || - row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) - png_do_strip_channel(row_info, png_ptr->row_buf + 1, - 0 /* at_start == false, because SWAP_ALPHA happens later */); -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - if (png_ptr->transformations & PNG_RGB_TO_GRAY) - { - int rgb_error = - png_do_rgb_to_gray(png_ptr, row_info, - png_ptr->row_buf + 1); - - if (rgb_error) - { - png_ptr->rgb_to_gray_status=1; - if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == - PNG_RGB_TO_GRAY_WARN) - png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); - - if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == - PNG_RGB_TO_GRAY_ERR) - png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); - } - } -#endif - -/* From Andreas Dilger e-mail to png-implement, 26 March 1998: - * - * In most cases, the "simple transparency" should be done prior to doing - * gray-to-RGB, or you will have to test 3x as many bytes to check if a - * pixel is transparent. You would also need to make sure that the - * transparency information is upgraded to RGB. - * - * To summarize, the current flow is: - * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite - * with background "in place" if transparent, - * convert to RGB if necessary - * - Gray + alpha -> composite with gray background and remove alpha bytes, - * convert to RGB if necessary - * - * To support RGB backgrounds for gray images we need: - * - Gray + simple transparency -> convert to RGB + simple transparency, - * compare 3 or 6 bytes and composite with - * background "in place" if transparent - * (3x compare/pixel compared to doing - * composite with gray bkgrnd) - * - Gray + alpha -> convert to RGB + alpha, composite with background and - * remove alpha bytes (3x float - * operations/pixel compared with composite - * on gray background) - * - * Greg's change will do this. The reason it wasn't done before is for - * performance, as this increases the per-pixel operations. If we would check - * in advance if the background was gray or RGB, and position the gray-to-RGB - * transform appropriately, then it would save a lot of work/time. - */ - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED - /* If gray -> RGB, do so now only if background is non-gray; else do later - * for performance reasons - */ - if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && - !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) - png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); -#endif - -#if (defined PNG_READ_BACKGROUND_SUPPORTED) ||\ - (defined PNG_READ_ALPHA_MODE_SUPPORTED) - if (png_ptr->transformations & PNG_COMPOSE) - png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr); -#endif - -#ifdef PNG_READ_GAMMA_SUPPORTED - if ((png_ptr->transformations & PNG_GAMMA) && -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - /* Because RGB_TO_GRAY does the gamma transform. */ - !(png_ptr->transformations & PNG_RGB_TO_GRAY) && -#endif -#if (defined PNG_READ_BACKGROUND_SUPPORTED) ||\ - (defined PNG_READ_ALPHA_MODE_SUPPORTED) - /* Because PNG_COMPOSE does the gamma transform if there is something to - * do (if there is an alpha channel or transparency.) - */ - !((png_ptr->transformations & PNG_COMPOSE) && - ((png_ptr->num_trans != 0) || - (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && -#endif - /* Because png_init_read_transformations transforms the palette, unless - * RGB_TO_GRAY will do the transform. - */ - (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) - png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr); -#endif - -#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED - if ((png_ptr->transformations & PNG_STRIP_ALPHA) && - (png_ptr->transformations & PNG_COMPOSE) && - (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || - row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) - png_do_strip_channel(row_info, png_ptr->row_buf + 1, - 0 /* at_start == false, because SWAP_ALPHA happens later */); -#endif - -#ifdef PNG_READ_ALPHA_MODE_SUPPORTED - if ((png_ptr->transformations & PNG_ENCODE_ALPHA) && - (row_info->color_type & PNG_COLOR_MASK_ALPHA)) - png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr); -#endif - -#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED - if (png_ptr->transformations & PNG_SCALE_16_TO_8) - png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED - /* There is no harm in doing both of these because only one has any effect, - * by putting the 'scale' option first if the app asks for scale (either by - * calling the API or in a TRANSFORM flag) this is what happens. - */ - if (png_ptr->transformations & PNG_16_TO_8) - png_do_chop(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED - if (png_ptr->transformations & PNG_QUANTIZE) - { - png_do_quantize(row_info, png_ptr->row_buf + 1, - png_ptr->palette_lookup, png_ptr->quantize_index); - - if (row_info->rowbytes == 0) - png_error(png_ptr, "png_do_quantize returned rowbytes=0"); - } -#endif /* PNG_READ_QUANTIZE_SUPPORTED */ - -#ifdef PNG_READ_EXPAND_16_SUPPORTED - /* Do the expansion now, after all the arithmetic has been done. Notice - * that previous transformations can handle the PNG_EXPAND_16 flag if this - * is efficient (particularly true in the case of gamma correction, where - * better accuracy results faster!) - */ - if (png_ptr->transformations & PNG_EXPAND_16) - png_do_expand_16(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED - /*NOTE: moved here in 1.5.4 (from much later in this list.) */ - if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && - (png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) - png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_INVERT_SUPPORTED - if (png_ptr->transformations & PNG_INVERT_MONO) - png_do_invert(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_SHIFT_SUPPORTED - if (png_ptr->transformations & PNG_SHIFT) - png_do_unshift(row_info, png_ptr->row_buf + 1, - &(png_ptr->shift)); -#endif - -#ifdef PNG_READ_PACK_SUPPORTED - if (png_ptr->transformations & PNG_PACK) - png_do_unpack(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED - /* Added at libpng-1.5.10 */ - if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) - png_do_check_palette_indexes(png_ptr, row_info); -#endif - -#ifdef PNG_READ_BGR_SUPPORTED - if (png_ptr->transformations & PNG_BGR) - png_do_bgr(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_PACKSWAP_SUPPORTED - if (png_ptr->transformations & PNG_PACKSWAP) - png_do_packswap(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_FILLER_SUPPORTED - if (png_ptr->transformations & PNG_FILLER) - png_do_read_filler(row_info, png_ptr->row_buf + 1, - (png_uint_32)png_ptr->filler, png_ptr->flags); -#endif - -#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED - if (png_ptr->transformations & PNG_INVERT_ALPHA) - png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED - if (png_ptr->transformations & PNG_SWAP_ALPHA) - png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_READ_16BIT_SUPPORTED -#ifdef PNG_READ_SWAP_SUPPORTED - if (png_ptr->transformations & PNG_SWAP_BYTES) - png_do_swap(row_info, png_ptr->row_buf + 1); -#endif -#endif - -#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED - if (png_ptr->transformations & PNG_USER_TRANSFORM) - { - if (png_ptr->read_user_transform_fn != NULL) - (*(png_ptr->read_user_transform_fn)) /* User read transform function */ - (png_ptr, /* png_ptr */ - row_info, /* row_info: */ - /* png_uint_32 width; width of row */ - /* png_size_t rowbytes; number of bytes in row */ - /* png_byte color_type; color type of pixels */ - /* png_byte bit_depth; bit depth of samples */ - /* png_byte channels; number of channels (1-4) */ - /* png_byte pixel_depth; bits per pixel (depth*channels) */ - png_ptr->row_buf + 1); /* start of pixel data for row */ -#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED - if (png_ptr->user_transform_depth) - row_info->bit_depth = png_ptr->user_transform_depth; - - if (png_ptr->user_transform_channels) - row_info->channels = png_ptr->user_transform_channels; -#endif - row_info->pixel_depth = (png_byte)(row_info->bit_depth * - row_info->channels); - - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->width); - } -#endif -} - -#ifdef PNG_READ_PACK_SUPPORTED -/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, - * without changing the actual values. Thus, if you had a row with - * a bit depth of 1, you would end up with bytes that only contained - * the numbers 0 or 1. If you would rather they contain 0 and 255, use - * png_do_shift() after this. - */ -void /* PRIVATE */ -png_do_unpack(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_unpack"); - - if (row_info->bit_depth < 8) - { - png_uint_32 i; - png_uint_32 row_width=row_info->width; - - switch (row_info->bit_depth) - { - case 1: - { - png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); - png_bytep dp = row + (png_size_t)row_width - 1; - png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); - for (i = 0; i < row_width; i++) - { - *dp = (png_byte)((*sp >> shift) & 0x01); - - if (shift == 7) - { - shift = 0; - sp--; - } - - else - shift++; - - dp--; - } - break; - } - - case 2: - { - - png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); - png_bytep dp = row + (png_size_t)row_width - 1; - png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); - for (i = 0; i < row_width; i++) - { - *dp = (png_byte)((*sp >> shift) & 0x03); - - if (shift == 6) - { - shift = 0; - sp--; - } - - else - shift += 2; - - dp--; - } - break; - } - - case 4: - { - png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); - png_bytep dp = row + (png_size_t)row_width - 1; - png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); - for (i = 0; i < row_width; i++) - { - *dp = (png_byte)((*sp >> shift) & 0x0f); - - if (shift == 4) - { - shift = 0; - sp--; - } - - else - shift = 4; - - dp--; - } - break; - } - - default: - break; - } - row_info->bit_depth = 8; - row_info->pixel_depth = (png_byte)(8 * row_info->channels); - row_info->rowbytes = row_width * row_info->channels; - } -} -#endif - -#ifdef PNG_READ_SHIFT_SUPPORTED -/* Reverse the effects of png_do_shift. This routine merely shifts the - * pixels back to their significant bits values. Thus, if you have - * a row of bit depth 8, but only 5 are significant, this will shift - * the values back to 0 through 31. - */ -void /* PRIVATE */ -png_do_unshift(png_row_infop row_info, png_bytep row, - png_const_color_8p sig_bits) -{ - int color_type; - - png_debug(1, "in png_do_unshift"); - - /* The palette case has already been handled in the _init routine. */ - color_type = row_info->color_type; - - if (color_type != PNG_COLOR_TYPE_PALETTE) - { - int shift[4]; - int channels = 0; - int bit_depth = row_info->bit_depth; - - if (color_type & PNG_COLOR_MASK_COLOR) - { - shift[channels++] = bit_depth - sig_bits->red; - shift[channels++] = bit_depth - sig_bits->green; - shift[channels++] = bit_depth - sig_bits->blue; - } - - else - { - shift[channels++] = bit_depth - sig_bits->gray; - } - - if (color_type & PNG_COLOR_MASK_ALPHA) - { - shift[channels++] = bit_depth - sig_bits->alpha; - } - - { - int c, have_shift; - - for (c = have_shift = 0; c < channels; ++c) - { - /* A shift of more than the bit depth is an error condition but it - * gets ignored here. - */ - if (shift[c] <= 0 || shift[c] >= bit_depth) - shift[c] = 0; - - else - have_shift = 1; - } - - if (!have_shift) - return; - } - - switch (bit_depth) - { - default: - /* Must be 1bpp gray: should not be here! */ - /* NOTREACHED */ - break; - - case 2: - /* Must be 2bpp gray */ - /* assert(channels == 1 && shift[0] == 1) */ - { - png_bytep bp = row; - png_bytep bp_end = bp + row_info->rowbytes; - - while (bp < bp_end) - { - int b = (*bp >> 1) & 0x55; - *bp++ = (png_byte)b; - } - break; - } - - case 4: - /* Must be 4bpp gray */ - /* assert(channels == 1) */ - { - png_bytep bp = row; - png_bytep bp_end = bp + row_info->rowbytes; - int gray_shift = shift[0]; - int mask = 0xf >> gray_shift; - - mask |= mask << 4; - - while (bp < bp_end) - { - int b = (*bp >> gray_shift) & mask; - *bp++ = (png_byte)b; - } - break; - } - - case 8: - /* Single byte components, G, GA, RGB, RGBA */ - { - png_bytep bp = row; - png_bytep bp_end = bp + row_info->rowbytes; - int channel = 0; - - while (bp < bp_end) - { - int b = *bp >> shift[channel]; - if (++channel >= channels) - channel = 0; - *bp++ = (png_byte)b; - } - break; - } - -#ifdef PNG_READ_16BIT_SUPPORTED - case 16: - /* Double byte components, G, GA, RGB, RGBA */ - { - png_bytep bp = row; - png_bytep bp_end = bp + row_info->rowbytes; - int channel = 0; - - while (bp < bp_end) - { - int value = (bp[0] << 8) + bp[1]; - - value >>= shift[channel]; - if (++channel >= channels) - channel = 0; - *bp++ = (png_byte)(value >> 8); - *bp++ = (png_byte)(value & 0xff); - } - break; - } -#endif - } - } -} -#endif - -#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED -/* Scale rows of bit depth 16 down to 8 accurately */ -void /* PRIVATE */ -png_do_scale_16_to_8(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_scale_16_to_8"); - - if (row_info->bit_depth == 16) - { - png_bytep sp = row; /* source */ - png_bytep dp = row; /* destination */ - png_bytep ep = sp + row_info->rowbytes; /* end+1 */ - - while (sp < ep) - { - /* The input is an array of 16 bit components, these must be scaled to - * 8 bits each. For a 16 bit value V the required value (from the PNG - * specification) is: - * - * (V * 255) / 65535 - * - * This reduces to round(V / 257), or floor((V + 128.5)/257) - * - * Represent V as the two byte value vhi.vlo. Make a guess that the - * result is the top byte of V, vhi, then the correction to this value - * is: - * - * error = floor(((V-vhi.vhi) + 128.5) / 257) - * = floor(((vlo-vhi) + 128.5) / 257) - * - * This can be approximated using integer arithmetic (and a signed - * shift): - * - * error = (vlo-vhi+128) >> 8; - * - * The approximate differs from the exact answer only when (vlo-vhi) is - * 128; it then gives a correction of +1 when the exact correction is - * 0. This gives 128 errors. The exact answer (correct for all 16 bit - * input values) is: - * - * error = (vlo-vhi+128)*65535 >> 24; - * - * An alternative arithmetic calculation which also gives no errors is: - * - * (V * 255 + 32895) >> 16 - */ - - png_int_32 tmp = *sp++; /* must be signed! */ - tmp += (((int)*sp++ - tmp + 128) * 65535) >> 24; - *dp++ = (png_byte)tmp; - } - - row_info->bit_depth = 8; - row_info->pixel_depth = (png_byte)(8 * row_info->channels); - row_info->rowbytes = row_info->width * row_info->channels; - } -} -#endif - -#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED -void /* PRIVATE */ -/* Simply discard the low byte. This was the default behavior prior - * to libpng-1.5.4. - */ -png_do_chop(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_chop"); - - if (row_info->bit_depth == 16) - { - png_bytep sp = row; /* source */ - png_bytep dp = row; /* destination */ - png_bytep ep = sp + row_info->rowbytes; /* end+1 */ - - while (sp < ep) - { - *dp++ = *sp; - sp += 2; /* skip low byte */ - } - - row_info->bit_depth = 8; - row_info->pixel_depth = (png_byte)(8 * row_info->channels); - row_info->rowbytes = row_info->width * row_info->channels; - } -} -#endif - -#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED -void /* PRIVATE */ -png_do_read_swap_alpha(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_read_swap_alpha"); - - { - png_uint_32 row_width = row_info->width; - if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - { - /* This converts from RGBA to ARGB */ - if (row_info->bit_depth == 8) - { - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_byte save; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - save = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = save; - } - } - -#ifdef PNG_READ_16BIT_SUPPORTED - /* This converts from RRGGBBAA to AARRGGBB */ - else - { - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_byte save[2]; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - save[0] = *(--sp); - save[1] = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = save[0]; - *(--dp) = save[1]; - } - } -#endif - } - - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - { - /* This converts from GA to AG */ - if (row_info->bit_depth == 8) - { - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_byte save; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - save = *(--sp); - *(--dp) = *(--sp); - *(--dp) = save; - } - } - -#ifdef PNG_READ_16BIT_SUPPORTED - /* This converts from GGAA to AAGG */ - else - { - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_byte save[2]; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - save[0] = *(--sp); - save[1] = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = save[0]; - *(--dp) = save[1]; - } - } -#endif - } - } -} -#endif - -#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED -void /* PRIVATE */ -png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) -{ - png_uint_32 row_width; - png_debug(1, "in png_do_read_invert_alpha"); - - row_width = row_info->width; - if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This inverts the alpha channel in RGBA */ - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - *(--dp) = (png_byte)(255 - *(--sp)); - -/* This does nothing: - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - We can replace it with: -*/ - sp-=3; - dp=sp; - } - } - -#ifdef PNG_READ_16BIT_SUPPORTED - /* This inverts the alpha channel in RRGGBBAA */ - else - { - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - *(--dp) = (png_byte)(255 - *(--sp)); - *(--dp) = (png_byte)(255 - *(--sp)); - -/* This does nothing: - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - We can replace it with: -*/ - sp-=6; - dp=sp; - } - } -#endif - } - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This inverts the alpha channel in GA */ - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - *(--dp) = (png_byte)(255 - *(--sp)); - *(--dp) = *(--sp); - } - } - -#ifdef PNG_READ_16BIT_SUPPORTED - else - { - /* This inverts the alpha channel in GGAA */ - png_bytep sp = row + row_info->rowbytes; - png_bytep dp = sp; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - *(--dp) = (png_byte)(255 - *(--sp)); - *(--dp) = (png_byte)(255 - *(--sp)); -/* - *(--dp) = *(--sp); - *(--dp) = *(--sp); -*/ - sp-=2; - dp=sp; - } - } -#endif - } -} -#endif - -#ifdef PNG_READ_FILLER_SUPPORTED -/* Add filler channel if we have RGB color */ -void /* PRIVATE */ -png_do_read_filler(png_row_infop row_info, png_bytep row, - png_uint_32 filler, png_uint_32 flags) -{ - png_uint_32 i; - png_uint_32 row_width = row_info->width; - -#ifdef PNG_READ_16BIT_SUPPORTED - png_byte hi_filler = (png_byte)((filler>>8) & 0xff); -#endif - png_byte lo_filler = (png_byte)(filler & 0xff); - - png_debug(1, "in png_do_read_filler"); - - if ( - row_info->color_type == PNG_COLOR_TYPE_GRAY) - { - if (row_info->bit_depth == 8) - { - if (flags & PNG_FLAG_FILLER_AFTER) - { - /* This changes the data from G to GX */ - png_bytep sp = row + (png_size_t)row_width; - png_bytep dp = sp + (png_size_t)row_width; - for (i = 1; i < row_width; i++) - { - *(--dp) = lo_filler; - *(--dp) = *(--sp); - } - *(--dp) = lo_filler; - row_info->channels = 2; - row_info->pixel_depth = 16; - row_info->rowbytes = row_width * 2; - } - - else - { - /* This changes the data from G to XG */ - png_bytep sp = row + (png_size_t)row_width; - png_bytep dp = sp + (png_size_t)row_width; - for (i = 0; i < row_width; i++) - { - *(--dp) = *(--sp); - *(--dp) = lo_filler; - } - row_info->channels = 2; - row_info->pixel_depth = 16; - row_info->rowbytes = row_width * 2; - } - } - -#ifdef PNG_READ_16BIT_SUPPORTED - else if (row_info->bit_depth == 16) - { - if (flags & PNG_FLAG_FILLER_AFTER) - { - /* This changes the data from GG to GGXX */ - png_bytep sp = row + (png_size_t)row_width * 2; - png_bytep dp = sp + (png_size_t)row_width * 2; - for (i = 1; i < row_width; i++) - { - *(--dp) = hi_filler; - *(--dp) = lo_filler; - *(--dp) = *(--sp); - *(--dp) = *(--sp); - } - *(--dp) = hi_filler; - *(--dp) = lo_filler; - row_info->channels = 2; - row_info->pixel_depth = 32; - row_info->rowbytes = row_width * 4; - } - - else - { - /* This changes the data from GG to XXGG */ - png_bytep sp = row + (png_size_t)row_width * 2; - png_bytep dp = sp + (png_size_t)row_width * 2; - for (i = 0; i < row_width; i++) - { - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = hi_filler; - *(--dp) = lo_filler; - } - row_info->channels = 2; - row_info->pixel_depth = 32; - row_info->rowbytes = row_width * 4; - } - } -#endif - } /* COLOR_TYPE == GRAY */ - else if (row_info->color_type == PNG_COLOR_TYPE_RGB) - { - if (row_info->bit_depth == 8) - { - if (flags & PNG_FLAG_FILLER_AFTER) - { - /* This changes the data from RGB to RGBX */ - png_bytep sp = row + (png_size_t)row_width * 3; - png_bytep dp = sp + (png_size_t)row_width; - for (i = 1; i < row_width; i++) - { - *(--dp) = lo_filler; - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - } - *(--dp) = lo_filler; - row_info->channels = 4; - row_info->pixel_depth = 32; - row_info->rowbytes = row_width * 4; - } - - else - { - /* This changes the data from RGB to XRGB */ - png_bytep sp = row + (png_size_t)row_width * 3; - png_bytep dp = sp + (png_size_t)row_width; - for (i = 0; i < row_width; i++) - { - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = lo_filler; - } - row_info->channels = 4; - row_info->pixel_depth = 32; - row_info->rowbytes = row_width * 4; - } - } - -#ifdef PNG_READ_16BIT_SUPPORTED - else if (row_info->bit_depth == 16) - { - if (flags & PNG_FLAG_FILLER_AFTER) - { - /* This changes the data from RRGGBB to RRGGBBXX */ - png_bytep sp = row + (png_size_t)row_width * 6; - png_bytep dp = sp + (png_size_t)row_width * 2; - for (i = 1; i < row_width; i++) - { - *(--dp) = hi_filler; - *(--dp) = lo_filler; - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - } - *(--dp) = hi_filler; - *(--dp) = lo_filler; - row_info->channels = 4; - row_info->pixel_depth = 64; - row_info->rowbytes = row_width * 8; - } - - else - { - /* This changes the data from RRGGBB to XXRRGGBB */ - png_bytep sp = row + (png_size_t)row_width * 6; - png_bytep dp = sp + (png_size_t)row_width * 2; - for (i = 0; i < row_width; i++) - { - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = *(--sp); - *(--dp) = hi_filler; - *(--dp) = lo_filler; - } - - row_info->channels = 4; - row_info->pixel_depth = 64; - row_info->rowbytes = row_width * 8; - } - } -#endif - } /* COLOR_TYPE == RGB */ -} -#endif - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED -/* Expand grayscale files to RGB, with or without alpha */ -void /* PRIVATE */ -png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) -{ - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - png_debug(1, "in png_do_gray_to_rgb"); - - if (row_info->bit_depth >= 8 && - !(row_info->color_type & PNG_COLOR_MASK_COLOR)) - { - if (row_info->color_type == PNG_COLOR_TYPE_GRAY) - { - if (row_info->bit_depth == 8) - { - /* This changes G to RGB */ - png_bytep sp = row + (png_size_t)row_width - 1; - png_bytep dp = sp + (png_size_t)row_width * 2; - for (i = 0; i < row_width; i++) - { - *(dp--) = *sp; - *(dp--) = *sp; - *(dp--) = *(sp--); - } - } - - else - { - /* This changes GG to RRGGBB */ - png_bytep sp = row + (png_size_t)row_width * 2 - 1; - png_bytep dp = sp + (png_size_t)row_width * 4; - for (i = 0; i < row_width; i++) - { - *(dp--) = *sp; - *(dp--) = *(sp - 1); - *(dp--) = *sp; - *(dp--) = *(sp - 1); - *(dp--) = *(sp--); - *(dp--) = *(sp--); - } - } - } - - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This changes GA to RGBA */ - png_bytep sp = row + (png_size_t)row_width * 2 - 1; - png_bytep dp = sp + (png_size_t)row_width * 2; - for (i = 0; i < row_width; i++) - { - *(dp--) = *(sp--); - *(dp--) = *sp; - *(dp--) = *sp; - *(dp--) = *(sp--); - } - } - - else - { - /* This changes GGAA to RRGGBBAA */ - png_bytep sp = row + (png_size_t)row_width * 4 - 1; - png_bytep dp = sp + (png_size_t)row_width * 4; - for (i = 0; i < row_width; i++) - { - *(dp--) = *(sp--); - *(dp--) = *(sp--); - *(dp--) = *sp; - *(dp--) = *(sp - 1); - *(dp--) = *sp; - *(dp--) = *(sp - 1); - *(dp--) = *(sp--); - *(dp--) = *(sp--); - } - } - } - row_info->channels = (png_byte)(row_info->channels + 2); - row_info->color_type |= PNG_COLOR_MASK_COLOR; - row_info->pixel_depth = (png_byte)(row_info->channels * - row_info->bit_depth); - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); - } -} -#endif - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED -/* Reduce RGB files to grayscale, with or without alpha - * using the equation given in Poynton's ColorFAQ of 1998-01-04 at - * (THIS LINK IS DEAD June 2008 but - * versions dated 1998 through November 2002 have been archived at - * http://web.archive.org/web/20000816232553/http://www.inforamp.net/ - * ~poynton/notes/colour_and_gamma/ColorFAQ.txt ) - * Charles Poynton poynton at poynton.com - * - * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B - * - * which can be expressed with integers as - * - * Y = (6969 * R + 23434 * G + 2365 * B)/32768 - * - * Poynton's current link (as of January 2003 through July 2011): - * - * has changed the numbers slightly: - * - * Y = 0.2126*R + 0.7152*G + 0.0722*B - * - * which can be expressed with integers as - * - * Y = (6966 * R + 23436 * G + 2366 * B)/32768 - * - * Historically, however, libpng uses numbers derived from the ITU-R Rec 709 - * end point chromaticities and the D65 white point. Depending on the - * precision used for the D65 white point this produces a variety of different - * numbers, however if the four decimal place value used in ITU-R Rec 709 is - * used (0.3127,0.3290) the Y calculation would be: - * - * Y = (6968 * R + 23435 * G + 2366 * B)/32768 - * - * While this is correct the rounding results in an overflow for white, because - * the sum of the rounded coefficients is 32769, not 32768. Consequently - * libpng uses, instead, the closest non-overflowing approximation: - * - * Y = (6968 * R + 23434 * G + 2366 * B)/32768 - * - * Starting with libpng-1.5.5, if the image being converted has a cHRM chunk - * (including an sRGB chunk) then the chromaticities are used to calculate the - * coefficients. See the chunk handling in pngrutil.c for more information. - * - * In all cases the calculation is to be done in a linear colorspace. If no - * gamma information is available to correct the encoding of the original RGB - * values this results in an implicit assumption that the original PNG RGB - * values were linear. - * - * Other integer coefficents can be used via png_set_rgb_to_gray(). Because - * the API takes just red and green coefficients the blue coefficient is - * calculated to make the sum 32768. This will result in different rounding - * to that used above. - */ -int /* PRIVATE */ -png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row) - -{ - int rgb_error = 0; - - png_debug(1, "in png_do_rgb_to_gray"); - - if (!(row_info->color_type & PNG_COLOR_MASK_PALETTE) && - (row_info->color_type & PNG_COLOR_MASK_COLOR)) - { - PNG_CONST png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; - PNG_CONST png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; - PNG_CONST png_uint_32 bc = 32768 - rc - gc; - PNG_CONST png_uint_32 row_width = row_info->width; - PNG_CONST int have_alpha = - (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0; - - if (row_info->bit_depth == 8) - { -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - /* Notice that gamma to/from 1 are not necessarily inverses (if - * there is an overall gamma correction). Prior to 1.5.5 this code - * checked the linearized values for equality; this doesn't match - * the documentation, the original values must be checked. - */ - if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) - { - png_bytep sp = row; - png_bytep dp = row; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - png_byte red = *(sp++); - png_byte green = *(sp++); - png_byte blue = *(sp++); - - if (red != green || red != blue) - { - red = png_ptr->gamma_to_1[red]; - green = png_ptr->gamma_to_1[green]; - blue = png_ptr->gamma_to_1[blue]; - - rgb_error |= 1; - *(dp++) = png_ptr->gamma_from_1[ - (rc*red + gc*green + bc*blue + 16384)>>15]; - } - - else - { - /* If there is no overall correction the table will not be - * set. - */ - if (png_ptr->gamma_table != NULL) - red = png_ptr->gamma_table[red]; - - *(dp++) = red; - } - - if (have_alpha) - *(dp++) = *(sp++); - } - } - else -#endif - { - png_bytep sp = row; - png_bytep dp = row; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - png_byte red = *(sp++); - png_byte green = *(sp++); - png_byte blue = *(sp++); - - if (red != green || red != blue) - { - rgb_error |= 1; - /*NOTE: this is the historical approach which simply - * truncates the results. - */ - *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); - } - - else - *(dp++) = red; - - if (have_alpha) - *(dp++) = *(sp++); - } - } - } - - else /* RGB bit_depth == 16 */ - { -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_1 != NULL) - { - png_bytep sp = row; - png_bytep dp = row; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - png_uint_16 red, green, blue, w; - - red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; - green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; - blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; - - if (red == green && red == blue) - { - if (png_ptr->gamma_16_table != NULL) - w = png_ptr->gamma_16_table[(red&0xff) - >> png_ptr->gamma_shift][red>>8]; - - else - w = red; - } - - else - { - png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) - >> png_ptr->gamma_shift][red>>8]; - png_uint_16 green_1 = - png_ptr->gamma_16_to_1[(green&0xff) >> - png_ptr->gamma_shift][green>>8]; - png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) - >> png_ptr->gamma_shift][blue>>8]; - png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 - + bc*blue_1 + 16384)>>15); - w = png_ptr->gamma_16_from_1[(gray16&0xff) >> - png_ptr->gamma_shift][gray16 >> 8]; - rgb_error |= 1; - } - - *(dp++) = (png_byte)((w>>8) & 0xff); - *(dp++) = (png_byte)(w & 0xff); - - if (have_alpha) - { - *(dp++) = *(sp++); - *(dp++) = *(sp++); - } - } - } - else -#endif - { - png_bytep sp = row; - png_bytep dp = row; - png_uint_32 i; - - for (i = 0; i < row_width; i++) - { - png_uint_16 red, green, blue, gray16; - - red = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; - green = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; - blue = (png_uint_16)(((*(sp))<<8) | *(sp + 1)); sp += 2; - - if (red != green || red != blue) - rgb_error |= 1; - - /* From 1.5.5 in the 16 bit case do the accurate conversion even - * in the 'fast' case - this is because this is where the code - * ends up when handling linear 16 bit data. - */ - gray16 = (png_uint_16)((rc*red + gc*green + bc*blue + 16384) >> - 15); - *(dp++) = (png_byte)((gray16>>8) & 0xff); - *(dp++) = (png_byte)(gray16 & 0xff); - - if (have_alpha) - { - *(dp++) = *(sp++); - *(dp++) = *(sp++); - } - } - } - } - - row_info->channels = (png_byte)(row_info->channels - 2); - row_info->color_type = (png_byte)(row_info->color_type & - ~PNG_COLOR_MASK_COLOR); - row_info->pixel_depth = (png_byte)(row_info->channels * - row_info->bit_depth); - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); - } - return rgb_error; -} -#endif -#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ - -#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED -/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth - * large of png_color. This lets grayscale images be treated as - * paletted. Most useful for gamma correction and simplification - * of code. This API is not used internally. - */ -void PNGAPI -png_build_grayscale_palette(int bit_depth, png_colorp palette) -{ - int num_palette; - int color_inc; - int i; - int v; - - png_debug(1, "in png_do_build_grayscale_palette"); - - if (palette == NULL) - return; - - switch (bit_depth) - { - case 1: - num_palette = 2; - color_inc = 0xff; - break; - - case 2: - num_palette = 4; - color_inc = 0x55; - break; - - case 4: - num_palette = 16; - color_inc = 0x11; - break; - - case 8: - num_palette = 256; - color_inc = 1; - break; - - default: - num_palette = 0; - color_inc = 0; - break; - } - - for (i = 0, v = 0; i < num_palette; i++, v += color_inc) - { - palette[i].red = (png_byte)v; - palette[i].green = (png_byte)v; - palette[i].blue = (png_byte)v; - } -} -#endif - - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED -#if (defined PNG_READ_BACKGROUND_SUPPORTED) ||\ - (defined PNG_READ_ALPHA_MODE_SUPPORTED) -/* Replace any alpha or transparency with the supplied background color. - * "background" is already in the screen gamma, while "background_1" is - * at a gamma of 1.0. Paletted files have already been taken care of. - */ -void /* PRIVATE */ -png_do_compose(png_row_infop row_info, png_bytep row, png_structp png_ptr) -{ -#ifdef PNG_READ_GAMMA_SUPPORTED - png_const_bytep gamma_table = png_ptr->gamma_table; - png_const_bytep gamma_from_1 = png_ptr->gamma_from_1; - png_const_bytep gamma_to_1 = png_ptr->gamma_to_1; - png_const_uint_16pp gamma_16 = png_ptr->gamma_16_table; - png_const_uint_16pp gamma_16_from_1 = png_ptr->gamma_16_from_1; - png_const_uint_16pp gamma_16_to_1 = png_ptr->gamma_16_to_1; - int gamma_shift = png_ptr->gamma_shift; -#endif - - png_bytep sp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - int optimize = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0; - int shift; - - png_debug(1, "in png_do_compose"); - - { - switch (row_info->color_type) - { - case PNG_COLOR_TYPE_GRAY: - { - switch (row_info->bit_depth) - { - case 1: - { - sp = row; - shift = 7; - for (i = 0; i < row_width; i++) - { - if ((png_uint_16)((*sp >> shift) & 0x01) - == png_ptr->trans_color.gray) - { - *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); - *sp |= (png_byte)(png_ptr->background.gray << shift); - } - - if (!shift) - { - shift = 7; - sp++; - } - - else - shift--; - } - break; - } - - case 2: - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_table != NULL) - { - sp = row; - shift = 6; - for (i = 0; i < row_width; i++) - { - if ((png_uint_16)((*sp >> shift) & 0x03) - == png_ptr->trans_color.gray) - { - *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); - *sp |= (png_byte)(png_ptr->background.gray << shift); - } - - else - { - png_byte p = (png_byte)((*sp >> shift) & 0x03); - png_byte g = (png_byte)((gamma_table [p | (p << 2) | - (p << 4) | (p << 6)] >> 6) & 0x03); - *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); - *sp |= (png_byte)(g << shift); - } - - if (!shift) - { - shift = 6; - sp++; - } - - else - shift -= 2; - } - } - - else -#endif - { - sp = row; - shift = 6; - for (i = 0; i < row_width; i++) - { - if ((png_uint_16)((*sp >> shift) & 0x03) - == png_ptr->trans_color.gray) - { - *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); - *sp |= (png_byte)(png_ptr->background.gray << shift); - } - - if (!shift) - { - shift = 6; - sp++; - } - - else - shift -= 2; - } - } - break; - } - - case 4: - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_table != NULL) - { - sp = row; - shift = 4; - for (i = 0; i < row_width; i++) - { - if ((png_uint_16)((*sp >> shift) & 0x0f) - == png_ptr->trans_color.gray) - { - *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); - *sp |= (png_byte)(png_ptr->background.gray << shift); - } - - else - { - png_byte p = (png_byte)((*sp >> shift) & 0x0f); - png_byte g = (png_byte)((gamma_table[p | - (p << 4)] >> 4) & 0x0f); - *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); - *sp |= (png_byte)(g << shift); - } - - if (!shift) - { - shift = 4; - sp++; - } - - else - shift -= 4; - } - } - - else -#endif - { - sp = row; - shift = 4; - for (i = 0; i < row_width; i++) - { - if ((png_uint_16)((*sp >> shift) & 0x0f) - == png_ptr->trans_color.gray) - { - *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); - *sp |= (png_byte)(png_ptr->background.gray << shift); - } - - if (!shift) - { - shift = 4; - sp++; - } - - else - shift -= 4; - } - } - break; - } - - case 8: - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_table != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp++) - { - if (*sp == png_ptr->trans_color.gray) - *sp = (png_byte)png_ptr->background.gray; - - else - *sp = gamma_table[*sp]; - } - } - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp++) - { - if (*sp == png_ptr->trans_color.gray) - *sp = (png_byte)png_ptr->background.gray; - } - } - break; - } - - case 16: - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_16 != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 2) - { - png_uint_16 v; - - v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); - - if (v == png_ptr->trans_color.gray) - { - /* Background is already in screen gamma */ - *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); - } - - else - { - v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - } - } - } - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 2) - { - png_uint_16 v; - - v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); - - if (v == png_ptr->trans_color.gray) - { - *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); - } - } - } - break; - } - - default: - break; - } - break; - } - - case PNG_COLOR_TYPE_RGB: - { - if (row_info->bit_depth == 8) - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_table != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 3) - { - if (*sp == png_ptr->trans_color.red && - *(sp + 1) == png_ptr->trans_color.green && - *(sp + 2) == png_ptr->trans_color.blue) - { - *sp = (png_byte)png_ptr->background.red; - *(sp + 1) = (png_byte)png_ptr->background.green; - *(sp + 2) = (png_byte)png_ptr->background.blue; - } - - else - { - *sp = gamma_table[*sp]; - *(sp + 1) = gamma_table[*(sp + 1)]; - *(sp + 2) = gamma_table[*(sp + 2)]; - } - } - } - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 3) - { - if (*sp == png_ptr->trans_color.red && - *(sp + 1) == png_ptr->trans_color.green && - *(sp + 2) == png_ptr->trans_color.blue) - { - *sp = (png_byte)png_ptr->background.red; - *(sp + 1) = (png_byte)png_ptr->background.green; - *(sp + 2) = (png_byte)png_ptr->background.blue; - } - } - } - } - else /* if (row_info->bit_depth == 16) */ - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_16 != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 6) - { - png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); - - png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) - + *(sp + 3)); - - png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) - + *(sp + 5)); - - if (r == png_ptr->trans_color.red && - g == png_ptr->trans_color.green && - b == png_ptr->trans_color.blue) - { - /* Background is already in screen gamma */ - *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); - *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff); - *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff); - *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff); - *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); - } - - else - { - png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - - v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; - *(sp + 2) = (png_byte)((v >> 8) & 0xff); - *(sp + 3) = (png_byte)(v & 0xff); - - v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; - *(sp + 4) = (png_byte)((v >> 8) & 0xff); - *(sp + 5) = (png_byte)(v & 0xff); - } - } - } - - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 6) - { - png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); - - png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) - + *(sp + 3)); - - png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) - + *(sp + 5)); - - if (r == png_ptr->trans_color.red && - g == png_ptr->trans_color.green && - b == png_ptr->trans_color.blue) - { - *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); - *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff); - *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff); - *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff); - *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); - } - } - } - } - break; - } - - case PNG_COLOR_TYPE_GRAY_ALPHA: - { - if (row_info->bit_depth == 8) - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_to_1 != NULL && gamma_from_1 != NULL && - gamma_table != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 2) - { - png_uint_16 a = *(sp + 1); - - if (a == 0xff) - *sp = gamma_table[*sp]; - - else if (a == 0) - { - /* Background is already in screen gamma */ - *sp = (png_byte)png_ptr->background.gray; - } - - else - { - png_byte v, w; - - v = gamma_to_1[*sp]; - png_composite(w, v, a, png_ptr->background_1.gray); - if (!optimize) - w = gamma_from_1[w]; - *sp = w; - } - } - } - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 2) - { - png_byte a = *(sp + 1); - - if (a == 0) - *sp = (png_byte)png_ptr->background.gray; - - else if (a < 0xff) - png_composite(*sp, *sp, a, png_ptr->background_1.gray); - } - } - } - else /* if (png_ptr->bit_depth == 16) */ - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_16 != NULL && gamma_16_from_1 != NULL && - gamma_16_to_1 != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 4) - { - png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) - + *(sp + 3)); - - if (a == (png_uint_16)0xffff) - { - png_uint_16 v; - - v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - } - - else if (a == 0) - { - /* Background is already in screen gamma */ - *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); - } - - else - { - png_uint_16 g, v, w; - - g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; - png_composite_16(v, g, a, png_ptr->background_1.gray); - if (optimize) - w = v; - else - w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; - *sp = (png_byte)((w >> 8) & 0xff); - *(sp + 1) = (png_byte)(w & 0xff); - } - } - } - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 4) - { - png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) - + *(sp + 3)); - - if (a == 0) - { - *sp = (png_byte)((png_ptr->background.gray >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); - } - - else if (a < 0xffff) - { - png_uint_16 g, v; - - g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); - png_composite_16(v, g, a, png_ptr->background_1.gray); - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - } - } - } - } - break; - } - - case PNG_COLOR_TYPE_RGB_ALPHA: - { - if (row_info->bit_depth == 8) - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_to_1 != NULL && gamma_from_1 != NULL && - gamma_table != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 4) - { - png_byte a = *(sp + 3); - - if (a == 0xff) - { - *sp = gamma_table[*sp]; - *(sp + 1) = gamma_table[*(sp + 1)]; - *(sp + 2) = gamma_table[*(sp + 2)]; - } - - else if (a == 0) - { - /* Background is already in screen gamma */ - *sp = (png_byte)png_ptr->background.red; - *(sp + 1) = (png_byte)png_ptr->background.green; - *(sp + 2) = (png_byte)png_ptr->background.blue; - } - - else - { - png_byte v, w; - - v = gamma_to_1[*sp]; - png_composite(w, v, a, png_ptr->background_1.red); - if (!optimize) w = gamma_from_1[w]; - *sp = w; - - v = gamma_to_1[*(sp + 1)]; - png_composite(w, v, a, png_ptr->background_1.green); - if (!optimize) w = gamma_from_1[w]; - *(sp + 1) = w; - - v = gamma_to_1[*(sp + 2)]; - png_composite(w, v, a, png_ptr->background_1.blue); - if (!optimize) w = gamma_from_1[w]; - *(sp + 2) = w; - } - } - } - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 4) - { - png_byte a = *(sp + 3); - - if (a == 0) - { - *sp = (png_byte)png_ptr->background.red; - *(sp + 1) = (png_byte)png_ptr->background.green; - *(sp + 2) = (png_byte)png_ptr->background.blue; - } - - else if (a < 0xff) - { - png_composite(*sp, *sp, a, png_ptr->background.red); - - png_composite(*(sp + 1), *(sp + 1), a, - png_ptr->background.green); - - png_composite(*(sp + 2), *(sp + 2), a, - png_ptr->background.blue); - } - } - } - } - else /* if (row_info->bit_depth == 16) */ - { -#ifdef PNG_READ_GAMMA_SUPPORTED - if (gamma_16 != NULL && gamma_16_from_1 != NULL && - gamma_16_to_1 != NULL) - { - sp = row; - for (i = 0; i < row_width; i++, sp += 8) - { - png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) - << 8) + (png_uint_16)(*(sp + 7))); - - if (a == (png_uint_16)0xffff) - { - png_uint_16 v; - - v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - - v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; - *(sp + 2) = (png_byte)((v >> 8) & 0xff); - *(sp + 3) = (png_byte)(v & 0xff); - - v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; - *(sp + 4) = (png_byte)((v >> 8) & 0xff); - *(sp + 5) = (png_byte)(v & 0xff); - } - - else if (a == 0) - { - /* Background is already in screen gamma */ - *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); - *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff); - *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff); - *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff); - *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); - } - - else - { - png_uint_16 v, w; - - v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; - png_composite_16(w, v, a, png_ptr->background_1.red); - if (!optimize) - w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; - *sp = (png_byte)((w >> 8) & 0xff); - *(sp + 1) = (png_byte)(w & 0xff); - - v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; - png_composite_16(w, v, a, png_ptr->background_1.green); - if (!optimize) - w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; - - *(sp + 2) = (png_byte)((w >> 8) & 0xff); - *(sp + 3) = (png_byte)(w & 0xff); - - v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; - png_composite_16(w, v, a, png_ptr->background_1.blue); - if (!optimize) - w = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; - - *(sp + 4) = (png_byte)((w >> 8) & 0xff); - *(sp + 5) = (png_byte)(w & 0xff); - } - } - } - - else -#endif - { - sp = row; - for (i = 0; i < row_width; i++, sp += 8) - { - png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) - << 8) + (png_uint_16)(*(sp + 7))); - - if (a == 0) - { - *sp = (png_byte)((png_ptr->background.red >> 8) & 0xff); - *(sp + 1) = (png_byte)(png_ptr->background.red & 0xff); - *(sp + 2) = (png_byte)((png_ptr->background.green >> 8) & 0xff); - *(sp + 3) = (png_byte)(png_ptr->background.green & 0xff); - *(sp + 4) = (png_byte)((png_ptr->background.blue >> 8) & 0xff); - *(sp + 5) = (png_byte)(png_ptr->background.blue & 0xff); - } - - else if (a < 0xffff) - { - png_uint_16 v; - - png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); - png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) - + *(sp + 3)); - png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) - + *(sp + 5)); - - png_composite_16(v, r, a, png_ptr->background.red); - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - - png_composite_16(v, g, a, png_ptr->background.green); - *(sp + 2) = (png_byte)((v >> 8) & 0xff); - *(sp + 3) = (png_byte)(v & 0xff); - - png_composite_16(v, b, a, png_ptr->background.blue); - *(sp + 4) = (png_byte)((v >> 8) & 0xff); - *(sp + 5) = (png_byte)(v & 0xff); - } - } - } - } - break; - } - - default: - break; - } - } -} -#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_READ_ALPHA_MODE_SUPPORTED */ - -#ifdef PNG_READ_GAMMA_SUPPORTED -/* Gamma correct the image, avoiding the alpha channel. Make sure - * you do this after you deal with the transparency issue on grayscale - * or RGB images. If your bit depth is 8, use gamma_table, if it - * is 16, use gamma_16_table and gamma_shift. Build these with - * build_gamma_table(). - */ -void /* PRIVATE */ -png_do_gamma(png_row_infop row_info, png_bytep row, png_structp png_ptr) -{ - png_const_bytep gamma_table = png_ptr->gamma_table; - png_const_uint_16pp gamma_16_table = png_ptr->gamma_16_table; - int gamma_shift = png_ptr->gamma_shift; - - png_bytep sp; - png_uint_32 i; - png_uint_32 row_width=row_info->width; - - png_debug(1, "in png_do_gamma"); - - if (((row_info->bit_depth <= 8 && gamma_table != NULL) || - (row_info->bit_depth == 16 && gamma_16_table != NULL))) - { - switch (row_info->color_type) - { - case PNG_COLOR_TYPE_RGB: - { - if (row_info->bit_depth == 8) - { - sp = row; - for (i = 0; i < row_width; i++) - { - *sp = gamma_table[*sp]; - sp++; - *sp = gamma_table[*sp]; - sp++; - *sp = gamma_table[*sp]; - sp++; - } - } - - else /* if (row_info->bit_depth == 16) */ - { - sp = row; - for (i = 0; i < row_width; i++) - { - png_uint_16 v; - - v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 2; - - v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 2; - - v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 2; - } - } - break; - } - - case PNG_COLOR_TYPE_RGB_ALPHA: - { - if (row_info->bit_depth == 8) - { - sp = row; - for (i = 0; i < row_width; i++) - { - *sp = gamma_table[*sp]; - sp++; - - *sp = gamma_table[*sp]; - sp++; - - *sp = gamma_table[*sp]; - sp++; - - sp++; - } - } - - else /* if (row_info->bit_depth == 16) */ - { - sp = row; - for (i = 0; i < row_width; i++) - { - png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 2; - - v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 2; - - v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 4; - } - } - break; - } - - case PNG_COLOR_TYPE_GRAY_ALPHA: - { - if (row_info->bit_depth == 8) - { - sp = row; - for (i = 0; i < row_width; i++) - { - *sp = gamma_table[*sp]; - sp += 2; - } - } - - else /* if (row_info->bit_depth == 16) */ - { - sp = row; - for (i = 0; i < row_width; i++) - { - png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 4; - } - } - break; - } - - case PNG_COLOR_TYPE_GRAY: - { - if (row_info->bit_depth == 2) - { - sp = row; - for (i = 0; i < row_width; i += 4) - { - int a = *sp & 0xc0; - int b = *sp & 0x30; - int c = *sp & 0x0c; - int d = *sp & 0x03; - - *sp = (png_byte)( - ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| - ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| - ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| - ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); - sp++; - } - } - - if (row_info->bit_depth == 4) - { - sp = row; - for (i = 0; i < row_width; i += 2) - { - int msb = *sp & 0xf0; - int lsb = *sp & 0x0f; - - *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0) - | (((int)gamma_table[(lsb << 4) | lsb]) >> 4)); - sp++; - } - } - - else if (row_info->bit_depth == 8) - { - sp = row; - for (i = 0; i < row_width; i++) - { - *sp = gamma_table[*sp]; - sp++; - } - } - - else if (row_info->bit_depth == 16) - { - sp = row; - for (i = 0; i < row_width; i++) - { - png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; - *sp = (png_byte)((v >> 8) & 0xff); - *(sp + 1) = (png_byte)(v & 0xff); - sp += 2; - } - } - break; - } - - default: - break; - } - } -} -#endif - -#ifdef PNG_READ_ALPHA_MODE_SUPPORTED -/* Encode the alpha channel to the output gamma (the input channel is always - * linear.) Called only with color types that have an alpha channel. Needs the - * from_1 tables. - */ -void /* PRIVATE */ -png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structp png_ptr) -{ - png_uint_32 row_width = row_info->width; - - png_debug(1, "in png_do_encode_alpha"); - - if (row_info->color_type & PNG_COLOR_MASK_ALPHA) - { - if (row_info->bit_depth == 8) - { - PNG_CONST png_bytep table = png_ptr->gamma_from_1; - - if (table != NULL) - { - PNG_CONST int step = - (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2; - - /* The alpha channel is the last component: */ - row += step - 1; - - for (; row_width > 0; --row_width, row += step) - *row = table[*row]; - - return; - } - } - - else if (row_info->bit_depth == 16) - { - PNG_CONST png_uint_16pp table = png_ptr->gamma_16_from_1; - PNG_CONST int gamma_shift = png_ptr->gamma_shift; - - if (table != NULL) - { - PNG_CONST int step = - (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4; - - /* The alpha channel is the last component: */ - row += step - 2; - - for (; row_width > 0; --row_width, row += step) - { - png_uint_16 v; - - v = table[*(row + 1) >> gamma_shift][*row]; - *row = (png_byte)((v >> 8) & 0xff); - *(row + 1) = (png_byte)(v & 0xff); - } - - return; - } - } - } - - /* Only get to here if called with a weird row_info; no harm has been done, - * so just issue a warning. - */ - png_warning(png_ptr, "png_do_encode_alpha: unexpected call"); -} -#endif - -#ifdef PNG_READ_EXPAND_SUPPORTED -/* Expands a palette row to an RGB or RGBA row depending - * upon whether you supply trans and num_trans. - */ -void /* PRIVATE */ -png_do_expand_palette(png_row_infop row_info, png_bytep row, - png_const_colorp palette, png_const_bytep trans_alpha, int num_trans) -{ - int shift, value; - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width=row_info->width; - - png_debug(1, "in png_do_expand_palette"); - - if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) - { - if (row_info->bit_depth < 8) - { - switch (row_info->bit_depth) - { - case 1: - { - sp = row + (png_size_t)((row_width - 1) >> 3); - dp = row + (png_size_t)row_width - 1; - shift = 7 - (int)((row_width + 7) & 0x07); - for (i = 0; i < row_width; i++) - { - if ((*sp >> shift) & 0x01) - *dp = 1; - - else - *dp = 0; - - if (shift == 7) - { - shift = 0; - sp--; - } - - else - shift++; - - dp--; - } - break; - } - - case 2: - { - sp = row + (png_size_t)((row_width - 1) >> 2); - dp = row + (png_size_t)row_width - 1; - shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); - for (i = 0; i < row_width; i++) - { - value = (*sp >> shift) & 0x03; - *dp = (png_byte)value; - if (shift == 6) - { - shift = 0; - sp--; - } - - else - shift += 2; - - dp--; - } - break; - } - - case 4: - { - sp = row + (png_size_t)((row_width - 1) >> 1); - dp = row + (png_size_t)row_width - 1; - shift = (int)((row_width & 0x01) << 2); - for (i = 0; i < row_width; i++) - { - value = (*sp >> shift) & 0x0f; - *dp = (png_byte)value; - if (shift == 4) - { - shift = 0; - sp--; - } - - else - shift += 4; - - dp--; - } - break; - } - - default: - break; - } - row_info->bit_depth = 8; - row_info->pixel_depth = 8; - row_info->rowbytes = row_width; - } - - if (row_info->bit_depth == 8) - { - { - if (num_trans > 0) - { - sp = row + (png_size_t)row_width - 1; - dp = row + (png_size_t)(row_width << 2) - 1; - - for (i = 0; i < row_width; i++) - { - if ((int)(*sp) >= num_trans) - *dp-- = 0xff; - - else - *dp-- = trans_alpha[*sp]; - - *dp-- = palette[*sp].blue; - *dp-- = palette[*sp].green; - *dp-- = palette[*sp].red; - sp--; - } - row_info->bit_depth = 8; - row_info->pixel_depth = 32; - row_info->rowbytes = row_width * 4; - row_info->color_type = 6; - row_info->channels = 4; - } - - else - { - sp = row + (png_size_t)row_width - 1; - dp = row + (png_size_t)(row_width * 3) - 1; - - for (i = 0; i < row_width; i++) - { - *dp-- = palette[*sp].blue; - *dp-- = palette[*sp].green; - *dp-- = palette[*sp].red; - sp--; - } - - row_info->bit_depth = 8; - row_info->pixel_depth = 24; - row_info->rowbytes = row_width * 3; - row_info->color_type = 2; - row_info->channels = 3; - } - } - } - } -} - -/* If the bit depth < 8, it is expanded to 8. Also, if the already - * expanded transparency value is supplied, an alpha channel is built. - */ -void /* PRIVATE */ -png_do_expand(png_row_infop row_info, png_bytep row, - png_const_color_16p trans_color) -{ - int shift, value; - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width=row_info->width; - - png_debug(1, "in png_do_expand"); - - { - if (row_info->color_type == PNG_COLOR_TYPE_GRAY) - { - png_uint_16 gray = (png_uint_16)(trans_color ? trans_color->gray : 0); - - if (row_info->bit_depth < 8) - { - switch (row_info->bit_depth) - { - case 1: - { - gray = (png_uint_16)((gray & 0x01) * 0xff); - sp = row + (png_size_t)((row_width - 1) >> 3); - dp = row + (png_size_t)row_width - 1; - shift = 7 - (int)((row_width + 7) & 0x07); - for (i = 0; i < row_width; i++) - { - if ((*sp >> shift) & 0x01) - *dp = 0xff; - - else - *dp = 0; - - if (shift == 7) - { - shift = 0; - sp--; - } - - else - shift++; - - dp--; - } - break; - } - - case 2: - { - gray = (png_uint_16)((gray & 0x03) * 0x55); - sp = row + (png_size_t)((row_width - 1) >> 2); - dp = row + (png_size_t)row_width - 1; - shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); - for (i = 0; i < row_width; i++) - { - value = (*sp >> shift) & 0x03; - *dp = (png_byte)(value | (value << 2) | (value << 4) | - (value << 6)); - if (shift == 6) - { - shift = 0; - sp--; - } - - else - shift += 2; - - dp--; - } - break; - } - - case 4: - { - gray = (png_uint_16)((gray & 0x0f) * 0x11); - sp = row + (png_size_t)((row_width - 1) >> 1); - dp = row + (png_size_t)row_width - 1; - shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); - for (i = 0; i < row_width; i++) - { - value = (*sp >> shift) & 0x0f; - *dp = (png_byte)(value | (value << 4)); - if (shift == 4) - { - shift = 0; - sp--; - } - - else - shift = 4; - - dp--; - } - break; - } - - default: - break; - } - - row_info->bit_depth = 8; - row_info->pixel_depth = 8; - row_info->rowbytes = row_width; - } - - if (trans_color != NULL) - { - if (row_info->bit_depth == 8) - { - gray = gray & 0xff; - sp = row + (png_size_t)row_width - 1; - dp = row + (png_size_t)(row_width << 1) - 1; - - for (i = 0; i < row_width; i++) - { - if (*sp == gray) - *dp-- = 0; - - else - *dp-- = 0xff; - - *dp-- = *sp--; - } - } - - else if (row_info->bit_depth == 16) - { - png_byte gray_high = (png_byte)((gray >> 8) & 0xff); - png_byte gray_low = (png_byte)(gray & 0xff); - sp = row + row_info->rowbytes - 1; - dp = row + (row_info->rowbytes << 1) - 1; - for (i = 0; i < row_width; i++) - { - if (*(sp - 1) == gray_high && *(sp) == gray_low) - { - *dp-- = 0; - *dp-- = 0; - } - - else - { - *dp-- = 0xff; - *dp-- = 0xff; - } - - *dp-- = *sp--; - *dp-- = *sp--; - } - } - - row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; - row_info->channels = 2; - row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, - row_width); - } - } - else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_color) - { - if (row_info->bit_depth == 8) - { - png_byte red = (png_byte)(trans_color->red & 0xff); - png_byte green = (png_byte)(trans_color->green & 0xff); - png_byte blue = (png_byte)(trans_color->blue & 0xff); - sp = row + (png_size_t)row_info->rowbytes - 1; - dp = row + (png_size_t)(row_width << 2) - 1; - for (i = 0; i < row_width; i++) - { - if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue) - *dp-- = 0; - - else - *dp-- = 0xff; - - *dp-- = *sp--; - *dp-- = *sp--; - *dp-- = *sp--; - } - } - else if (row_info->bit_depth == 16) - { - png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff); - png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff); - png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff); - png_byte red_low = (png_byte)(trans_color->red & 0xff); - png_byte green_low = (png_byte)(trans_color->green & 0xff); - png_byte blue_low = (png_byte)(trans_color->blue & 0xff); - sp = row + row_info->rowbytes - 1; - dp = row + (png_size_t)(row_width << 3) - 1; - for (i = 0; i < row_width; i++) - { - if (*(sp - 5) == red_high && - *(sp - 4) == red_low && - *(sp - 3) == green_high && - *(sp - 2) == green_low && - *(sp - 1) == blue_high && - *(sp ) == blue_low) - { - *dp-- = 0; - *dp-- = 0; - } - - else - { - *dp-- = 0xff; - *dp-- = 0xff; - } - - *dp-- = *sp--; - *dp-- = *sp--; - *dp-- = *sp--; - *dp-- = *sp--; - *dp-- = *sp--; - *dp-- = *sp--; - } - } - row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; - row_info->channels = 4; - row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); - } - } -} -#endif - -#ifdef PNG_READ_EXPAND_16_SUPPORTED -/* If the bit depth is 8 and the color type is not a palette type expand the - * whole row to 16 bits. Has no effect otherwise. - */ -void /* PRIVATE */ -png_do_expand_16(png_row_infop row_info, png_bytep row) -{ - if (row_info->bit_depth == 8 && - row_info->color_type != PNG_COLOR_TYPE_PALETTE) - { - /* The row have a sequence of bytes containing [0..255] and we need - * to turn it into another row containing [0..65535], to do this we - * calculate: - * - * (input / 255) * 65535 - * - * Which happens to be exactly input * 257 and this can be achieved - * simply by byte replication in place (copying backwards). - */ - png_byte *sp = row + row_info->rowbytes; /* source, last byte + 1 */ - png_byte *dp = sp + row_info->rowbytes; /* destination, end + 1 */ - while (dp > sp) - dp[-2] = dp[-1] = *--sp, dp -= 2; - - row_info->rowbytes *= 2; - row_info->bit_depth = 16; - row_info->pixel_depth = (png_byte)(row_info->channels * 16); - } -} -#endif - -#ifdef PNG_READ_QUANTIZE_SUPPORTED -void /* PRIVATE */ -png_do_quantize(png_row_infop row_info, png_bytep row, - png_const_bytep palette_lookup, png_const_bytep quantize_lookup) -{ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width=row_info->width; - - png_debug(1, "in png_do_quantize"); - - if (row_info->bit_depth == 8) - { - if (row_info->color_type == PNG_COLOR_TYPE_RGB && palette_lookup) - { - int r, g, b, p; - sp = row; - dp = row; - for (i = 0; i < row_width; i++) - { - r = *sp++; - g = *sp++; - b = *sp++; - - /* This looks real messy, but the compiler will reduce - * it down to a reasonable formula. For example, with - * 5 bits per color, we get: - * p = (((r >> 3) & 0x1f) << 10) | - * (((g >> 3) & 0x1f) << 5) | - * ((b >> 3) & 0x1f); - */ - p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) & - ((1 << PNG_QUANTIZE_RED_BITS) - 1)) << - (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | - (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & - ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << - (PNG_QUANTIZE_BLUE_BITS)) | - ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & - ((1 << PNG_QUANTIZE_BLUE_BITS) - 1)); - - *dp++ = palette_lookup[p]; - } - - row_info->color_type = PNG_COLOR_TYPE_PALETTE; - row_info->channels = 1; - row_info->pixel_depth = row_info->bit_depth; - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); - } - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && - palette_lookup != NULL) - { - int r, g, b, p; - sp = row; - dp = row; - for (i = 0; i < row_width; i++) - { - r = *sp++; - g = *sp++; - b = *sp++; - sp++; - - p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) & - ((1 << PNG_QUANTIZE_RED_BITS) - 1)) << - (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | - (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & - ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << - (PNG_QUANTIZE_BLUE_BITS)) | - ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & - ((1 << PNG_QUANTIZE_BLUE_BITS) - 1)); - - *dp++ = palette_lookup[p]; - } - - row_info->color_type = PNG_COLOR_TYPE_PALETTE; - row_info->channels = 1; - row_info->pixel_depth = row_info->bit_depth; - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); - } - - else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && - quantize_lookup) - { - sp = row; - - for (i = 0; i < row_width; i++, sp++) - { - *sp = quantize_lookup[*sp]; - } - } - } -} -#endif /* PNG_READ_QUANTIZE_SUPPORTED */ -#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ - -#ifdef PNG_MNG_FEATURES_SUPPORTED -/* Undoes intrapixel differencing */ -void /* PRIVATE */ -png_do_read_intrapixel(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_read_intrapixel"); - - if ( - (row_info->color_type & PNG_COLOR_MASK_COLOR)) - { - int bytes_per_pixel; - png_uint_32 row_width = row_info->width; - - if (row_info->bit_depth == 8) - { - png_bytep rp; - png_uint_32 i; - - if (row_info->color_type == PNG_COLOR_TYPE_RGB) - bytes_per_pixel = 3; - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - bytes_per_pixel = 4; - - else - return; - - for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) - { - *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff); - *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff); - } - } - else if (row_info->bit_depth == 16) - { - png_bytep rp; - png_uint_32 i; - - if (row_info->color_type == PNG_COLOR_TYPE_RGB) - bytes_per_pixel = 6; - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - bytes_per_pixel = 8; - - else - return; - - for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) - { - png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1); - png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3); - png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5); - png_uint_32 red = (s0 + s1 + 65536) & 0xffff; - png_uint_32 blue = (s2 + s1 + 65536) & 0xffff; - *(rp ) = (png_byte)((red >> 8) & 0xff); - *(rp + 1) = (png_byte)(red & 0xff); - *(rp + 4) = (png_byte)((blue >> 8) & 0xff); - *(rp + 5) = (png_byte)(blue & 0xff); - } - } - } -} -#endif /* PNG_MNG_FEATURES_SUPPORTED */ -#endif /* PNG_READ_SUPPORTED */ diff --git a/source/libpng/pngrutil.c b/source/libpng/pngrutil.c deleted file mode 100644 index b22b416..0000000 --- a/source/libpng/pngrutil.c +++ /dev/null @@ -1,4159 +0,0 @@ - -/* pngrutil.c - utilities to read a PNG file - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file contains routines that are only called from within - * libpng itself during the course of reading an image. - */ - -#include "pngpriv.h" - -#ifdef PNG_READ_SUPPORTED - -#define png_strtod(p,a,b) strtod(a,b) - -png_uint_32 PNGAPI -png_get_uint_31(png_structp png_ptr, png_const_bytep buf) -{ - png_uint_32 uval = png_get_uint_32(buf); - - if (uval > PNG_UINT_31_MAX) - png_error(png_ptr, "PNG unsigned integer out of range"); - - return (uval); -} - -#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_READ_cHRM_SUPPORTED) -/* The following is a variation on the above for use with the fixed - * point values used for gAMA and cHRM. Instead of png_error it - * issues a warning and returns (-1) - an invalid value because both - * gAMA and cHRM use *unsigned* integers for fixed point values. - */ -#define PNG_FIXED_ERROR (-1) - -static png_fixed_point /* PRIVATE */ -png_get_fixed_point(png_structp png_ptr, png_const_bytep buf) -{ - png_uint_32 uval = png_get_uint_32(buf); - - if (uval <= PNG_UINT_31_MAX) - return (png_fixed_point)uval; /* known to be in range */ - - /* The caller can turn off the warning by passing NULL. */ - if (png_ptr != NULL) - png_warning(png_ptr, "PNG fixed point integer out of range"); - - return PNG_FIXED_ERROR; -} -#endif - -#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED -/* NOTE: the read macros will obscure these definitions, so that if - * PNG_USE_READ_MACROS is set the library will not use them internally, - * but the APIs will still be available externally. - * - * The parentheses around "PNGAPI function_name" in the following three - * functions are necessary because they allow the macros to co-exist with - * these (unused but exported) functions. - */ - -/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ -png_uint_32 (PNGAPI -png_get_uint_32)(png_const_bytep buf) -{ - png_uint_32 uval = - ((png_uint_32)(*(buf )) << 24) + - ((png_uint_32)(*(buf + 1)) << 16) + - ((png_uint_32)(*(buf + 2)) << 8) + - ((png_uint_32)(*(buf + 3)) ) ; - - return uval; -} - -/* Grab a signed 32-bit integer from a buffer in big-endian format. The - * data is stored in the PNG file in two's complement format and there - * is no guarantee that a 'png_int_32' is exactly 32 bits, therefore - * the following code does a two's complement to native conversion. - */ -png_int_32 (PNGAPI -png_get_int_32)(png_const_bytep buf) -{ - png_uint_32 uval = png_get_uint_32(buf); - if ((uval & 0x80000000) == 0) /* non-negative */ - return uval; - - uval = (uval ^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */ - return -(png_int_32)uval; -} - -/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ -png_uint_16 (PNGAPI -png_get_uint_16)(png_const_bytep buf) -{ - /* ANSI-C requires an int value to accomodate at least 16 bits so this - * works and allows the compiler not to worry about possible narrowing - * on 32 bit systems. (Pre-ANSI systems did not make integers smaller - * than 16 bits either.) - */ - unsigned int val = - ((unsigned int)(*buf) << 8) + - ((unsigned int)(*(buf + 1))); - - return (png_uint_16)val; -} - -#endif /* PNG_READ_INT_FUNCTIONS_SUPPORTED */ - -/* Read and check the PNG file signature */ -void /* PRIVATE */ -png_read_sig(png_structp png_ptr, png_infop info_ptr) -{ - png_size_t num_checked, num_to_check; - - /* Exit if the user application does not expect a signature. */ - if (png_ptr->sig_bytes >= 8) - return; - - num_checked = png_ptr->sig_bytes; - num_to_check = 8 - num_checked; - -#ifdef PNG_IO_STATE_SUPPORTED - png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE; -#endif - - /* The signature must be serialized in a single I/O call. */ - png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); - png_ptr->sig_bytes = 8; - - if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) - { - if (num_checked < 4 && - png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) - png_error(png_ptr, "Not a PNG file"); - else - png_error(png_ptr, "PNG file corrupted by ASCII conversion"); - } - if (num_checked < 3) - png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; -} - -/* Read the chunk header (length + type name). - * Put the type name into png_ptr->chunk_name, and return the length. - */ -png_uint_32 /* PRIVATE */ -png_read_chunk_header(png_structp png_ptr) -{ - png_byte buf[8]; - png_uint_32 length; - -#ifdef PNG_IO_STATE_SUPPORTED - png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR; -#endif - - /* Read the length and the chunk name. - * This must be performed in a single I/O call. - */ - png_read_data(png_ptr, buf, 8); - length = png_get_uint_31(png_ptr, buf); - - /* Put the chunk name into png_ptr->chunk_name. */ - png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4); - - png_debug2(0, "Reading %lx chunk, length = %lu", - (unsigned long)png_ptr->chunk_name, (unsigned long)length); - - /* Reset the crc and run it over the chunk name. */ - png_reset_crc(png_ptr); - png_calculate_crc(png_ptr, buf + 4, 4); - - /* Check to see if chunk name is valid. */ - png_check_chunk_name(png_ptr, png_ptr->chunk_name); - -#ifdef PNG_IO_STATE_SUPPORTED - png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA; -#endif - - return length; -} - -/* Read data, and (optionally) run it through the CRC. */ -void /* PRIVATE */ -png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) -{ - if (png_ptr == NULL) - return; - - png_read_data(png_ptr, buf, length); - png_calculate_crc(png_ptr, buf, length); -} - -/* Optionally skip data and then check the CRC. Depending on whether we - * are reading a ancillary or critical chunk, and how the program has set - * things up, we may calculate the CRC on the data and print a message. - * Returns '1' if there was a CRC error, '0' otherwise. - */ -int /* PRIVATE */ -png_crc_finish(png_structp png_ptr, png_uint_32 skip) -{ - png_size_t i; - png_size_t istop = png_ptr->zbuf_size; - - for (i = (png_size_t)skip; i > istop; i -= istop) - { - png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); - } - - if (i) - { - png_crc_read(png_ptr, png_ptr->zbuf, i); - } - - if (png_crc_error(png_ptr)) - { - if (PNG_CHUNK_ANCILLIARY(png_ptr->chunk_name) ? - !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) : - (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)) - { - png_chunk_warning(png_ptr, "CRC error"); - } - - else - { - png_chunk_benign_error(png_ptr, "CRC error"); - return (0); - } - - return (1); - } - - return (0); -} - -/* Compare the CRC stored in the PNG file with that calculated by libpng from - * the data it has read thus far. - */ -int /* PRIVATE */ -png_crc_error(png_structp png_ptr) -{ - png_byte crc_bytes[4]; - png_uint_32 crc; - int need_crc = 1; - - if (PNG_CHUNK_ANCILLIARY(png_ptr->chunk_name)) - { - if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == - (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) - need_crc = 0; - } - - else /* critical */ - { - if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) - need_crc = 0; - } - -#ifdef PNG_IO_STATE_SUPPORTED - png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC; -#endif - - /* The chunk CRC must be serialized in a single I/O call. */ - png_read_data(png_ptr, crc_bytes, 4); - - if (need_crc) - { - crc = png_get_uint_32(crc_bytes); - return ((int)(crc != png_ptr->crc)); - } - - else - return (0); -} - -#ifdef PNG_READ_COMPRESSED_TEXT_SUPPORTED -static png_size_t -png_inflate(png_structp png_ptr, png_bytep data, png_size_t size, - png_bytep output, png_size_t output_size) -{ - png_size_t count = 0; - - /* zlib can't necessarily handle more than 65535 bytes at once (i.e. it can't - * even necessarily handle 65536 bytes) because the type uInt is "16 bits or - * more". Consequently it is necessary to chunk the input to zlib. This - * code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the maximum value - * that can be stored in a uInt.) It is possible to set ZLIB_IO_MAX to a - * lower value in pngpriv.h and this may sometimes have a performance - * advantage, because it forces access of the input data to be separated from - * at least some of the use by some period of time. - */ - png_ptr->zstream.next_in = data; - /* avail_in is set below from 'size' */ - png_ptr->zstream.avail_in = 0; - - while (1) - { - int ret, avail; - - /* The setting of 'avail_in' used to be outside the loop; by setting it - * inside it is possible to chunk the input to zlib and simply rely on - * zlib to advance the 'next_in' pointer. This allows arbitrary amounts o - * data to be passed through zlib at the unavoidable cost of requiring a - * window save (memcpy of up to 32768 output bytes) every ZLIB_IO_MAX - * input bytes. - */ - if (png_ptr->zstream.avail_in == 0 && size > 0) - { - if (size <= ZLIB_IO_MAX) - { - /* The value is less than ZLIB_IO_MAX so the cast is safe: */ - png_ptr->zstream.avail_in = (uInt)size; - size = 0; - } - - else - { - png_ptr->zstream.avail_in = ZLIB_IO_MAX; - size -= ZLIB_IO_MAX; - } - } - - /* Reset the output buffer each time round - we empty it - * after every inflate call. - */ - png_ptr->zstream.next_out = png_ptr->zbuf; - png_ptr->zstream.avail_out = png_ptr->zbuf_size; - - ret = inflate(&png_ptr->zstream, Z_NO_FLUSH); - avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out; - - /* First copy/count any new output - but only if we didn't - * get an error code. - */ - if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0) - { - png_size_t space = avail; /* > 0, see above */ - - if (output != 0 && output_size > count) - { - png_size_t copy = output_size - count; - - if (space < copy) - copy = space; - - png_memcpy(output + count, png_ptr->zbuf, copy); - } - count += space; - } - - if (ret == Z_OK) - continue; - - /* Termination conditions - always reset the zstream, it - * must be left in inflateInit state. - */ - png_ptr->zstream.avail_in = 0; - inflateReset(&png_ptr->zstream); - - if (ret == Z_STREAM_END) - return count; /* NOTE: may be zero. */ - - /* Now handle the error codes - the API always returns 0 - * and the error message is dumped into the uncompressed - * buffer if available. - */ -# ifdef PNG_WARNINGS_SUPPORTED - { - png_const_charp msg; - - if (png_ptr->zstream.msg != 0) - msg = png_ptr->zstream.msg; - - else switch (ret) - { - case Z_BUF_ERROR: - msg = "Buffer error in compressed datastream"; - break; - - case Z_DATA_ERROR: - msg = "Data error in compressed datastream"; - break; - - default: - msg = "Incomplete compressed datastream"; - break; - } - - png_chunk_warning(png_ptr, msg); - } -# endif - - /* 0 means an error - notice that this code simply ignores - * zero length compressed chunks as a result. - */ - return 0; - } -} - -/* - * Decompress trailing data in a chunk. The assumption is that chunkdata - * points at an allocated area holding the contents of a chunk with a - * trailing compressed part. What we get back is an allocated area - * holding the original prefix part and an uncompressed version of the - * trailing part (the malloc area passed in is freed). - */ -void /* PRIVATE */ -png_decompress_chunk(png_structp png_ptr, int comp_type, - png_size_t chunklength, - png_size_t prefix_size, png_size_t *newlength) -{ - /* The caller should guarantee this */ - if (prefix_size > chunklength) - { - /* The recovery is to delete the chunk. */ - png_warning(png_ptr, "invalid chunklength"); - prefix_size = 0; /* To delete everything */ - } - - else if (comp_type == PNG_COMPRESSION_TYPE_BASE) - { - png_size_t expanded_size = png_inflate(png_ptr, - (png_bytep)(png_ptr->chunkdata + prefix_size), - chunklength - prefix_size, - 0, /* output */ - 0); /* output size */ - - /* Now check the limits on this chunk - if the limit fails the - * compressed data will be removed, the prefix will remain. - */ - if (prefix_size >= (~(png_size_t)0) - 1 || - expanded_size >= (~(png_size_t)0) - 1 - prefix_size -#ifdef PNG_USER_LIMITS_SUPPORTED - || (png_ptr->user_chunk_malloc_max && - (prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1)) -#else - || ((PNG_USER_CHUNK_MALLOC_MAX > 0) && - prefix_size + expanded_size >= PNG_USER_CHUNK_MALLOC_MAX - 1) -#endif - ) - png_warning(png_ptr, "Exceeded size limit while expanding chunk"); - - /* If the size is zero either there was an error and a message - * has already been output (warning) or the size really is zero - * and we have nothing to do - the code will exit through the - * error case below. - */ - else if (expanded_size > 0) - { - /* Success (maybe) - really uncompress the chunk. */ - png_size_t new_size = 0; - png_charp text = (png_charp)png_malloc_warn(png_ptr, - prefix_size + expanded_size + 1); - - if (text != NULL) - { - png_memcpy(text, png_ptr->chunkdata, prefix_size); - new_size = png_inflate(png_ptr, - (png_bytep)(png_ptr->chunkdata + prefix_size), - chunklength - prefix_size, - (png_bytep)(text + prefix_size), expanded_size); - text[prefix_size + expanded_size] = 0; /* just in case */ - - if (new_size == expanded_size) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = text; - *newlength = prefix_size + expanded_size; - return; /* The success return! */ - } - - png_warning(png_ptr, "png_inflate logic error"); - png_free(png_ptr, text); - } - - else - png_warning(png_ptr, "Not enough memory to decompress chunk"); - } - } - - else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ - { - PNG_WARNING_PARAMETERS(p) - png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d, comp_type); - png_formatted_warning(png_ptr, p, "Unknown compression type @1"); - - /* The recovery is to simply drop the data. */ - } - - /* Generic error return - leave the prefix, delete the compressed - * data, reallocate the chunkdata to remove the potentially large - * amount of compressed data. - */ - { - png_charp text = (png_charp)png_malloc_warn(png_ptr, prefix_size + 1); - - if (text != NULL) - { - if (prefix_size > 0) - png_memcpy(text, png_ptr->chunkdata, prefix_size); - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = text; - - /* This is an extra zero in the 'uncompressed' part. */ - *(png_ptr->chunkdata + prefix_size) = 0x00; - } - /* Ignore a malloc error here - it is safe. */ - } - - *newlength = prefix_size; -} -#endif /* PNG_READ_COMPRESSED_TEXT_SUPPORTED */ - -/* Read and check the IDHR chunk */ -void /* PRIVATE */ -png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_byte buf[13]; - png_uint_32 width, height; - int bit_depth, color_type, compression_type, filter_type; - int interlace_type; - - png_debug(1, "in png_handle_IHDR"); - - if (png_ptr->mode & PNG_HAVE_IHDR) - png_error(png_ptr, "Out of place IHDR"); - - /* Check the length */ - if (length != 13) - png_error(png_ptr, "Invalid IHDR chunk"); - - png_ptr->mode |= PNG_HAVE_IHDR; - - png_crc_read(png_ptr, buf, 13); - png_crc_finish(png_ptr, 0); - - width = png_get_uint_31(png_ptr, buf); - height = png_get_uint_31(png_ptr, buf + 4); - bit_depth = buf[8]; - color_type = buf[9]; - compression_type = buf[10]; - filter_type = buf[11]; - interlace_type = buf[12]; - - /* Set internal variables */ - png_ptr->width = width; - png_ptr->height = height; - png_ptr->bit_depth = (png_byte)bit_depth; - png_ptr->interlaced = (png_byte)interlace_type; - png_ptr->color_type = (png_byte)color_type; -#ifdef PNG_MNG_FEATURES_SUPPORTED - png_ptr->filter_type = (png_byte)filter_type; -#endif - png_ptr->compression_type = (png_byte)compression_type; - - /* Find number of channels */ - switch (png_ptr->color_type) - { - default: /* invalid, png_set_IHDR calls png_error */ - case PNG_COLOR_TYPE_GRAY: - case PNG_COLOR_TYPE_PALETTE: - png_ptr->channels = 1; - break; - - case PNG_COLOR_TYPE_RGB: - png_ptr->channels = 3; - break; - - case PNG_COLOR_TYPE_GRAY_ALPHA: - png_ptr->channels = 2; - break; - - case PNG_COLOR_TYPE_RGB_ALPHA: - png_ptr->channels = 4; - break; - } - - /* Set up other useful info */ - png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * - png_ptr->channels); - png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width); - png_debug1(3, "bit_depth = %d", png_ptr->bit_depth); - png_debug1(3, "channels = %d", png_ptr->channels); - png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes); - png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, - color_type, interlace_type, compression_type, filter_type); -} - -/* Read and check the palette */ -void /* PRIVATE */ -png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_color palette[PNG_MAX_PALETTE_LENGTH]; - int num, i; -#ifdef PNG_POINTER_INDEXING_SUPPORTED - png_colorp pal_ptr; -#endif - - png_debug(1, "in png_handle_PLTE"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before PLTE"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid PLTE after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->mode & PNG_HAVE_PLTE) - png_error(png_ptr, "Duplicate PLTE chunk"); - - png_ptr->mode |= PNG_HAVE_PLTE; - - if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) - { - png_warning(png_ptr, - "Ignoring PLTE chunk in grayscale PNG"); - png_crc_finish(png_ptr, length); - return; - } - -#ifndef PNG_READ_OPT_PLTE_SUPPORTED - if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) - { - png_crc_finish(png_ptr, length); - return; - } -#endif - - if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) - { - if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) - { - png_warning(png_ptr, "Invalid palette chunk"); - png_crc_finish(png_ptr, length); - return; - } - - else - { - png_error(png_ptr, "Invalid palette chunk"); - } - } - - num = (int)length / 3; - -#ifdef PNG_POINTER_INDEXING_SUPPORTED - for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) - { - png_byte buf[3]; - - png_crc_read(png_ptr, buf, 3); - pal_ptr->red = buf[0]; - pal_ptr->green = buf[1]; - pal_ptr->blue = buf[2]; - } -#else - for (i = 0; i < num; i++) - { - png_byte buf[3]; - - png_crc_read(png_ptr, buf, 3); - /* Don't depend upon png_color being any order */ - palette[i].red = buf[0]; - palette[i].green = buf[1]; - palette[i].blue = buf[2]; - } -#endif - - /* If we actually need the PLTE chunk (ie for a paletted image), we do - * whatever the normal CRC configuration tells us. However, if we - * have an RGB image, the PLTE can be considered ancillary, so - * we will act as though it is. - */ -#ifndef PNG_READ_OPT_PLTE_SUPPORTED - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -#endif - { - png_crc_finish(png_ptr, 0); - } - -#ifndef PNG_READ_OPT_PLTE_SUPPORTED - else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */ - { - /* If we don't want to use the data from an ancillary chunk, - * we have two options: an error abort, or a warning and we - * ignore the data in this chunk (which should be OK, since - * it's considered ancillary for a RGB or RGBA image). - */ - if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) - { - if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) - { - png_chunk_benign_error(png_ptr, "CRC error"); - } - - else - { - png_chunk_warning(png_ptr, "CRC error"); - return; - } - } - - /* Otherwise, we (optionally) emit a warning and use the chunk. */ - else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) - { - png_chunk_warning(png_ptr, "CRC error"); - } - } -#endif - - png_set_PLTE(png_ptr, info_ptr, palette, num); - -#ifdef PNG_READ_tRNS_SUPPORTED - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) - { - if (png_ptr->num_trans > (png_uint_16)num) - { - png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); - png_ptr->num_trans = (png_uint_16)num; - } - - if (info_ptr->num_trans > (png_uint_16)num) - { - png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); - info_ptr->num_trans = (png_uint_16)num; - } - } - } -#endif - -} - -void /* PRIVATE */ -png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_debug(1, "in png_handle_IEND"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) - { - png_error(png_ptr, "No image in file"); - } - - png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); - - if (length != 0) - { - png_warning(png_ptr, "Incorrect IEND chunk length"); - } - - png_crc_finish(png_ptr, length); - - PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */ -} - -#ifdef PNG_READ_gAMA_SUPPORTED -void /* PRIVATE */ -png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_fixed_point igamma; - png_byte buf[4]; - - png_debug(1, "in png_handle_gAMA"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before gAMA"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid gAMA after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->mode & PNG_HAVE_PLTE) - /* Should be an error, but we can cope with it */ - png_warning(png_ptr, "Out of place gAMA chunk"); - - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) -#ifdef PNG_READ_sRGB_SUPPORTED - && !(info_ptr->valid & PNG_INFO_sRGB) -#endif - ) - { - png_warning(png_ptr, "Duplicate gAMA chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (length != 4) - { - png_warning(png_ptr, "Incorrect gAMA chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 4); - - if (png_crc_finish(png_ptr, 0)) - return; - - igamma = png_get_fixed_point(NULL, buf); - - /* Check for zero gamma or an error. */ - if (igamma <= 0) - { - png_warning(png_ptr, - "Ignoring gAMA chunk with out of range gamma"); - - return; - } - -# ifdef PNG_READ_sRGB_SUPPORTED - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) - { - if (PNG_OUT_OF_RANGE(igamma, 45500, 500)) - { - PNG_WARNING_PARAMETERS(p) - png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_fixed, igamma); - png_formatted_warning(png_ptr, p, - "Ignoring incorrect gAMA value @1 when sRGB is also present"); - return; - } - } -# endif /* PNG_READ_sRGB_SUPPORTED */ - -# ifdef PNG_READ_GAMMA_SUPPORTED - /* Gamma correction on read is supported. */ - png_ptr->gamma = igamma; -# endif - /* And set the 'info' structure members. */ - png_set_gAMA_fixed(png_ptr, info_ptr, igamma); -} -#endif - -#ifdef PNG_READ_sBIT_SUPPORTED -void /* PRIVATE */ -png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_size_t truelen; - png_byte buf[4]; - - png_debug(1, "in png_handle_sBIT"); - - buf[0] = buf[1] = buf[2] = buf[3] = 0; - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before sBIT"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid sBIT after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->mode & PNG_HAVE_PLTE) - { - /* Should be an error, but we can cope with it */ - png_warning(png_ptr, "Out of place sBIT chunk"); - } - - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) - { - png_warning(png_ptr, "Duplicate sBIT chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - truelen = 3; - - else - truelen = (png_size_t)png_ptr->channels; - - if (length != truelen || length > 4) - { - png_warning(png_ptr, "Incorrect sBIT chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, truelen); - - if (png_crc_finish(png_ptr, 0)) - return; - - if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) - { - png_ptr->sig_bit.red = buf[0]; - png_ptr->sig_bit.green = buf[1]; - png_ptr->sig_bit.blue = buf[2]; - png_ptr->sig_bit.alpha = buf[3]; - } - - else - { - png_ptr->sig_bit.gray = buf[0]; - png_ptr->sig_bit.red = buf[0]; - png_ptr->sig_bit.green = buf[0]; - png_ptr->sig_bit.blue = buf[0]; - png_ptr->sig_bit.alpha = buf[1]; - } - - png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); -} -#endif - -#ifdef PNG_READ_cHRM_SUPPORTED -void /* PRIVATE */ -png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_byte buf[32]; - png_fixed_point x_white, y_white, x_red, y_red, x_green, y_green, x_blue, - y_blue; - - png_debug(1, "in png_handle_cHRM"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before cHRM"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid cHRM after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->mode & PNG_HAVE_PLTE) - /* Should be an error, but we can cope with it */ - png_warning(png_ptr, "Out of place cHRM chunk"); - - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) -# ifdef PNG_READ_sRGB_SUPPORTED - && !(info_ptr->valid & PNG_INFO_sRGB) -# endif - ) - { - png_warning(png_ptr, "Duplicate cHRM chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (length != 32) - { - png_warning(png_ptr, "Incorrect cHRM chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 32); - - if (png_crc_finish(png_ptr, 0)) - return; - - x_white = png_get_fixed_point(NULL, buf); - y_white = png_get_fixed_point(NULL, buf + 4); - x_red = png_get_fixed_point(NULL, buf + 8); - y_red = png_get_fixed_point(NULL, buf + 12); - x_green = png_get_fixed_point(NULL, buf + 16); - y_green = png_get_fixed_point(NULL, buf + 20); - x_blue = png_get_fixed_point(NULL, buf + 24); - y_blue = png_get_fixed_point(NULL, buf + 28); - - if (x_white == PNG_FIXED_ERROR || - y_white == PNG_FIXED_ERROR || - x_red == PNG_FIXED_ERROR || - y_red == PNG_FIXED_ERROR || - x_green == PNG_FIXED_ERROR || - y_green == PNG_FIXED_ERROR || - x_blue == PNG_FIXED_ERROR || - y_blue == PNG_FIXED_ERROR) - { - png_warning(png_ptr, "Ignoring cHRM chunk with negative chromaticities"); - return; - } - -#ifdef PNG_READ_sRGB_SUPPORTED - if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB)) - { - if (PNG_OUT_OF_RANGE(x_white, 31270, 1000) || - PNG_OUT_OF_RANGE(y_white, 32900, 1000) || - PNG_OUT_OF_RANGE(x_red, 64000, 1000) || - PNG_OUT_OF_RANGE(y_red, 33000, 1000) || - PNG_OUT_OF_RANGE(x_green, 30000, 1000) || - PNG_OUT_OF_RANGE(y_green, 60000, 1000) || - PNG_OUT_OF_RANGE(x_blue, 15000, 1000) || - PNG_OUT_OF_RANGE(y_blue, 6000, 1000)) - { - PNG_WARNING_PARAMETERS(p) - - png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_fixed, x_white); - png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_fixed, y_white); - png_warning_parameter_signed(p, 3, PNG_NUMBER_FORMAT_fixed, x_red); - png_warning_parameter_signed(p, 4, PNG_NUMBER_FORMAT_fixed, y_red); - png_warning_parameter_signed(p, 5, PNG_NUMBER_FORMAT_fixed, x_green); - png_warning_parameter_signed(p, 6, PNG_NUMBER_FORMAT_fixed, y_green); - png_warning_parameter_signed(p, 7, PNG_NUMBER_FORMAT_fixed, x_blue); - png_warning_parameter_signed(p, 8, PNG_NUMBER_FORMAT_fixed, y_blue); - - png_formatted_warning(png_ptr, p, - "Ignoring incorrect cHRM white(@1,@2) r(@3,@4)g(@5,@6)b(@7,@8) " - "when sRGB is also present"); - } - return; - } -#endif /* PNG_READ_sRGB_SUPPORTED */ - -#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - /* Store the _white values as default coefficients for the rgb to gray - * operation if it is supported. Check if the transform is already set to - * avoid destroying the transform values. - */ - if (!png_ptr->rgb_to_gray_coefficients_set) - { - /* png_set_background has not been called and we haven't seen an sRGB - * chunk yet. Find the XYZ of the three end points. - */ - png_XYZ XYZ; - png_xy xy; - - xy.redx = x_red; - xy.redy = y_red; - xy.greenx = x_green; - xy.greeny = y_green; - xy.bluex = x_blue; - xy.bluey = y_blue; - xy.whitex = x_white; - xy.whitey = y_white; - - if (png_XYZ_from_xy_checked(png_ptr, &XYZ, xy)) - { - /* The success case, because XYZ_from_xy normalises to a reference - * white Y of 1.0 we just need to scale the numbers. This should - * always work just fine. It is an internal error if this overflows. - */ - { - png_fixed_point r, g, b; - if (png_muldiv(&r, XYZ.redY, 32768, PNG_FP_1) && - r >= 0 && r <= 32768 && - png_muldiv(&g, XYZ.greenY, 32768, PNG_FP_1) && - g >= 0 && g <= 32768 && - png_muldiv(&b, XYZ.blueY, 32768, PNG_FP_1) && - b >= 0 && b <= 32768 && - r+g+b <= 32769) - { - /* We allow 0 coefficients here. r+g+b may be 32769 if two or - * all of the coefficients were rounded up. Handle this by - * reducing the *largest* coefficient by 1; this matches the - * approach used for the default coefficients in pngrtran.c - */ - int add = 0; - - if (r+g+b > 32768) - add = -1; - else if (r+g+b < 32768) - add = 1; - - if (add != 0) - { - if (g >= r && g >= b) - g += add; - else if (r >= g && r >= b) - r += add; - else - b += add; - } - - /* Check for an internal error. */ - if (r+g+b != 32768) - png_error(png_ptr, - "internal error handling cHRM coefficients"); - - png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r; - png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g; - } - - /* This is a png_error at present even though it could be ignored - - * it should never happen, but it is important that if it does, the - * bug is fixed. - */ - else - png_error(png_ptr, "internal error handling cHRM->XYZ"); - } - } - } -#endif - - png_set_cHRM_fixed(png_ptr, info_ptr, x_white, y_white, x_red, y_red, - x_green, y_green, x_blue, y_blue); -} -#endif - -#ifdef PNG_READ_sRGB_SUPPORTED -void /* PRIVATE */ -png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - int intent; - png_byte buf[1]; - - png_debug(1, "in png_handle_sRGB"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before sRGB"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid sRGB after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->mode & PNG_HAVE_PLTE) - /* Should be an error, but we can cope with it */ - png_warning(png_ptr, "Out of place sRGB chunk"); - - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) - { - png_warning(png_ptr, "Duplicate sRGB chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (length != 1) - { - png_warning(png_ptr, "Incorrect sRGB chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 1); - - if (png_crc_finish(png_ptr, 0)) - return; - - intent = buf[0]; - - /* Check for bad intent */ - if (intent >= PNG_sRGB_INTENT_LAST) - { - png_warning(png_ptr, "Unknown sRGB intent"); - return; - } - -#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)) - { - if (PNG_OUT_OF_RANGE(info_ptr->gamma, 45500, 500)) - { - PNG_WARNING_PARAMETERS(p) - - png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_fixed, - info_ptr->gamma); - - png_formatted_warning(png_ptr, p, - "Ignoring incorrect gAMA value @1 when sRGB is also present"); - } - } -#endif /* PNG_READ_gAMA_SUPPORTED */ - -#ifdef PNG_READ_cHRM_SUPPORTED - if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) - if (PNG_OUT_OF_RANGE(info_ptr->x_white, 31270, 1000) || - PNG_OUT_OF_RANGE(info_ptr->y_white, 32900, 1000) || - PNG_OUT_OF_RANGE(info_ptr->x_red, 64000, 1000) || - PNG_OUT_OF_RANGE(info_ptr->y_red, 33000, 1000) || - PNG_OUT_OF_RANGE(info_ptr->x_green, 30000, 1000) || - PNG_OUT_OF_RANGE(info_ptr->y_green, 60000, 1000) || - PNG_OUT_OF_RANGE(info_ptr->x_blue, 15000, 1000) || - PNG_OUT_OF_RANGE(info_ptr->y_blue, 6000, 1000)) - { - png_warning(png_ptr, - "Ignoring incorrect cHRM value when sRGB is also present"); - } -#endif /* PNG_READ_cHRM_SUPPORTED */ - - /* This is recorded for use when handling the cHRM chunk above. An sRGB - * chunk unconditionally overwrites the coefficients for grayscale conversion - * too. - */ - png_ptr->is_sRGB = 1; - -# ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED - /* Don't overwrite user supplied values: */ - if (!png_ptr->rgb_to_gray_coefficients_set) - { - /* These numbers come from the sRGB specification (or, since one has to - * pay much money to get a copy, the wikipedia sRGB page) the - * chromaticity values quoted have been inverted to get the reverse - * transformation from RGB to XYZ and the 'Y' coefficients scaled by - * 32768 (then rounded). - * - * sRGB and ITU Rec-709 both truncate the values for the D65 white - * point to four digits and, even though it actually stores five - * digits, the PNG spec gives the truncated value. - * - * This means that when the chromaticities are converted back to XYZ - * end points we end up with (6968,23435,2366), which, as described in - * pngrtran.c, would overflow. If the five digit precision and up is - * used we get, instead: - * - * 6968*R + 23435*G + 2365*B - * - * (Notice that this rounds the blue coefficient down, rather than the - * choice used in pngrtran.c which is to round the green one down.) - */ - png_ptr->rgb_to_gray_red_coeff = 6968; /* 0.212639005871510 */ - png_ptr->rgb_to_gray_green_coeff = 23434; /* 0.715168678767756 */ - /* png_ptr->rgb_to_gray_blue_coeff = 2366; 0.072192315360734 */ - - /* The following keeps the cHRM chunk from destroying the - * coefficients again in the event that it follows the sRGB chunk. - */ - png_ptr->rgb_to_gray_coefficients_set = 1; - } -# endif - - png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); -} -#endif /* PNG_READ_sRGB_SUPPORTED */ - -#ifdef PNG_READ_iCCP_SUPPORTED -void /* PRIVATE */ -png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -/* Note: this does not properly handle chunks that are > 64K under DOS */ -{ - png_byte compression_type; - png_bytep pC; - png_charp profile; - png_uint_32 skip = 0; - png_uint_32 profile_size; - png_alloc_size_t profile_length; - png_size_t slength, prefix_length, data_length; - - png_debug(1, "in png_handle_iCCP"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before iCCP"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid iCCP after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->mode & PNG_HAVE_PLTE) - /* Should be an error, but we can cope with it */ - png_warning(png_ptr, "Out of place iCCP chunk"); - - if ((png_ptr->mode & PNG_HAVE_iCCP) || (info_ptr != NULL && - (info_ptr->valid & (PNG_INFO_iCCP|PNG_INFO_sRGB)))) - { - png_warning(png_ptr, "Duplicate iCCP chunk"); - png_crc_finish(png_ptr, length); - return; - } - - png_ptr->mode |= PNG_HAVE_iCCP; - -#ifdef PNG_MAX_MALLOC_64K - if (length > (png_uint_32)65535L) - { - png_warning(png_ptr, "iCCP chunk too large to fit in memory"); - skip = length - (png_uint_32)65535L; - length = (png_uint_32)65535L; - } -#endif - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1); - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - - if (png_crc_finish(png_ptr, skip)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - png_ptr->chunkdata[slength] = 0x00; - - for (profile = png_ptr->chunkdata; *profile; profile++) - /* Empty loop to find end of name */ ; - - ++profile; - - /* There should be at least one zero (the compression type byte) - * following the separator, and we should be on it - */ - if (profile >= png_ptr->chunkdata + slength - 1) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_warning(png_ptr, "Malformed iCCP chunk"); - return; - } - - /* Compression_type should always be zero */ - compression_type = *profile++; - - if (compression_type) - { - png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); - compression_type = 0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 - wrote nonzero) */ - } - - prefix_length = profile - png_ptr->chunkdata; - png_decompress_chunk(png_ptr, compression_type, - slength, prefix_length, &data_length); - - profile_length = data_length - prefix_length; - - if (prefix_length > data_length || profile_length < 4) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_warning(png_ptr, "Profile size field missing from iCCP chunk"); - return; - } - - /* Check the profile_size recorded in the first 32 bits of the ICC profile */ - pC = (png_bytep)(png_ptr->chunkdata + prefix_length); - profile_size = ((*(pC )) << 24) | - ((*(pC + 1)) << 16) | - ((*(pC + 2)) << 8) | - ((*(pC + 3)) ); - - /* NOTE: the following guarantees that 'profile_length' fits into 32 bits, - * because profile_size is a 32 bit value. - */ - if (profile_size < profile_length) - profile_length = profile_size; - - /* And the following guarantees that profile_size == profile_length. */ - if (profile_size > profile_length) - { - PNG_WARNING_PARAMETERS(p) - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - - png_warning_parameter_unsigned(p, 1, PNG_NUMBER_FORMAT_u, profile_size); - png_warning_parameter_unsigned(p, 2, PNG_NUMBER_FORMAT_u, profile_length); - png_formatted_warning(png_ptr, p, - "Ignoring iCCP chunk with declared size = @1 and actual length = @2"); - return; - } - - png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata, - compression_type, (png_bytep)png_ptr->chunkdata + prefix_length, - profile_size); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; -} -#endif /* PNG_READ_iCCP_SUPPORTED */ - -#ifdef PNG_READ_sPLT_SUPPORTED -void /* PRIVATE */ -png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -/* Note: this does not properly handle chunks that are > 64K under DOS */ -{ - png_bytep entry_start; - png_sPLT_t new_palette; - png_sPLT_entryp pp; - png_uint_32 data_length; - int entry_size, i; - png_uint_32 skip = 0; - png_size_t slength; - png_uint_32 dl; - png_size_t max_dl; - - png_debug(1, "in png_handle_sPLT"); - -#ifdef PNG_USER_LIMITS_SUPPORTED - - if (png_ptr->user_chunk_cache_max != 0) - { - if (png_ptr->user_chunk_cache_max == 1) - { - png_crc_finish(png_ptr, length); - return; - } - - if (--png_ptr->user_chunk_cache_max == 1) - { - png_warning(png_ptr, "No space in chunk cache for sPLT"); - png_crc_finish(png_ptr, length); - return; - } - } -#endif - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before sPLT"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid sPLT after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - -#ifdef PNG_MAX_MALLOC_64K - if (length > (png_uint_32)65535L) - { - png_warning(png_ptr, "sPLT chunk too large to fit in memory"); - skip = length - (png_uint_32)65535L; - length = (png_uint_32)65535L; - } -#endif - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1); - - /* WARNING: this may break if size_t is less than 32 bits; it is assumed - * that the PNG_MAX_MALLOC_64K test is enabled in this case, but this is a - * potential breakage point if the types in pngconf.h aren't exactly right. - */ - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - - if (png_crc_finish(png_ptr, skip)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - png_ptr->chunkdata[slength] = 0x00; - - for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; - entry_start++) - /* Empty loop to find end of name */ ; - - ++entry_start; - - /* A sample depth should follow the separator, and we should be on it */ - if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_warning(png_ptr, "malformed sPLT chunk"); - return; - } - - new_palette.depth = *entry_start++; - entry_size = (new_palette.depth == 8 ? 6 : 10); - /* This must fit in a png_uint_32 because it is derived from the original - * chunk data length (and use 'length', not 'slength' here for clarity - - * they are guaranteed to be the same, see the tests above.) - */ - data_length = length - (png_uint_32)(entry_start - - (png_bytep)png_ptr->chunkdata); - - /* Integrity-check the data length */ - if (data_length % entry_size) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_warning(png_ptr, "sPLT chunk has bad length"); - return; - } - - dl = (png_int_32)(data_length / entry_size); - max_dl = PNG_SIZE_MAX / png_sizeof(png_sPLT_entry); - - if (dl > max_dl) - { - png_warning(png_ptr, "sPLT chunk too long"); - return; - } - - new_palette.nentries = (png_int_32)(data_length / entry_size); - - new_palette.entries = (png_sPLT_entryp)png_malloc_warn( - png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry)); - - if (new_palette.entries == NULL) - { - png_warning(png_ptr, "sPLT chunk requires too much memory"); - return; - } - -#ifdef PNG_POINTER_INDEXING_SUPPORTED - for (i = 0; i < new_palette.nentries; i++) - { - pp = new_palette.entries + i; - - if (new_palette.depth == 8) - { - pp->red = *entry_start++; - pp->green = *entry_start++; - pp->blue = *entry_start++; - pp->alpha = *entry_start++; - } - - else - { - pp->red = png_get_uint_16(entry_start); entry_start += 2; - pp->green = png_get_uint_16(entry_start); entry_start += 2; - pp->blue = png_get_uint_16(entry_start); entry_start += 2; - pp->alpha = png_get_uint_16(entry_start); entry_start += 2; - } - - pp->frequency = png_get_uint_16(entry_start); entry_start += 2; - } -#else - pp = new_palette.entries; - - for (i = 0; i < new_palette.nentries; i++) - { - - if (new_palette.depth == 8) - { - pp[i].red = *entry_start++; - pp[i].green = *entry_start++; - pp[i].blue = *entry_start++; - pp[i].alpha = *entry_start++; - } - - else - { - pp[i].red = png_get_uint_16(entry_start); entry_start += 2; - pp[i].green = png_get_uint_16(entry_start); entry_start += 2; - pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; - pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; - } - - pp[i].frequency = png_get_uint_16(entry_start); entry_start += 2; - } -#endif - - /* Discard all chunk data except the name and stash that */ - new_palette.name = png_ptr->chunkdata; - - png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_free(png_ptr, new_palette.entries); -} -#endif /* PNG_READ_sPLT_SUPPORTED */ - -#ifdef PNG_READ_tRNS_SUPPORTED -void /* PRIVATE */ -png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; - - png_debug(1, "in png_handle_tRNS"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before tRNS"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid tRNS after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) - { - png_warning(png_ptr, "Duplicate tRNS chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) - { - png_byte buf[2]; - - if (length != 2) - { - png_warning(png_ptr, "Incorrect tRNS chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 2); - png_ptr->num_trans = 1; - png_ptr->trans_color.gray = png_get_uint_16(buf); - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) - { - png_byte buf[6]; - - if (length != 6) - { - png_warning(png_ptr, "Incorrect tRNS chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, (png_size_t)length); - png_ptr->num_trans = 1; - png_ptr->trans_color.red = png_get_uint_16(buf); - png_ptr->trans_color.green = png_get_uint_16(buf + 2); - png_ptr->trans_color.blue = png_get_uint_16(buf + 4); - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - if (!(png_ptr->mode & PNG_HAVE_PLTE)) - { - /* Should be an error, but we can cope with it. */ - png_warning(png_ptr, "Missing PLTE before tRNS"); - } - - if (length > (png_uint_32)png_ptr->num_palette || - length > PNG_MAX_PALETTE_LENGTH) - { - png_warning(png_ptr, "Incorrect tRNS chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - if (length == 0) - { - png_warning(png_ptr, "Zero length tRNS chunk"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, readbuf, (png_size_t)length); - png_ptr->num_trans = (png_uint_16)length; - } - - else - { - png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); - png_crc_finish(png_ptr, length); - return; - } - - if (png_crc_finish(png_ptr, 0)) - { - png_ptr->num_trans = 0; - return; - } - - png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, - &(png_ptr->trans_color)); -} -#endif - -#ifdef PNG_READ_bKGD_SUPPORTED -void /* PRIVATE */ -png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_size_t truelen; - png_byte buf[6]; - png_color_16 background; - - png_debug(1, "in png_handle_bKGD"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before bKGD"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid bKGD after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && - !(png_ptr->mode & PNG_HAVE_PLTE)) - { - png_warning(png_ptr, "Missing PLTE before bKGD"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) - { - png_warning(png_ptr, "Duplicate bKGD chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - truelen = 1; - - else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) - truelen = 6; - - else - truelen = 2; - - if (length != truelen) - { - png_warning(png_ptr, "Incorrect bKGD chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, truelen); - - if (png_crc_finish(png_ptr, 0)) - return; - - /* We convert the index value into RGB components so that we can allow - * arbitrary RGB values for background when we have transparency, and - * so it is easy to determine the RGB values of the background color - * from the info_ptr struct. - */ - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - background.index = buf[0]; - - if (info_ptr && info_ptr->num_palette) - { - if (buf[0] >= info_ptr->num_palette) - { - png_warning(png_ptr, "Incorrect bKGD chunk index value"); - return; - } - - background.red = (png_uint_16)png_ptr->palette[buf[0]].red; - background.green = (png_uint_16)png_ptr->palette[buf[0]].green; - background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue; - } - - else - background.red = background.green = background.blue = 0; - - background.gray = 0; - } - - else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ - { - background.index = 0; - background.red = - background.green = - background.blue = - background.gray = png_get_uint_16(buf); - } - - else - { - background.index = 0; - background.red = png_get_uint_16(buf); - background.green = png_get_uint_16(buf + 2); - background.blue = png_get_uint_16(buf + 4); - background.gray = 0; - } - - png_set_bKGD(png_ptr, info_ptr, &background); -} -#endif - -#ifdef PNG_READ_hIST_SUPPORTED -void /* PRIVATE */ -png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - unsigned int num, i; - png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; - - png_debug(1, "in png_handle_hIST"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before hIST"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid hIST after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (!(png_ptr->mode & PNG_HAVE_PLTE)) - { - png_warning(png_ptr, "Missing PLTE before hIST"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) - { - png_warning(png_ptr, "Duplicate hIST chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (length > 2*PNG_MAX_PALETTE_LENGTH || - length != (unsigned int) (2*png_ptr->num_palette)) - { - png_warning(png_ptr, "Incorrect hIST chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - num = length / 2 ; - - for (i = 0; i < num; i++) - { - png_byte buf[2]; - - png_crc_read(png_ptr, buf, 2); - readbuf[i] = png_get_uint_16(buf); - } - - if (png_crc_finish(png_ptr, 0)) - return; - - png_set_hIST(png_ptr, info_ptr, readbuf); -} -#endif - -#ifdef PNG_READ_pHYs_SUPPORTED -void /* PRIVATE */ -png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_byte buf[9]; - png_uint_32 res_x, res_y; - int unit_type; - - png_debug(1, "in png_handle_pHYs"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before pHYs"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid pHYs after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) - { - png_warning(png_ptr, "Duplicate pHYs chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (length != 9) - { - png_warning(png_ptr, "Incorrect pHYs chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 9); - - if (png_crc_finish(png_ptr, 0)) - return; - - res_x = png_get_uint_32(buf); - res_y = png_get_uint_32(buf + 4); - unit_type = buf[8]; - png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type); -} -#endif - -#ifdef PNG_READ_oFFs_SUPPORTED -void /* PRIVATE */ -png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_byte buf[9]; - png_int_32 offset_x, offset_y; - int unit_type; - - png_debug(1, "in png_handle_oFFs"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before oFFs"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid oFFs after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) - { - png_warning(png_ptr, "Duplicate oFFs chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (length != 9) - { - png_warning(png_ptr, "Incorrect oFFs chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 9); - - if (png_crc_finish(png_ptr, 0)) - return; - - offset_x = png_get_int_32(buf); - offset_y = png_get_int_32(buf + 4); - unit_type = buf[8]; - png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type); -} -#endif - -#ifdef PNG_READ_pCAL_SUPPORTED -/* Read the pCAL chunk (described in the PNG Extensions document) */ -void /* PRIVATE */ -png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_int_32 X0, X1; - png_byte type, nparams; - png_charp buf, units, endptr; - png_charpp params; - png_size_t slength; - int i; - - png_debug(1, "in png_handle_pCAL"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before pCAL"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid pCAL after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) - { - png_warning(png_ptr, "Duplicate pCAL chunk"); - png_crc_finish(png_ptr, length); - return; - } - - png_debug1(2, "Allocating and reading pCAL chunk data (%u bytes)", - length + 1); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); - - if (png_ptr->chunkdata == NULL) - { - png_warning(png_ptr, "No memory for pCAL purpose"); - return; - } - - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - - if (png_crc_finish(png_ptr, 0)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ - - png_debug(3, "Finding end of pCAL purpose string"); - for (buf = png_ptr->chunkdata; *buf; buf++) - /* Empty loop */ ; - - endptr = png_ptr->chunkdata + slength; - - /* We need to have at least 12 bytes after the purpose string - * in order to get the parameter information. - */ - if (endptr <= buf + 12) - { - png_warning(png_ptr, "Invalid pCAL data"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - png_debug(3, "Reading pCAL X0, X1, type, nparams, and units"); - X0 = png_get_int_32((png_bytep)buf+1); - X1 = png_get_int_32((png_bytep)buf+5); - type = buf[9]; - nparams = buf[10]; - units = buf + 11; - - png_debug(3, "Checking pCAL equation type and number of parameters"); - /* Check that we have the right number of parameters for known - * equation types. - */ - if ((type == PNG_EQUATION_LINEAR && nparams != 2) || - (type == PNG_EQUATION_BASE_E && nparams != 3) || - (type == PNG_EQUATION_ARBITRARY && nparams != 3) || - (type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) - { - png_warning(png_ptr, "Invalid pCAL parameters for equation type"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - else if (type >= PNG_EQUATION_LAST) - { - png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); - } - - for (buf = units; *buf; buf++) - /* Empty loop to move past the units string. */ ; - - png_debug(3, "Allocating pCAL parameters array"); - - params = (png_charpp)png_malloc_warn(png_ptr, - (png_size_t)(nparams * png_sizeof(png_charp))); - - if (params == NULL) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_warning(png_ptr, "No memory for pCAL params"); - return; - } - - /* Get pointers to the start of each parameter string. */ - for (i = 0; i < (int)nparams; i++) - { - buf++; /* Skip the null string terminator from previous parameter. */ - - png_debug1(3, "Reading pCAL parameter %d", i); - - for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++) - /* Empty loop to move past each parameter string */ ; - - /* Make sure we haven't run out of data yet */ - if (buf > endptr) - { - png_warning(png_ptr, "Invalid pCAL data"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_free(png_ptr, params); - return; - } - } - - png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams, - units, params); - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_free(png_ptr, params); -} -#endif - -#ifdef PNG_READ_sCAL_SUPPORTED -/* Read the sCAL chunk */ -void /* PRIVATE */ -png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_size_t slength, i; - int state; - - png_debug(1, "in png_handle_sCAL"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before sCAL"); - - else if (png_ptr->mode & PNG_HAVE_IDAT) - { - png_warning(png_ptr, "Invalid sCAL after IDAT"); - png_crc_finish(png_ptr, length); - return; - } - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) - { - png_warning(png_ptr, "Duplicate sCAL chunk"); - png_crc_finish(png_ptr, length); - return; - } - - /* Need unit type, width, \0, height: minimum 4 bytes */ - else if (length < 4) - { - png_warning(png_ptr, "sCAL chunk too short"); - png_crc_finish(png_ptr, length); - return; - } - - png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)", - length + 1); - - png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); - - if (png_ptr->chunkdata == NULL) - { - png_warning(png_ptr, "Out of memory while processing sCAL chunk"); - png_crc_finish(png_ptr, length); - return; - } - - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ - - if (png_crc_finish(png_ptr, 0)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - /* Validate the unit. */ - if (png_ptr->chunkdata[0] != 1 && png_ptr->chunkdata[0] != 2) - { - png_warning(png_ptr, "Invalid sCAL ignored: invalid unit"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - /* Validate the ASCII numbers, need two ASCII numbers separated by - * a '\0' and they need to fit exactly in the chunk data. - */ - i = 1; - state = 0; - - if (!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) || - i >= slength || png_ptr->chunkdata[i++] != 0) - png_warning(png_ptr, "Invalid sCAL chunk ignored: bad width format"); - - else if (!PNG_FP_IS_POSITIVE(state)) - png_warning(png_ptr, "Invalid sCAL chunk ignored: non-positive width"); - - else - { - png_size_t heighti = i; - - state = 0; - if (!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) || - i != slength) - png_warning(png_ptr, "Invalid sCAL chunk ignored: bad height format"); - - else if (!PNG_FP_IS_POSITIVE(state)) - png_warning(png_ptr, - "Invalid sCAL chunk ignored: non-positive height"); - - else - /* This is the (only) success case. */ - png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], - png_ptr->chunkdata+1, png_ptr->chunkdata+heighti); - } - - /* Clean up - just free the temporarily allocated buffer. */ - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; -} -#endif - -#ifdef PNG_READ_tIME_SUPPORTED -void /* PRIVATE */ -png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_byte buf[7]; - png_time mod_time; - - png_debug(1, "in png_handle_tIME"); - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Out of place tIME chunk"); - - else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) - { - png_warning(png_ptr, "Duplicate tIME chunk"); - png_crc_finish(png_ptr, length); - return; - } - - if (png_ptr->mode & PNG_HAVE_IDAT) - png_ptr->mode |= PNG_AFTER_IDAT; - - if (length != 7) - { - png_warning(png_ptr, "Incorrect tIME chunk length"); - png_crc_finish(png_ptr, length); - return; - } - - png_crc_read(png_ptr, buf, 7); - - if (png_crc_finish(png_ptr, 0)) - return; - - mod_time.second = buf[6]; - mod_time.minute = buf[5]; - mod_time.hour = buf[4]; - mod_time.day = buf[3]; - mod_time.month = buf[2]; - mod_time.year = png_get_uint_16(buf); - - png_set_tIME(png_ptr, info_ptr, &mod_time); -} -#endif - -#ifdef PNG_READ_tEXt_SUPPORTED -/* Note: this does not properly handle chunks that are > 64K under DOS */ -void /* PRIVATE */ -png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_textp text_ptr; - png_charp key; - png_charp text; - png_uint_32 skip = 0; - png_size_t slength; - int ret; - - png_debug(1, "in png_handle_tEXt"); - -#ifdef PNG_USER_LIMITS_SUPPORTED - if (png_ptr->user_chunk_cache_max != 0) - { - if (png_ptr->user_chunk_cache_max == 1) - { - png_crc_finish(png_ptr, length); - return; - } - - if (--png_ptr->user_chunk_cache_max == 1) - { - png_warning(png_ptr, "No space in chunk cache for tEXt"); - png_crc_finish(png_ptr, length); - return; - } - } -#endif - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before tEXt"); - - if (png_ptr->mode & PNG_HAVE_IDAT) - png_ptr->mode |= PNG_AFTER_IDAT; - -#ifdef PNG_MAX_MALLOC_64K - if (length > (png_uint_32)65535L) - { - png_warning(png_ptr, "tEXt chunk too large to fit in memory"); - skip = length - (png_uint_32)65535L; - length = (png_uint_32)65535L; - } -#endif - - png_free(png_ptr, png_ptr->chunkdata); - - png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); - - if (png_ptr->chunkdata == NULL) - { - png_warning(png_ptr, "No memory to process text chunk"); - return; - } - - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - - if (png_crc_finish(png_ptr, skip)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - key = png_ptr->chunkdata; - - key[slength] = 0x00; - - for (text = key; *text; text++) - /* Empty loop to find end of key */ ; - - if (text != key + slength) - text++; - - text_ptr = (png_textp)png_malloc_warn(png_ptr, - png_sizeof(png_text)); - - if (text_ptr == NULL) - { - png_warning(png_ptr, "Not enough memory to process text chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; - text_ptr->key = key; - text_ptr->lang = NULL; - text_ptr->lang_key = NULL; - text_ptr->itxt_length = 0; - text_ptr->text = text; - text_ptr->text_length = png_strlen(text); - - ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - png_free(png_ptr, text_ptr); - - if (ret) - png_warning(png_ptr, "Insufficient memory to process text chunk"); -} -#endif - -#ifdef PNG_READ_zTXt_SUPPORTED -/* Note: this does not correctly handle chunks that are > 64K under DOS */ -void /* PRIVATE */ -png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_textp text_ptr; - png_charp text; - int comp_type; - int ret; - png_size_t slength, prefix_len, data_len; - - png_debug(1, "in png_handle_zTXt"); - -#ifdef PNG_USER_LIMITS_SUPPORTED - if (png_ptr->user_chunk_cache_max != 0) - { - if (png_ptr->user_chunk_cache_max == 1) - { - png_crc_finish(png_ptr, length); - return; - } - - if (--png_ptr->user_chunk_cache_max == 1) - { - png_warning(png_ptr, "No space in chunk cache for zTXt"); - png_crc_finish(png_ptr, length); - return; - } - } -#endif - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before zTXt"); - - if (png_ptr->mode & PNG_HAVE_IDAT) - png_ptr->mode |= PNG_AFTER_IDAT; - -#ifdef PNG_MAX_MALLOC_64K - /* We will no doubt have problems with chunks even half this size, but - * there is no hard and fast rule to tell us where to stop. - */ - if (length > (png_uint_32)65535L) - { - png_warning(png_ptr, "zTXt chunk too large to fit in memory"); - png_crc_finish(png_ptr, length); - return; - } -#endif - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); - - if (png_ptr->chunkdata == NULL) - { - png_warning(png_ptr, "Out of memory processing zTXt chunk"); - return; - } - - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - - if (png_crc_finish(png_ptr, 0)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - png_ptr->chunkdata[slength] = 0x00; - - for (text = png_ptr->chunkdata; *text; text++) - /* Empty loop */ ; - - /* zTXt must have some text after the chunkdataword */ - if (text >= png_ptr->chunkdata + slength - 2) - { - png_warning(png_ptr, "Truncated zTXt chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - else - { - comp_type = *(++text); - - if (comp_type != PNG_TEXT_COMPRESSION_zTXt) - { - png_warning(png_ptr, "Unknown compression type in zTXt chunk"); - comp_type = PNG_TEXT_COMPRESSION_zTXt; - } - - text++; /* Skip the compression_method byte */ - } - - prefix_len = text - png_ptr->chunkdata; - - png_decompress_chunk(png_ptr, comp_type, - (png_size_t)length, prefix_len, &data_len); - - text_ptr = (png_textp)png_malloc_warn(png_ptr, - png_sizeof(png_text)); - - if (text_ptr == NULL) - { - png_warning(png_ptr, "Not enough memory to process zTXt chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - text_ptr->compression = comp_type; - text_ptr->key = png_ptr->chunkdata; - text_ptr->lang = NULL; - text_ptr->lang_key = NULL; - text_ptr->itxt_length = 0; - text_ptr->text = png_ptr->chunkdata + prefix_len; - text_ptr->text_length = data_len; - - ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); - - png_free(png_ptr, text_ptr); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - - if (ret) - png_error(png_ptr, "Insufficient memory to store zTXt chunk"); -} -#endif - -#ifdef PNG_READ_iTXt_SUPPORTED -/* Note: this does not correctly handle chunks that are > 64K under DOS */ -void /* PRIVATE */ -png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_textp text_ptr; - png_charp key, lang, text, lang_key; - int comp_flag; - int comp_type = 0; - int ret; - png_size_t slength, prefix_len, data_len; - - png_debug(1, "in png_handle_iTXt"); - -#ifdef PNG_USER_LIMITS_SUPPORTED - if (png_ptr->user_chunk_cache_max != 0) - { - if (png_ptr->user_chunk_cache_max == 1) - { - png_crc_finish(png_ptr, length); - return; - } - - if (--png_ptr->user_chunk_cache_max == 1) - { - png_warning(png_ptr, "No space in chunk cache for iTXt"); - png_crc_finish(png_ptr, length); - return; - } - } -#endif - - if (!(png_ptr->mode & PNG_HAVE_IHDR)) - png_error(png_ptr, "Missing IHDR before iTXt"); - - if (png_ptr->mode & PNG_HAVE_IDAT) - png_ptr->mode |= PNG_AFTER_IDAT; - -#ifdef PNG_MAX_MALLOC_64K - /* We will no doubt have problems with chunks even half this size, but - * there is no hard and fast rule to tell us where to stop. - */ - if (length > (png_uint_32)65535L) - { - png_warning(png_ptr, "iTXt chunk too large to fit in memory"); - png_crc_finish(png_ptr, length); - return; - } -#endif - - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); - - if (png_ptr->chunkdata == NULL) - { - png_warning(png_ptr, "No memory to process iTXt chunk"); - return; - } - - slength = length; - png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); - - if (png_crc_finish(png_ptr, 0)) - { - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - png_ptr->chunkdata[slength] = 0x00; - - for (lang = png_ptr->chunkdata; *lang; lang++) - /* Empty loop */ ; - - lang++; /* Skip NUL separator */ - - /* iTXt must have a language tag (possibly empty), two compression bytes, - * translated keyword (possibly empty), and possibly some text after the - * keyword - */ - - if (lang >= png_ptr->chunkdata + slength - 3) - { - png_warning(png_ptr, "Truncated iTXt chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - else - { - comp_flag = *lang++; - comp_type = *lang++; - } - - if (comp_type || (comp_flag && comp_flag != PNG_TEXT_COMPRESSION_zTXt)) - { - png_warning(png_ptr, "Unknown iTXt compression type or method"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - for (lang_key = lang; *lang_key; lang_key++) - /* Empty loop */ ; - - lang_key++; /* Skip NUL separator */ - - if (lang_key >= png_ptr->chunkdata + slength) - { - png_warning(png_ptr, "Truncated iTXt chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - for (text = lang_key; *text; text++) - /* Empty loop */ ; - - text++; /* Skip NUL separator */ - - if (text >= png_ptr->chunkdata + slength) - { - png_warning(png_ptr, "Malformed iTXt chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - prefix_len = text - png_ptr->chunkdata; - - key=png_ptr->chunkdata; - - if (comp_flag) - png_decompress_chunk(png_ptr, comp_type, - (size_t)length, prefix_len, &data_len); - - else - data_len = png_strlen(png_ptr->chunkdata + prefix_len); - - text_ptr = (png_textp)png_malloc_warn(png_ptr, - png_sizeof(png_text)); - - if (text_ptr == NULL) - { - png_warning(png_ptr, "Not enough memory to process iTXt chunk"); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - return; - } - - text_ptr->compression = (int)comp_flag + 1; - text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key); - text_ptr->lang = png_ptr->chunkdata + (lang - key); - text_ptr->itxt_length = data_len; - text_ptr->text_length = 0; - text_ptr->key = png_ptr->chunkdata; - text_ptr->text = png_ptr->chunkdata + prefix_len; - - ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); - - png_free(png_ptr, text_ptr); - png_free(png_ptr, png_ptr->chunkdata); - png_ptr->chunkdata = NULL; - - if (ret) - png_error(png_ptr, "Insufficient memory to store iTXt chunk"); -} -#endif - -/* This function is called when we haven't found a handler for a - * chunk. If there isn't a problem with the chunk itself (ie bad - * chunk name, CRC, or a critical chunk), the chunk is silently ignored - * -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which - * case it will be saved away to be written out later. - */ -void /* PRIVATE */ -png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) -{ - png_uint_32 skip = 0; - - png_debug(1, "in png_handle_unknown"); - -#ifdef PNG_USER_LIMITS_SUPPORTED - if (png_ptr->user_chunk_cache_max != 0) - { - if (png_ptr->user_chunk_cache_max == 1) - { - png_crc_finish(png_ptr, length); - return; - } - - if (--png_ptr->user_chunk_cache_max == 1) - { - png_warning(png_ptr, "No space in chunk cache for unknown chunk"); - png_crc_finish(png_ptr, length); - return; - } - } -#endif - - if (png_ptr->mode & PNG_HAVE_IDAT) - { - if (png_ptr->chunk_name != png_IDAT) - png_ptr->mode |= PNG_AFTER_IDAT; - } - - if (PNG_CHUNK_CRITICAL(png_ptr->chunk_name)) - { -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - if (png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name) != - PNG_HANDLE_CHUNK_ALWAYS -#ifdef PNG_READ_USER_CHUNKS_SUPPORTED - && png_ptr->read_user_chunk_fn == NULL -#endif - ) -#endif - png_chunk_error(png_ptr, "unknown critical chunk"); - } - -#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED - if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) -#ifdef PNG_READ_USER_CHUNKS_SUPPORTED - || (png_ptr->read_user_chunk_fn != NULL) -#endif - ) - { -#ifdef PNG_MAX_MALLOC_64K - if (length > 65535) - { - png_warning(png_ptr, "unknown chunk too large to fit in memory"); - skip = length - 65535; - length = 65535; - } -#endif - - /* TODO: this code is very close to the unknown handling in pngpread.c, - * maybe it can be put into a common utility routine? - * png_struct::unknown_chunk is just used as a temporary variable, along - * with the data into which the chunk is read. These can be eliminated. - */ - PNG_CSTRING_FROM_CHUNK(png_ptr->unknown_chunk.name, png_ptr->chunk_name); - png_ptr->unknown_chunk.size = (png_size_t)length; - - if (length == 0) - png_ptr->unknown_chunk.data = NULL; - - else - { - png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length); - png_crc_read(png_ptr, png_ptr->unknown_chunk.data, length); - } - -#ifdef PNG_READ_USER_CHUNKS_SUPPORTED - if (png_ptr->read_user_chunk_fn != NULL) - { - /* Callback to user unknown chunk handler */ - int ret; - - ret = (*(png_ptr->read_user_chunk_fn)) - (png_ptr, &png_ptr->unknown_chunk); - - if (ret < 0) - png_chunk_error(png_ptr, "error in user chunk"); - - if (ret == 0) - { - if (PNG_CHUNK_CRITICAL(png_ptr->chunk_name)) - { -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - if (png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name) != - PNG_HANDLE_CHUNK_ALWAYS) -#endif - png_chunk_error(png_ptr, "unknown critical chunk"); - } - - png_set_unknown_chunks(png_ptr, info_ptr, - &png_ptr->unknown_chunk, 1); - } - } - - else -#endif - png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); - - png_free(png_ptr, png_ptr->unknown_chunk.data); - png_ptr->unknown_chunk.data = NULL; - } - - else -#endif - skip = length; - - png_crc_finish(png_ptr, skip); - -#ifndef PNG_READ_USER_CHUNKS_SUPPORTED - PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */ -#endif -} - -/* This function is called to verify that a chunk name is valid. - * This function can't have the "critical chunk check" incorporated - * into it, since in the future we will need to be able to call user - * functions to handle unknown critical chunks after we check that - * the chunk name itself is valid. - */ - -/* Bit hacking: the test for an invalid byte in the 4 byte chunk name is: - * - * ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) - */ - -void /* PRIVATE */ -png_check_chunk_name(png_structp png_ptr, png_uint_32 chunk_name) -{ - int i; - - png_debug(1, "in png_check_chunk_name"); - - for (i=1; i<=4; ++i) - { - int c = chunk_name & 0xff; - - if (c < 65 || c > 122 || (c > 90 && c < 97)) - png_chunk_error(png_ptr, "invalid chunk type"); - - chunk_name >>= 8; - } -} - -/* Combines the row recently read in with the existing pixels in the row. This - * routine takes care of alpha and transparency if requested. This routine also - * handles the two methods of progressive display of interlaced images, - * depending on the 'display' value; if 'display' is true then the whole row - * (dp) is filled from the start by replicating the available pixels. If - * 'display' is false only those pixels present in the pass are filled in. - */ -void /* PRIVATE */ -png_combine_row(png_structp png_ptr, png_bytep dp, int display) -{ - unsigned int pixel_depth = png_ptr->transformed_pixel_depth; - png_const_bytep sp = png_ptr->row_buf + 1; - png_uint_32 row_width = png_ptr->width; - unsigned int pass = png_ptr->pass; - png_bytep end_ptr = 0; - png_byte end_byte = 0; - unsigned int end_mask; - - png_debug(1, "in png_combine_row"); - - /* Added in 1.5.6: it should not be possible to enter this routine until at - * least one row has been read from the PNG data and transformed. - */ - if (pixel_depth == 0) - png_error(png_ptr, "internal row logic error"); - - /* Added in 1.5.4: the pixel depth should match the information returned by - * any call to png_read_update_info at this point. Do not continue if we got - * this wrong. - */ - if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes != - PNG_ROWBYTES(pixel_depth, row_width)) - png_error(png_ptr, "internal row size calculation error"); - - /* Don't expect this to ever happen: */ - if (row_width == 0) - png_error(png_ptr, "internal row width error"); - - /* Preserve the last byte in cases where only part of it will be overwritten, - * the multiply below may overflow, we don't care because ANSI-C guarantees - * we get the low bits. - */ - end_mask = (pixel_depth * row_width) & 7; - if (end_mask != 0) - { - /* end_ptr == NULL is a flag to say do nothing */ - end_ptr = dp + PNG_ROWBYTES(pixel_depth, row_width) - 1; - end_byte = *end_ptr; -# ifdef PNG_READ_PACKSWAP_SUPPORTED - if (png_ptr->transformations & PNG_PACKSWAP) /* little-endian byte */ - end_mask = 0xff << end_mask; - - else /* big-endian byte */ -# endif - end_mask = 0xff >> end_mask; - /* end_mask is now the bits to *keep* from the destination row */ - } - - /* For non-interlaced images this reduces to a png_memcpy(). A png_memcpy() - * will also happen if interlacing isn't supported or if the application - * does not call png_set_interlace_handling(). In the latter cases the - * caller just gets a sequence of the unexpanded rows from each interlace - * pass. - */ -#ifdef PNG_READ_INTERLACING_SUPPORTED - if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE) && - pass < 6 && (display == 0 || - /* The following copies everything for 'display' on passes 0, 2 and 4. */ - (display == 1 && (pass & 1) != 0))) - { - /* Narrow images may have no bits in a pass; the caller should handle - * this, but this test is cheap: - */ - if (row_width <= PNG_PASS_START_COL(pass)) - return; - - if (pixel_depth < 8) - { - /* For pixel depths up to 4 bpp the 8-pixel mask can be expanded to fit - * into 32 bits, then a single loop over the bytes using the four byte - * values in the 32-bit mask can be used. For the 'display' option the - * expanded mask may also not require any masking within a byte. To - * make this work the PACKSWAP option must be taken into account - it - * simply requires the pixels to be reversed in each byte. - * - * The 'regular' case requires a mask for each of the first 6 passes, - * the 'display' case does a copy for the even passes in the range - * 0..6. This has already been handled in the test above. - * - * The masks are arranged as four bytes with the first byte to use in - * the lowest bits (little-endian) regardless of the order (PACKSWAP or - * not) of the pixels in each byte. - * - * NOTE: the whole of this logic depends on the caller of this function - * only calling it on rows appropriate to the pass. This function only - * understands the 'x' logic; the 'y' logic is handled by the caller. - * - * The following defines allow generation of compile time constant bit - * masks for each pixel depth and each possibility of swapped or not - * swapped bytes. Pass 'p' is in the range 0..6; 'x', a pixel index, - * is in the range 0..7; and the result is 1 if the pixel is to be - * copied in the pass, 0 if not. 'S' is for the sparkle method, 'B' - * for the block method. - * - * With some compilers a compile time expression of the general form: - * - * (shift >= 32) ? (a >> (shift-32)) : (b >> shift) - * - * Produces warnings with values of 'shift' in the range 33 to 63 - * because the right hand side of the ?: expression is evaluated by - * the compiler even though it isn't used. Microsoft Visual C (various - * versions) and the Intel C compiler are known to do this. To avoid - * this the following macros are used in 1.5.6. This is a temporary - * solution to avoid destabilizing the code during the release process. - */ -# if PNG_USE_COMPILE_TIME_MASKS -# define PNG_LSR(x,s) ((x)>>((s) & 0x1f)) -# define PNG_LSL(x,s) ((x)<<((s) & 0x1f)) -# else -# define PNG_LSR(x,s) ((x)>>(s)) -# define PNG_LSL(x,s) ((x)<<(s)) -# endif -# define S_COPY(p,x) (((p)<4 ? PNG_LSR(0x80088822,(3-(p))*8+(7-(x))) :\ - PNG_LSR(0xaa55ff00,(7-(p))*8+(7-(x)))) & 1) -# define B_COPY(p,x) (((p)<4 ? PNG_LSR(0xff0fff33,(3-(p))*8+(7-(x))) :\ - PNG_LSR(0xff55ff00,(7-(p))*8+(7-(x)))) & 1) - - /* Return a mask for pass 'p' pixel 'x' at depth 'd'. The mask is - * little endian - the first pixel is at bit 0 - however the extra - * parameter 's' can be set to cause the mask position to be swapped - * within each byte, to match the PNG format. This is done by XOR of - * the shift with 7, 6 or 4 for bit depths 1, 2 and 4. - */ -# define PIXEL_MASK(p,x,d,s) \ - (PNG_LSL(((PNG_LSL(1U,(d)))-1),(((x)*(d))^((s)?8-(d):0)))) - - /* Hence generate the appropriate 'block' or 'sparkle' pixel copy mask. - */ -# define S_MASKx(p,x,d,s) (S_COPY(p,x)?PIXEL_MASK(p,x,d,s):0) -# define B_MASKx(p,x,d,s) (B_COPY(p,x)?PIXEL_MASK(p,x,d,s):0) - - /* Combine 8 of these to get the full mask. For the 1-bpp and 2-bpp - * cases the result needs replicating, for the 4-bpp case the above - * generates a full 32 bits. - */ -# define MASK_EXPAND(m,d) ((m)*((d)==1?0x01010101:((d)==2?0x00010001:1))) - -# define S_MASK(p,d,s) MASK_EXPAND(S_MASKx(p,0,d,s) + S_MASKx(p,1,d,s) +\ - S_MASKx(p,2,d,s) + S_MASKx(p,3,d,s) + S_MASKx(p,4,d,s) +\ - S_MASKx(p,5,d,s) + S_MASKx(p,6,d,s) + S_MASKx(p,7,d,s), d) - -# define B_MASK(p,d,s) MASK_EXPAND(B_MASKx(p,0,d,s) + B_MASKx(p,1,d,s) +\ - B_MASKx(p,2,d,s) + B_MASKx(p,3,d,s) + B_MASKx(p,4,d,s) +\ - B_MASKx(p,5,d,s) + B_MASKx(p,6,d,s) + B_MASKx(p,7,d,s), d) - -#if PNG_USE_COMPILE_TIME_MASKS - /* Utility macros to construct all the masks for a depth/swap - * combination. The 's' parameter says whether the format is PNG - * (big endian bytes) or not. Only the three odd-numbered passes are - * required for the display/block algorithm. - */ -# define S_MASKS(d,s) { S_MASK(0,d,s), S_MASK(1,d,s), S_MASK(2,d,s),\ - S_MASK(3,d,s), S_MASK(4,d,s), S_MASK(5,d,s) } - -# define B_MASKS(d,s) { B_MASK(1,d,s), S_MASK(3,d,s), S_MASK(5,d,s) } - -# define DEPTH_INDEX(d) ((d)==1?0:((d)==2?1:2)) - - /* Hence the pre-compiled masks indexed by PACKSWAP (or not), depth and - * then pass: - */ - static PNG_CONST png_uint_32 row_mask[2/*PACKSWAP*/][3/*depth*/][6] = - { - /* Little-endian byte masks for PACKSWAP */ - { S_MASKS(1,0), S_MASKS(2,0), S_MASKS(4,0) }, - /* Normal (big-endian byte) masks - PNG format */ - { S_MASKS(1,1), S_MASKS(2,1), S_MASKS(4,1) } - }; - - /* display_mask has only three entries for the odd passes, so index by - * pass>>1. - */ - static PNG_CONST png_uint_32 display_mask[2][3][3] = - { - /* Little-endian byte masks for PACKSWAP */ - { B_MASKS(1,0), B_MASKS(2,0), B_MASKS(4,0) }, - /* Normal (big-endian byte) masks - PNG format */ - { B_MASKS(1,1), B_MASKS(2,1), B_MASKS(4,1) } - }; - -# define MASK(pass,depth,display,png)\ - ((display)?display_mask[png][DEPTH_INDEX(depth)][pass>>1]:\ - row_mask[png][DEPTH_INDEX(depth)][pass]) - -#else /* !PNG_USE_COMPILE_TIME_MASKS */ - /* This is the runtime alternative: it seems unlikely that this will - * ever be either smaller or faster than the compile time approach. - */ -# define MASK(pass,depth,display,png)\ - ((display)?B_MASK(pass,depth,png):S_MASK(pass,depth,png)) -#endif /* !PNG_USE_COMPILE_TIME_MASKS */ - - /* Use the appropriate mask to copy the required bits. In some cases - * the byte mask will be 0 or 0xff, optimize these cases. row_width is - * the number of pixels, but the code copies bytes, so it is necessary - * to special case the end. - */ - png_uint_32 pixels_per_byte = 8 / pixel_depth; - png_uint_32 mask; - -# ifdef PNG_READ_PACKSWAP_SUPPORTED - if (png_ptr->transformations & PNG_PACKSWAP) - mask = MASK(pass, pixel_depth, display, 0); - - else -# endif - mask = MASK(pass, pixel_depth, display, 1); - - for (;;) - { - png_uint_32 m; - - /* It doesn't matter in the following if png_uint_32 has more than - * 32 bits because the high bits always match those in m<<24; it is, - * however, essential to use OR here, not +, because of this. - */ - m = mask; - mask = (m >> 8) | (m << 24); /* rotate right to good compilers */ - m &= 0xff; - - if (m != 0) /* something to copy */ - { - if (m != 0xff) - *dp = (png_byte)((*dp & ~m) | (*sp & m)); - else - *dp = *sp; - } - - /* NOTE: this may overwrite the last byte with garbage if the image - * is not an exact number of bytes wide; libpng has always done - * this. - */ - if (row_width <= pixels_per_byte) - break; /* May need to restore part of the last byte */ - - row_width -= pixels_per_byte; - ++dp; - ++sp; - } - } - - else /* pixel_depth >= 8 */ - { - unsigned int bytes_to_copy, bytes_to_jump; - - /* Validate the depth - it must be a multiple of 8 */ - if (pixel_depth & 7) - png_error(png_ptr, "invalid user transform pixel depth"); - - pixel_depth >>= 3; /* now in bytes */ - row_width *= pixel_depth; - - /* Regardless of pass number the Adam 7 interlace always results in a - * fixed number of pixels to copy then to skip. There may be a - * different number of pixels to skip at the start though. - */ - { - unsigned int offset = PNG_PASS_START_COL(pass) * pixel_depth; - - row_width -= offset; - dp += offset; - sp += offset; - } - - /* Work out the bytes to copy. */ - if (display) - { - /* When doing the 'block' algorithm the pixel in the pass gets - * replicated to adjacent pixels. This is why the even (0,2,4,6) - * passes are skipped above - the entire expanded row is copied. - */ - bytes_to_copy = (1<<((6-pass)>>1)) * pixel_depth; - - /* But don't allow this number to exceed the actual row width. */ - if (bytes_to_copy > row_width) - bytes_to_copy = row_width; - } - - else /* normal row; Adam7 only ever gives us one pixel to copy. */ - bytes_to_copy = pixel_depth; - - /* In Adam7 there is a constant offset between where the pixels go. */ - bytes_to_jump = PNG_PASS_COL_OFFSET(pass) * pixel_depth; - - /* And simply copy these bytes. Some optimization is possible here, - * depending on the value of 'bytes_to_copy'. Special case the low - * byte counts, which we know to be frequent. - * - * Notice that these cases all 'return' rather than 'break' - this - * avoids an unnecessary test on whether to restore the last byte - * below. - */ - switch (bytes_to_copy) - { - case 1: - for (;;) - { - *dp = *sp; - - if (row_width <= bytes_to_jump) - return; - - dp += bytes_to_jump; - sp += bytes_to_jump; - row_width -= bytes_to_jump; - } - - case 2: - /* There is a possibility of a partial copy at the end here; this - * slows the code down somewhat. - */ - do - { - dp[0] = sp[0], dp[1] = sp[1]; - - if (row_width <= bytes_to_jump) - return; - - sp += bytes_to_jump; - dp += bytes_to_jump; - row_width -= bytes_to_jump; - } - while (row_width > 1); - - /* And there can only be one byte left at this point: */ - *dp = *sp; - return; - - case 3: - /* This can only be the RGB case, so each copy is exactly one - * pixel and it is not necessary to check for a partial copy. - */ - for(;;) - { - dp[0] = sp[0], dp[1] = sp[1], dp[2] = sp[2]; - - if (row_width <= bytes_to_jump) - return; - - sp += bytes_to_jump; - dp += bytes_to_jump; - row_width -= bytes_to_jump; - } - - default: -#if PNG_ALIGN_TYPE != PNG_ALIGN_NONE - /* Check for double byte alignment and, if possible, use a - * 16-bit copy. Don't attempt this for narrow images - ones that - * are less than an interlace panel wide. Don't attempt it for - * wide bytes_to_copy either - use the png_memcpy there. - */ - if (bytes_to_copy < 16 /*else use png_memcpy*/ && - png_isaligned(dp, png_uint_16) && - png_isaligned(sp, png_uint_16) && - bytes_to_copy % sizeof (png_uint_16) == 0 && - bytes_to_jump % sizeof (png_uint_16) == 0) - { - /* Everything is aligned for png_uint_16 copies, but try for - * png_uint_32 first. - */ - if (png_isaligned(dp, png_uint_32) && - png_isaligned(sp, png_uint_32) && - bytes_to_copy % sizeof (png_uint_32) == 0 && - bytes_to_jump % sizeof (png_uint_32) == 0) - { - png_uint_32p dp32 = (png_uint_32p)dp; - png_const_uint_32p sp32 = (png_const_uint_32p)sp; - unsigned int skip = (bytes_to_jump-bytes_to_copy) / - sizeof (png_uint_32); - - do - { - size_t c = bytes_to_copy; - do - { - *dp32++ = *sp32++; - c -= sizeof (png_uint_32); - } - while (c > 0); - - if (row_width <= bytes_to_jump) - return; - - dp32 += skip; - sp32 += skip; - row_width -= bytes_to_jump; - } - while (bytes_to_copy <= row_width); - - /* Get to here when the row_width truncates the final copy. - * There will be 1-3 bytes left to copy, so don't try the - * 16-bit loop below. - */ - dp = (png_bytep)dp32; - sp = (png_const_bytep)sp32; - do - *dp++ = *sp++; - while (--row_width > 0); - return; - } - - /* Else do it in 16-bit quantities, but only if the size is - * not too large. - */ - else - { - png_uint_16p dp16 = (png_uint_16p)dp; - png_const_uint_16p sp16 = (png_const_uint_16p)sp; - unsigned int skip = (bytes_to_jump-bytes_to_copy) / - sizeof (png_uint_16); - - do - { - size_t c = bytes_to_copy; - do - { - *dp16++ = *sp16++; - c -= sizeof (png_uint_16); - } - while (c > 0); - - if (row_width <= bytes_to_jump) - return; - - dp16 += skip; - sp16 += skip; - row_width -= bytes_to_jump; - } - while (bytes_to_copy <= row_width); - - /* End of row - 1 byte left, bytes_to_copy > row_width: */ - dp = (png_bytep)dp16; - sp = (png_const_bytep)sp16; - do - *dp++ = *sp++; - while (--row_width > 0); - return; - } - } -#endif /* PNG_ALIGN_ code */ - - /* The true default - use a png_memcpy: */ - for (;;) - { - png_memcpy(dp, sp, bytes_to_copy); - - if (row_width <= bytes_to_jump) - return; - - sp += bytes_to_jump; - dp += bytes_to_jump; - row_width -= bytes_to_jump; - if (bytes_to_copy > row_width) - bytes_to_copy = row_width; - } - } - - /* NOT REACHED*/ - } /* pixel_depth >= 8 */ - - /* Here if pixel_depth < 8 to check 'end_ptr' below. */ - } - else -#endif - - /* If here then the switch above wasn't used so just png_memcpy the whole row - * from the temporary row buffer (notice that this overwrites the end of the - * destination row if it is a partial byte.) - */ - png_memcpy(dp, sp, PNG_ROWBYTES(pixel_depth, row_width)); - - /* Restore the overwritten bits from the last byte if necessary. */ - if (end_ptr != NULL) - *end_ptr = (png_byte)((end_byte & end_mask) | (*end_ptr & ~end_mask)); -} - -#ifdef PNG_READ_INTERLACING_SUPPORTED -void /* PRIVATE */ -png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, - png_uint_32 transformations /* Because these may affect the byte layout */) -{ - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - /* Offset to next interlace block */ - static PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; - - png_debug(1, "in png_do_read_interlace"); - if (row != NULL && row_info != NULL) - { - png_uint_32 final_width; - - final_width = row_info->width * png_pass_inc[pass]; - - switch (row_info->pixel_depth) - { - case 1: - { - png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); - png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); - int sshift, dshift; - int s_start, s_end, s_inc; - int jstop = png_pass_inc[pass]; - png_byte v; - png_uint_32 i; - int j; - -#ifdef PNG_READ_PACKSWAP_SUPPORTED - if (transformations & PNG_PACKSWAP) - { - sshift = (int)((row_info->width + 7) & 0x07); - dshift = (int)((final_width + 7) & 0x07); - s_start = 7; - s_end = 0; - s_inc = -1; - } - - else -#endif - { - sshift = 7 - (int)((row_info->width + 7) & 0x07); - dshift = 7 - (int)((final_width + 7) & 0x07); - s_start = 0; - s_end = 7; - s_inc = 1; - } - - for (i = 0; i < row_info->width; i++) - { - v = (png_byte)((*sp >> sshift) & 0x01); - for (j = 0; j < jstop; j++) - { - *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); - *dp |= (png_byte)(v << dshift); - - if (dshift == s_end) - { - dshift = s_start; - dp--; - } - - else - dshift += s_inc; - } - - if (sshift == s_end) - { - sshift = s_start; - sp--; - } - - else - sshift += s_inc; - } - break; - } - - case 2: - { - png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); - png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); - int sshift, dshift; - int s_start, s_end, s_inc; - int jstop = png_pass_inc[pass]; - png_uint_32 i; - -#ifdef PNG_READ_PACKSWAP_SUPPORTED - if (transformations & PNG_PACKSWAP) - { - sshift = (int)(((row_info->width + 3) & 0x03) << 1); - dshift = (int)(((final_width + 3) & 0x03) << 1); - s_start = 6; - s_end = 0; - s_inc = -2; - } - - else -#endif - { - sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); - dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); - s_start = 0; - s_end = 6; - s_inc = 2; - } - - for (i = 0; i < row_info->width; i++) - { - png_byte v; - int j; - - v = (png_byte)((*sp >> sshift) & 0x03); - for (j = 0; j < jstop; j++) - { - *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); - *dp |= (png_byte)(v << dshift); - - if (dshift == s_end) - { - dshift = s_start; - dp--; - } - - else - dshift += s_inc; - } - - if (sshift == s_end) - { - sshift = s_start; - sp--; - } - - else - sshift += s_inc; - } - break; - } - - case 4: - { - png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); - png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); - int sshift, dshift; - int s_start, s_end, s_inc; - png_uint_32 i; - int jstop = png_pass_inc[pass]; - -#ifdef PNG_READ_PACKSWAP_SUPPORTED - if (transformations & PNG_PACKSWAP) - { - sshift = (int)(((row_info->width + 1) & 0x01) << 2); - dshift = (int)(((final_width + 1) & 0x01) << 2); - s_start = 4; - s_end = 0; - s_inc = -4; - } - - else -#endif - { - sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); - dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); - s_start = 0; - s_end = 4; - s_inc = 4; - } - - for (i = 0; i < row_info->width; i++) - { - png_byte v = (png_byte)((*sp >> sshift) & 0x0f); - int j; - - for (j = 0; j < jstop; j++) - { - *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); - *dp |= (png_byte)(v << dshift); - - if (dshift == s_end) - { - dshift = s_start; - dp--; - } - - else - dshift += s_inc; - } - - if (sshift == s_end) - { - sshift = s_start; - sp--; - } - - else - sshift += s_inc; - } - break; - } - - default: - { - png_size_t pixel_bytes = (row_info->pixel_depth >> 3); - - png_bytep sp = row + (png_size_t)(row_info->width - 1) - * pixel_bytes; - - png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; - - int jstop = png_pass_inc[pass]; - png_uint_32 i; - - for (i = 0; i < row_info->width; i++) - { - png_byte v[8]; - int j; - - png_memcpy(v, sp, pixel_bytes); - - for (j = 0; j < jstop; j++) - { - png_memcpy(dp, v, pixel_bytes); - dp -= pixel_bytes; - } - - sp -= pixel_bytes; - } - break; - } - } - - row_info->width = final_width; - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width); - } -#ifndef PNG_READ_PACKSWAP_SUPPORTED - PNG_UNUSED(transformations) /* Silence compiler warning */ -#endif -} -#endif /* PNG_READ_INTERLACING_SUPPORTED */ - -static void -png_read_filter_row_sub(png_row_infop row_info, png_bytep row, - png_const_bytep prev_row) -{ - png_size_t i; - png_size_t istop = row_info->rowbytes; - unsigned int bpp = (row_info->pixel_depth + 7) >> 3; - png_bytep rp = row + bpp; - - PNG_UNUSED(prev_row) - - for (i = bpp; i < istop; i++) - { - *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); - rp++; - } -} - -static void -png_read_filter_row_up(png_row_infop row_info, png_bytep row, - png_const_bytep prev_row) -{ - png_size_t i; - png_size_t istop = row_info->rowbytes; - png_bytep rp = row; - png_const_bytep pp = prev_row; - - for (i = 0; i < istop; i++) - { - *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); - rp++; - } -} - -static void -png_read_filter_row_avg(png_row_infop row_info, png_bytep row, - png_const_bytep prev_row) -{ - png_size_t i; - png_bytep rp = row; - png_const_bytep pp = prev_row; - unsigned int bpp = (row_info->pixel_depth + 7) >> 3; - png_size_t istop = row_info->rowbytes - bpp; - - for (i = 0; i < bpp; i++) - { - *rp = (png_byte)(((int)(*rp) + - ((int)(*pp++) / 2 )) & 0xff); - - rp++; - } - - for (i = 0; i < istop; i++) - { - *rp = (png_byte)(((int)(*rp) + - (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); - - rp++; - } -} - -static void -png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row, - png_const_bytep prev_row) -{ - png_bytep rp_end = row + row_info->rowbytes; - int a, c; - - /* First pixel/byte */ - c = *prev_row++; - a = *row + c; - *row++ = (png_byte)a; - - /* Remainder */ - while (row < rp_end) - { - int b, pa, pb, pc, p; - - a &= 0xff; /* From previous iteration or start */ - b = *prev_row++; - - p = b - c; - pc = a - c; - -# ifdef PNG_USE_ABS - pa = abs(p); - pb = abs(pc); - pc = abs(p + pc); -# else - pa = p < 0 ? -p : p; - pb = pc < 0 ? -pc : pc; - pc = (p + pc) < 0 ? -(p + pc) : p + pc; -# endif - - /* Find the best predictor, the least of pa, pb, pc favoring the earlier - * ones in the case of a tie. - */ - if (pb < pa) pa = pb, a = b; - if (pc < pa) a = c; - - /* Calculate the current pixel in a, and move the previous row pixel to c - * for the next time round the loop - */ - c = b; - a += *row; - *row++ = (png_byte)a; - } -} - -static void -png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row, - png_const_bytep prev_row) -{ - int bpp = (row_info->pixel_depth + 7) >> 3; - png_bytep rp_end = row + bpp; - - /* Process the first pixel in the row completely (this is the same as 'up' - * because there is only one candidate predictor for the first row). - */ - while (row < rp_end) - { - int a = *row + *prev_row++; - *row++ = (png_byte)a; - } - - /* Remainder */ - rp_end += row_info->rowbytes - bpp; - - while (row < rp_end) - { - int a, b, c, pa, pb, pc, p; - - c = *(prev_row - bpp); - a = *(row - bpp); - b = *prev_row++; - - p = b - c; - pc = a - c; - -# ifdef PNG_USE_ABS - pa = abs(p); - pb = abs(pc); - pc = abs(p + pc); -# else - pa = p < 0 ? -p : p; - pb = pc < 0 ? -pc : pc; - pc = (p + pc) < 0 ? -(p + pc) : p + pc; -# endif - - if (pb < pa) pa = pb, a = b; - if (pc < pa) a = c; - - c = b; - a += *row; - *row++ = (png_byte)a; - } -} - -#ifdef PNG_ARM_NEON - -#if defined __linux__ && !defined ANDROID -#include -#include -#include - -static int png_have_hwcap(unsigned cap) -{ - FILE *f = fopen("/proc/self/auxv", "r"); - Elf32_auxv_t aux; - int have_cap = 0; - - if (!f) - return 0; - - while (fread(&aux, sizeof(aux), 1, f) > 0) - { - if (aux.a_type == AT_HWCAP && - aux.a_un.a_val & cap) - { - have_cap = 1; - break; - } - } - - fclose(f); - - return have_cap; -} -#endif /* __linux__ */ - -static void -png_init_filter_functions_neon(png_structp pp, unsigned int bpp) -{ -#if defined __linux__ && !defined ANDROID - if (!png_have_hwcap(HWCAP_NEON)) - return; -#endif - - pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_neon; - - if (bpp == 3) - { - pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_neon; - pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_neon; - pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = - png_read_filter_row_paeth3_neon; - } - - else if (bpp == 4) - { - pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_neon; - pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_neon; - pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = - png_read_filter_row_paeth4_neon; - } -} -#endif /* PNG_ARM_NEON */ - -static void -png_init_filter_functions(png_structp pp) -{ - unsigned int bpp = (pp->pixel_depth + 7) >> 3; - - pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub; - pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up; - pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg; - if (bpp == 1) - pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = - png_read_filter_row_paeth_1byte_pixel; - else - pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = - png_read_filter_row_paeth_multibyte_pixel; - -#ifdef PNG_ARM_NEON - png_init_filter_functions_neon(pp, bpp); -#endif -} - -void /* PRIVATE */ -png_read_filter_row(png_structp pp, png_row_infop row_info, png_bytep row, - png_const_bytep prev_row, int filter) -{ - if (pp->read_filter[0] == NULL) - png_init_filter_functions(pp); - if (filter > PNG_FILTER_VALUE_NONE && filter < PNG_FILTER_VALUE_LAST) - pp->read_filter[filter-1](row_info, row, prev_row); -} - -#ifdef PNG_SEQUENTIAL_READ_SUPPORTED -void /* PRIVATE */ -png_read_finish_row(png_structp png_ptr) -{ -#ifdef PNG_READ_INTERLACING_SUPPORTED - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - - /* Start of interlace block */ - static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; - - /* Offset to next interlace block */ - static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; - - /* Start of interlace block in the y direction */ - static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; - - /* Offset to next interlace block in the y direction */ - static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; -#endif /* PNG_READ_INTERLACING_SUPPORTED */ - - png_debug(1, "in png_read_finish_row"); - png_ptr->row_number++; - if (png_ptr->row_number < png_ptr->num_rows) - return; - -#ifdef PNG_READ_INTERLACING_SUPPORTED - if (png_ptr->interlaced) - { - png_ptr->row_number = 0; - - /* TO DO: don't do this if prev_row isn't needed (requires - * read-ahead of the next row's filter byte. - */ - png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); - - do - { - png_ptr->pass++; - - if (png_ptr->pass >= 7) - break; - - png_ptr->iwidth = (png_ptr->width + - png_pass_inc[png_ptr->pass] - 1 - - png_pass_start[png_ptr->pass]) / - png_pass_inc[png_ptr->pass]; - - if (!(png_ptr->transformations & PNG_INTERLACE)) - { - png_ptr->num_rows = (png_ptr->height + - png_pass_yinc[png_ptr->pass] - 1 - - png_pass_ystart[png_ptr->pass]) / - png_pass_yinc[png_ptr->pass]; - } - - else /* if (png_ptr->transformations & PNG_INTERLACE) */ - break; /* libpng deinterlacing sees every row */ - - } while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0); - - if (png_ptr->pass < 7) - return; - } -#endif /* PNG_READ_INTERLACING_SUPPORTED */ - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) - { - char extra; - int ret; - - png_ptr->zstream.next_out = (Byte *)&extra; - png_ptr->zstream.avail_out = (uInt)1; - - for (;;) - { - if (!(png_ptr->zstream.avail_in)) - { - while (!png_ptr->idat_size) - { - png_crc_finish(png_ptr, 0); - png_ptr->idat_size = png_read_chunk_header(png_ptr); - if (png_ptr->chunk_name != png_IDAT) - png_error(png_ptr, "Not enough image data"); - } - - png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; - png_ptr->zstream.next_in = png_ptr->zbuf; - - if (png_ptr->zbuf_size > png_ptr->idat_size) - png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; - - png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); - png_ptr->idat_size -= png_ptr->zstream.avail_in; - } - - ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); - - if (ret == Z_STREAM_END) - { - if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || - png_ptr->idat_size) - png_warning(png_ptr, "Extra compressed data"); - - png_ptr->mode |= PNG_AFTER_IDAT; - png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; - break; - } - - if (ret != Z_OK) - png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : - "Decompression Error"); - - if (!(png_ptr->zstream.avail_out)) - { - png_warning(png_ptr, "Extra compressed data"); - png_ptr->mode |= PNG_AFTER_IDAT; - png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; - break; - } - - } - png_ptr->zstream.avail_out = 0; - } - - if (png_ptr->idat_size || png_ptr->zstream.avail_in) - png_warning(png_ptr, "Extra compression data"); - - inflateReset(&png_ptr->zstream); - - png_ptr->mode |= PNG_AFTER_IDAT; -} -#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ - -void /* PRIVATE */ -png_read_start_row(png_structp png_ptr) -{ -#ifdef PNG_READ_INTERLACING_SUPPORTED - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - - /* Start of interlace block */ - static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; - - /* Offset to next interlace block */ - static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; - - /* Start of interlace block in the y direction */ - static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; - - /* Offset to next interlace block in the y direction */ - static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; -#endif - - int max_pixel_depth; - png_size_t row_bytes; - - png_debug(1, "in png_read_start_row"); - png_ptr->zstream.avail_in = 0; -#ifdef PNG_READ_TRANSFORMS_SUPPORTED - png_init_read_transformations(png_ptr); -#endif -#ifdef PNG_READ_INTERLACING_SUPPORTED - if (png_ptr->interlaced) - { - if (!(png_ptr->transformations & PNG_INTERLACE)) - png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - - png_pass_ystart[0]) / png_pass_yinc[0]; - - else - png_ptr->num_rows = png_ptr->height; - - png_ptr->iwidth = (png_ptr->width + - png_pass_inc[png_ptr->pass] - 1 - - png_pass_start[png_ptr->pass]) / - png_pass_inc[png_ptr->pass]; - } - - else -#endif /* PNG_READ_INTERLACING_SUPPORTED */ - { - png_ptr->num_rows = png_ptr->height; - png_ptr->iwidth = png_ptr->width; - } - - max_pixel_depth = png_ptr->pixel_depth; - - /* WARNING: * png_read_transform_info (pngrtran.c) performs a simpliar set of - * calculations to calculate the final pixel depth, then - * png_do_read_transforms actually does the transforms. This means that the - * code which effectively calculates this value is actually repeated in three - * separate places. They must all match. Innocent changes to the order of - * transformations can and will break libpng in a way that causes memory - * overwrites. - * - * TODO: fix this. - */ -#ifdef PNG_READ_PACK_SUPPORTED - if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) - max_pixel_depth = 8; -#endif - -#ifdef PNG_READ_EXPAND_SUPPORTED - if (png_ptr->transformations & PNG_EXPAND) - { - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - if (png_ptr->num_trans) - max_pixel_depth = 32; - - else - max_pixel_depth = 24; - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) - { - if (max_pixel_depth < 8) - max_pixel_depth = 8; - - if (png_ptr->num_trans) - max_pixel_depth *= 2; - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) - { - if (png_ptr->num_trans) - { - max_pixel_depth *= 4; - max_pixel_depth /= 3; - } - } - } -#endif - -#ifdef PNG_READ_EXPAND_16_SUPPORTED - if (png_ptr->transformations & PNG_EXPAND_16) - { -# ifdef PNG_READ_EXPAND_SUPPORTED - /* In fact it is an error if it isn't supported, but checking is - * the safe way. - */ - if (png_ptr->transformations & PNG_EXPAND) - { - if (png_ptr->bit_depth < 16) - max_pixel_depth *= 2; - } - else -# endif - png_ptr->transformations &= ~PNG_EXPAND_16; - } -#endif - -#ifdef PNG_READ_FILLER_SUPPORTED - if (png_ptr->transformations & (PNG_FILLER)) - { - if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) - { - if (max_pixel_depth <= 8) - max_pixel_depth = 16; - - else - max_pixel_depth = 32; - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB || - png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - if (max_pixel_depth <= 32) - max_pixel_depth = 32; - - else - max_pixel_depth = 64; - } - } -#endif - -#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED - if (png_ptr->transformations & PNG_GRAY_TO_RGB) - { - if ( -#ifdef PNG_READ_EXPAND_SUPPORTED - (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || -#endif -#ifdef PNG_READ_FILLER_SUPPORTED - (png_ptr->transformations & (PNG_FILLER)) || -#endif - png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - { - if (max_pixel_depth <= 16) - max_pixel_depth = 32; - - else - max_pixel_depth = 64; - } - - else - { - if (max_pixel_depth <= 8) - { - if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - max_pixel_depth = 32; - - else - max_pixel_depth = 24; - } - - else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - max_pixel_depth = 64; - - else - max_pixel_depth = 48; - } - } -#endif - -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ -defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) - if (png_ptr->transformations & PNG_USER_TRANSFORM) - { - int user_pixel_depth = png_ptr->user_transform_depth * - png_ptr->user_transform_channels; - - if (user_pixel_depth > max_pixel_depth) - max_pixel_depth = user_pixel_depth; - } -#endif - - /* This value is stored in png_struct and double checked in the row read - * code. - */ - png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth; - png_ptr->transformed_pixel_depth = 0; /* calculated on demand */ - - /* Align the width on the next larger 8 pixels. Mainly used - * for interlacing - */ - row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); - /* Calculate the maximum bytes needed, adding a byte and a pixel - * for safety's sake - */ - row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) + - 1 + ((max_pixel_depth + 7) >> 3); - -#ifdef PNG_MAX_MALLOC_64K - if (row_bytes > (png_uint_32)65536L) - png_error(png_ptr, "This image requires a row greater than 64KB"); -#endif - - if (row_bytes + 48 > png_ptr->old_big_row_buf_size) - { - png_free(png_ptr, png_ptr->big_row_buf); - png_free(png_ptr, png_ptr->big_prev_row); - - if (png_ptr->interlaced) - png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr, - row_bytes + 48); - - else - png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48); - - png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48); - -#ifdef PNG_ALIGNED_MEMORY_SUPPORTED - /* Use 16-byte aligned memory for row_buf with at least 16 bytes - * of padding before and after row_buf; treat prev_row similarly. - * NOTE: the alignment is to the start of the pixels, one beyond the start - * of the buffer, because of the filter byte. Prior to libpng 1.5.6 this - * was incorrect; the filter byte was aligned, which had the exact - * opposite effect of that intended. - */ - { - png_bytep temp = png_ptr->big_row_buf + 32; - int extra = (int)((temp - (png_bytep)0) & 0x0f); - png_ptr->row_buf = temp - extra - 1/*filter byte*/; - - temp = png_ptr->big_prev_row + 32; - extra = (int)((temp - (png_bytep)0) & 0x0f); - png_ptr->prev_row = temp - extra - 1/*filter byte*/; - } - -#else - /* Use 31 bytes of padding before and 17 bytes after row_buf. */ - png_ptr->row_buf = png_ptr->big_row_buf + 31; - png_ptr->prev_row = png_ptr->big_prev_row + 31; -#endif - png_ptr->old_big_row_buf_size = row_bytes + 48; - } - -#ifdef PNG_MAX_MALLOC_64K - if (png_ptr->rowbytes > 65535) - png_error(png_ptr, "This image requires a row greater than 64KB"); - -#endif - if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1)) - png_error(png_ptr, "Row has too many bytes to allocate in memory"); - - png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); - - png_debug1(3, "width = %u,", png_ptr->width); - png_debug1(3, "height = %u,", png_ptr->height); - png_debug1(3, "iwidth = %u,", png_ptr->iwidth); - png_debug1(3, "num_rows = %u,", png_ptr->num_rows); - png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes); - png_debug1(3, "irowbytes = %lu", - (unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1); - - png_ptr->flags |= PNG_FLAG_ROW_INIT; -} -#endif /* PNG_READ_SUPPORTED */ diff --git a/source/libpng/pngset.c b/source/libpng/pngset.c deleted file mode 100644 index 2bcd96d..0000000 --- a/source/libpng/pngset.c +++ /dev/null @@ -1,1309 +0,0 @@ - -/* pngset.c - storage of image information into info struct - * - * Last changed in libpng 1.5.10 [(PENDING RELEASE)] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * The functions here are used during reads to store data from the file - * into the info struct, and during writes to store application data - * into the info struct for writing into the file. This abstracts the - * info struct and allows us to change the structure in the future. - */ - -#include "pngpriv.h" - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) - -#ifdef PNG_bKGD_SUPPORTED -void PNGAPI -png_set_bKGD(png_structp png_ptr, png_infop info_ptr, - png_const_color_16p background) -{ - png_debug1(1, "in %s storage function", "bKGD"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16)); - info_ptr->valid |= PNG_INFO_bKGD; -} -#endif - -#ifdef PNG_cHRM_SUPPORTED -void PNGFAPI -png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, - png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, - png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, - png_fixed_point blue_x, png_fixed_point blue_y) -{ - png_debug1(1, "in %s storage function", "cHRM fixed"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - -# ifdef PNG_CHECK_cHRM_SUPPORTED - if (png_check_cHRM_fixed(png_ptr, - white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y)) -# endif - { - info_ptr->x_white = white_x; - info_ptr->y_white = white_y; - info_ptr->x_red = red_x; - info_ptr->y_red = red_y; - info_ptr->x_green = green_x; - info_ptr->y_green = green_y; - info_ptr->x_blue = blue_x; - info_ptr->y_blue = blue_y; - info_ptr->valid |= PNG_INFO_cHRM; - } -} - -void PNGFAPI -png_set_cHRM_XYZ_fixed(png_structp png_ptr, png_infop info_ptr, - png_fixed_point int_red_X, png_fixed_point int_red_Y, - png_fixed_point int_red_Z, png_fixed_point int_green_X, - png_fixed_point int_green_Y, png_fixed_point int_green_Z, - png_fixed_point int_blue_X, png_fixed_point int_blue_Y, - png_fixed_point int_blue_Z) -{ - png_XYZ XYZ; - png_xy xy; - - png_debug1(1, "in %s storage function", "cHRM XYZ fixed"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - XYZ.redX = int_red_X; - XYZ.redY = int_red_Y; - XYZ.redZ = int_red_Z; - XYZ.greenX = int_green_X; - XYZ.greenY = int_green_Y; - XYZ.greenZ = int_green_Z; - XYZ.blueX = int_blue_X; - XYZ.blueY = int_blue_Y; - XYZ.blueZ = int_blue_Z; - - if (png_xy_from_XYZ(&xy, XYZ)) - png_error(png_ptr, "XYZ values out of representable range"); - - png_set_cHRM_fixed(png_ptr, info_ptr, xy.whitex, xy.whitey, xy.redx, xy.redy, - xy.greenx, xy.greeny, xy.bluex, xy.bluey); -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_cHRM(png_structp png_ptr, png_infop info_ptr, - double white_x, double white_y, double red_x, double red_y, - double green_x, double green_y, double blue_x, double blue_y) -{ - png_set_cHRM_fixed(png_ptr, info_ptr, - png_fixed(png_ptr, white_x, "cHRM White X"), - png_fixed(png_ptr, white_y, "cHRM White Y"), - png_fixed(png_ptr, red_x, "cHRM Red X"), - png_fixed(png_ptr, red_y, "cHRM Red Y"), - png_fixed(png_ptr, green_x, "cHRM Green X"), - png_fixed(png_ptr, green_y, "cHRM Green Y"), - png_fixed(png_ptr, blue_x, "cHRM Blue X"), - png_fixed(png_ptr, blue_y, "cHRM Blue Y")); -} - -void PNGAPI -png_set_cHRM_XYZ(png_structp png_ptr, png_infop info_ptr, double red_X, - double red_Y, double red_Z, double green_X, double green_Y, double green_Z, - double blue_X, double blue_Y, double blue_Z) -{ - png_set_cHRM_XYZ_fixed(png_ptr, info_ptr, - png_fixed(png_ptr, red_X, "cHRM Red X"), - png_fixed(png_ptr, red_Y, "cHRM Red Y"), - png_fixed(png_ptr, red_Z, "cHRM Red Z"), - png_fixed(png_ptr, green_X, "cHRM Red X"), - png_fixed(png_ptr, green_Y, "cHRM Red Y"), - png_fixed(png_ptr, green_Z, "cHRM Red Z"), - png_fixed(png_ptr, blue_X, "cHRM Red X"), - png_fixed(png_ptr, blue_Y, "cHRM Red Y"), - png_fixed(png_ptr, blue_Z, "cHRM Red Z")); -} -# endif /* PNG_FLOATING_POINT_SUPPORTED */ - -#endif /* PNG_cHRM_SUPPORTED */ - -#ifdef PNG_gAMA_SUPPORTED -void PNGFAPI -png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point - file_gamma) -{ - png_debug1(1, "in %s storage function", "gAMA"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't - * occur. Since the fixed point representation is assymetrical it is - * possible for 1/gamma to overflow the limit of 21474 and this means the - * gamma value must be at least 5/100000 and hence at most 20000.0. For - * safety the limits here are a little narrower. The values are 0.00016 to - * 6250.0, which are truly ridiculous gammma values (and will produce - * displays that are all black or all white.) - */ - if (file_gamma < 16 || file_gamma > 625000000) - png_warning(png_ptr, "Out of range gamma value ignored"); - - else - { - info_ptr->gamma = file_gamma; - info_ptr->valid |= PNG_INFO_gAMA; - } -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) -{ - png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma, - "png_set_gAMA")); -} -# endif -#endif - -#ifdef PNG_hIST_SUPPORTED -void PNGAPI -png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_const_uint_16p hist) -{ - int i; - - png_debug1(1, "in %s storage function", "hIST"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - if (info_ptr->num_palette == 0 || info_ptr->num_palette - > PNG_MAX_PALETTE_LENGTH) - { - png_warning(png_ptr, - "Invalid palette size, hIST allocation skipped"); - - return; - } - - png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); - - /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in - * version 1.2.1 - */ - png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, - PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)); - - if (png_ptr->hist == NULL) - { - png_warning(png_ptr, "Insufficient memory for hIST chunk data"); - return; - } - - for (i = 0; i < info_ptr->num_palette; i++) - png_ptr->hist[i] = hist[i]; - - info_ptr->hist = png_ptr->hist; - info_ptr->valid |= PNG_INFO_hIST; - info_ptr->free_me |= PNG_FREE_HIST; -} -#endif - -void PNGAPI -png_set_IHDR(png_structp png_ptr, png_infop info_ptr, - png_uint_32 width, png_uint_32 height, int bit_depth, - int color_type, int interlace_type, int compression_type, - int filter_type) -{ - png_debug1(1, "in %s storage function", "IHDR"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - info_ptr->width = width; - info_ptr->height = height; - info_ptr->bit_depth = (png_byte)bit_depth; - info_ptr->color_type = (png_byte)color_type; - info_ptr->compression_type = (png_byte)compression_type; - info_ptr->filter_type = (png_byte)filter_type; - info_ptr->interlace_type = (png_byte)interlace_type; - - png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height, - info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, - info_ptr->compression_type, info_ptr->filter_type); - - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - info_ptr->channels = 1; - - else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) - info_ptr->channels = 3; - - else - info_ptr->channels = 1; - - if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) - info_ptr->channels++; - - info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); - - /* Check for potential overflow */ - if (width > - (PNG_UINT_32_MAX >> 3) /* 8-byte RRGGBBAA pixels */ - - 48 /* bigrowbuf hack */ - - 1 /* filter byte */ - - 7*8 /* rounding of width to multiple of 8 pixels */ - - 8) /* extra max_pixel_depth pad */ - info_ptr->rowbytes = 0; - else - info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width); -} - -#ifdef PNG_oFFs_SUPPORTED -void PNGAPI -png_set_oFFs(png_structp png_ptr, png_infop info_ptr, - png_int_32 offset_x, png_int_32 offset_y, int unit_type) -{ - png_debug1(1, "in %s storage function", "oFFs"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - info_ptr->x_offset = offset_x; - info_ptr->y_offset = offset_y; - info_ptr->offset_unit_type = (png_byte)unit_type; - info_ptr->valid |= PNG_INFO_oFFs; -} -#endif - -#ifdef PNG_pCAL_SUPPORTED -void PNGAPI -png_set_pCAL(png_structp png_ptr, png_infop info_ptr, - png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, - int nparams, png_const_charp units, png_charpp params) -{ - png_size_t length; - int i; - - png_debug1(1, "in %s storage function", "pCAL"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - length = png_strlen(purpose) + 1; - png_debug1(3, "allocating purpose for info (%lu bytes)", - (unsigned long)length); - - /* TODO: validate format of calibration name and unit name */ - - /* Check that the type matches the specification. */ - if (type < 0 || type > 3) - png_error(png_ptr, "Invalid pCAL equation type"); - - /* Validate params[nparams] */ - for (i=0; ipcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); - - if (info_ptr->pcal_purpose == NULL) - { - png_warning(png_ptr, "Insufficient memory for pCAL purpose"); - return; - } - - png_memcpy(info_ptr->pcal_purpose, purpose, length); - - png_debug(3, "storing X0, X1, type, and nparams in info"); - info_ptr->pcal_X0 = X0; - info_ptr->pcal_X1 = X1; - info_ptr->pcal_type = (png_byte)type; - info_ptr->pcal_nparams = (png_byte)nparams; - - length = png_strlen(units) + 1; - png_debug1(3, "allocating units for info (%lu bytes)", - (unsigned long)length); - - info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length); - - if (info_ptr->pcal_units == NULL) - { - png_warning(png_ptr, "Insufficient memory for pCAL units"); - return; - } - - png_memcpy(info_ptr->pcal_units, units, length); - - info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, - (png_size_t)((nparams + 1) * png_sizeof(png_charp))); - - if (info_ptr->pcal_params == NULL) - { - png_warning(png_ptr, "Insufficient memory for pCAL params"); - return; - } - - png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp)); - - for (i = 0; i < nparams; i++) - { - length = png_strlen(params[i]) + 1; - png_debug2(3, "allocating parameter %d for info (%lu bytes)", i, - (unsigned long)length); - - info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length); - - if (info_ptr->pcal_params[i] == NULL) - { - png_warning(png_ptr, "Insufficient memory for pCAL parameter"); - return; - } - - png_memcpy(info_ptr->pcal_params[i], params[i], length); - } - - info_ptr->valid |= PNG_INFO_pCAL; - info_ptr->free_me |= PNG_FREE_PCAL; -} -#endif - -#ifdef PNG_sCAL_SUPPORTED -void PNGAPI -png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, - int unit, png_const_charp swidth, png_const_charp sheight) -{ - png_size_t lengthw = 0, lengthh = 0; - - png_debug1(1, "in %s storage function", "sCAL"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - /* Double check the unit (should never get here with an invalid - * unit unless this is an API call.) - */ - if (unit != 1 && unit != 2) - png_error(png_ptr, "Invalid sCAL unit"); - - if (swidth == NULL || (lengthw = png_strlen(swidth)) == 0 || - swidth[0] == 45 /* '-' */ || !png_check_fp_string(swidth, lengthw)) - png_error(png_ptr, "Invalid sCAL width"); - - if (sheight == NULL || (lengthh = png_strlen(sheight)) == 0 || - sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh)) - png_error(png_ptr, "Invalid sCAL height"); - - info_ptr->scal_unit = (png_byte)unit; - - ++lengthw; - - png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw); - - info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, lengthw); - - if (info_ptr->scal_s_width == NULL) - { - png_warning(png_ptr, "Memory allocation failed while processing sCAL"); - return; - } - - png_memcpy(info_ptr->scal_s_width, swidth, lengthw); - - ++lengthh; - - png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh); - - info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, lengthh); - - if (info_ptr->scal_s_height == NULL) - { - png_free (png_ptr, info_ptr->scal_s_width); - info_ptr->scal_s_width = NULL; - - png_warning(png_ptr, "Memory allocation failed while processing sCAL"); - return; - } - - png_memcpy(info_ptr->scal_s_height, sheight, lengthh); - - info_ptr->valid |= PNG_INFO_sCAL; - info_ptr->free_me |= PNG_FREE_SCAL; -} - -# ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_sCAL(png_structp png_ptr, png_infop info_ptr, int unit, double width, - double height) -{ - png_debug1(1, "in %s storage function", "sCAL"); - - /* Check the arguments. */ - if (width <= 0) - png_warning(png_ptr, "Invalid sCAL width ignored"); - - else if (height <= 0) - png_warning(png_ptr, "Invalid sCAL height ignored"); - - else - { - /* Convert 'width' and 'height' to ASCII. */ - char swidth[PNG_sCAL_MAX_DIGITS+1]; - char sheight[PNG_sCAL_MAX_DIGITS+1]; - - png_ascii_from_fp(png_ptr, swidth, sizeof swidth, width, - PNG_sCAL_PRECISION); - png_ascii_from_fp(png_ptr, sheight, sizeof sheight, height, - PNG_sCAL_PRECISION); - - png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); - } -} -# endif - -# ifdef PNG_FIXED_POINT_SUPPORTED -void PNGAPI -png_set_sCAL_fixed(png_structp png_ptr, png_infop info_ptr, int unit, - png_fixed_point width, png_fixed_point height) -{ - png_debug1(1, "in %s storage function", "sCAL"); - - /* Check the arguments. */ - if (width <= 0) - png_warning(png_ptr, "Invalid sCAL width ignored"); - - else if (height <= 0) - png_warning(png_ptr, "Invalid sCAL height ignored"); - - else - { - /* Convert 'width' and 'height' to ASCII. */ - char swidth[PNG_sCAL_MAX_DIGITS+1]; - char sheight[PNG_sCAL_MAX_DIGITS+1]; - - png_ascii_from_fixed(png_ptr, swidth, sizeof swidth, width); - png_ascii_from_fixed(png_ptr, sheight, sizeof sheight, height); - - png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); - } -} -# endif -#endif - -#ifdef PNG_pHYs_SUPPORTED -void PNGAPI -png_set_pHYs(png_structp png_ptr, png_infop info_ptr, - png_uint_32 res_x, png_uint_32 res_y, int unit_type) -{ - png_debug1(1, "in %s storage function", "pHYs"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - info_ptr->x_pixels_per_unit = res_x; - info_ptr->y_pixels_per_unit = res_y; - info_ptr->phys_unit_type = (png_byte)unit_type; - info_ptr->valid |= PNG_INFO_pHYs; -} -#endif - -void PNGAPI -png_set_PLTE(png_structp png_ptr, png_infop info_ptr, - png_const_colorp palette, int num_palette) -{ - - png_debug1(1, "in %s storage function", "PLTE"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH) - { - if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - png_error(png_ptr, "Invalid palette length"); - - else - { - png_warning(png_ptr, "Invalid palette length"); - return; - } - } - - /* It may not actually be necessary to set png_ptr->palette here; - * we do it for backward compatibility with the way the png_handle_tRNS - * function used to do the allocation. - */ - png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); - - /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead - * of num_palette entries, in case of an invalid PNG file that has - * too-large sample values. - */ - png_ptr->palette = (png_colorp)png_calloc(png_ptr, - PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color)); - - png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color)); - info_ptr->palette = png_ptr->palette; - info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; - - info_ptr->free_me |= PNG_FREE_PLTE; - - info_ptr->valid |= PNG_INFO_PLTE; -} - -#ifdef PNG_sBIT_SUPPORTED -void PNGAPI -png_set_sBIT(png_structp png_ptr, png_infop info_ptr, - png_const_color_8p sig_bit) -{ - png_debug1(1, "in %s storage function", "sBIT"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8)); - info_ptr->valid |= PNG_INFO_sBIT; -} -#endif - -#ifdef PNG_sRGB_SUPPORTED -void PNGAPI -png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int srgb_intent) -{ - png_debug1(1, "in %s storage function", "sRGB"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - info_ptr->srgb_intent = (png_byte)srgb_intent; - info_ptr->valid |= PNG_INFO_sRGB; -} - -void PNGAPI -png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, - int srgb_intent) -{ - png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - png_set_sRGB(png_ptr, info_ptr, srgb_intent); - -# ifdef PNG_gAMA_SUPPORTED - png_set_gAMA_fixed(png_ptr, info_ptr, PNG_GAMMA_sRGB_INVERSE); -# endif - -# ifdef PNG_cHRM_SUPPORTED - png_set_cHRM_fixed(png_ptr, info_ptr, - /* color x y */ - /* white */ 31270, 32900, - /* red */ 64000, 33000, - /* green */ 30000, 60000, - /* blue */ 15000, 6000 - ); -# endif /* cHRM */ -} -#endif /* sRGB */ - - -#ifdef PNG_iCCP_SUPPORTED -void PNGAPI -png_set_iCCP(png_structp png_ptr, png_infop info_ptr, - png_const_charp name, int compression_type, - png_const_bytep profile, png_uint_32 proflen) -{ - png_charp new_iccp_name; - png_bytep new_iccp_profile; - png_size_t length; - - png_debug1(1, "in %s storage function", "iCCP"); - - if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) - return; - - length = png_strlen(name)+1; - new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length); - - if (new_iccp_name == NULL) - { - png_warning(png_ptr, "Insufficient memory to process iCCP chunk"); - return; - } - - png_memcpy(new_iccp_name, name, length); - new_iccp_profile = (png_bytep)png_malloc_warn(png_ptr, proflen); - - if (new_iccp_profile == NULL) - { - png_free (png_ptr, new_iccp_name); - png_warning(png_ptr, - "Insufficient memory to process iCCP profile"); - return; - } - - png_memcpy(new_iccp_profile, profile, (png_size_t)proflen); - - png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0); - - info_ptr->iccp_proflen = proflen; - info_ptr->iccp_name = new_iccp_name; - info_ptr->iccp_profile = new_iccp_profile; - /* Compression is always zero but is here so the API and info structure - * does not have to change if we introduce multiple compression types - */ - info_ptr->iccp_compression = (png_byte)compression_type; - info_ptr->free_me |= PNG_FREE_ICCP; - info_ptr->valid |= PNG_INFO_iCCP; -} -#endif - -#ifdef PNG_TEXT_SUPPORTED -void PNGAPI -png_set_text(png_structp png_ptr, png_infop info_ptr, png_const_textp text_ptr, - int num_text) -{ - int ret; - ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); - - if (ret) - png_error(png_ptr, "Insufficient memory to store text"); -} - -int /* PRIVATE */ -png_set_text_2(png_structp png_ptr, png_infop info_ptr, - png_const_textp text_ptr, int num_text) -{ - int i; - - png_debug1(1, "in %lx storage function", png_ptr == NULL ? "unexpected" : - (unsigned long)png_ptr->chunk_name); - - if (png_ptr == NULL || info_ptr == NULL || num_text == 0) - return(0); - - /* Make sure we have enough space in the "text" array in info_struct - * to hold all of the incoming text_ptr objects. - */ - if (info_ptr->num_text + num_text > info_ptr->max_text) - { - int old_max_text = info_ptr->max_text; - int old_num_text = info_ptr->num_text; - - if (info_ptr->text != NULL) - { - png_textp old_text; - - info_ptr->max_text = info_ptr->num_text + num_text + 8; - old_text = info_ptr->text; - - info_ptr->text = (png_textp)png_malloc_warn(png_ptr, - (png_size_t)(info_ptr->max_text * png_sizeof(png_text))); - - if (info_ptr->text == NULL) - { - /* Restore to previous condition */ - info_ptr->max_text = old_max_text; - info_ptr->text = old_text; - return(1); - } - - png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max_text * - png_sizeof(png_text))); - png_free(png_ptr, old_text); - } - - else - { - info_ptr->max_text = num_text + 8; - info_ptr->num_text = 0; - info_ptr->text = (png_textp)png_malloc_warn(png_ptr, - (png_size_t)(info_ptr->max_text * png_sizeof(png_text))); - if (info_ptr->text == NULL) - { - /* Restore to previous condition */ - info_ptr->num_text = old_num_text; - info_ptr->max_text = old_max_text; - return(1); - } - info_ptr->free_me |= PNG_FREE_TEXT; - } - - png_debug1(3, "allocated %d entries for info_ptr->text", - info_ptr->max_text); - } - for (i = 0; i < num_text; i++) - { - png_size_t text_length, key_len; - png_size_t lang_len, lang_key_len; - png_textp textp = &(info_ptr->text[info_ptr->num_text]); - - if (text_ptr[i].key == NULL) - continue; - - if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE || - text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST) - { - png_warning(png_ptr, "text compression mode is out of range"); - continue; - } - - key_len = png_strlen(text_ptr[i].key); - - if (text_ptr[i].compression <= 0) - { - lang_len = 0; - lang_key_len = 0; - } - - else -# ifdef PNG_iTXt_SUPPORTED - { - /* Set iTXt data */ - - if (text_ptr[i].lang != NULL) - lang_len = png_strlen(text_ptr[i].lang); - - else - lang_len = 0; - - if (text_ptr[i].lang_key != NULL) - lang_key_len = png_strlen(text_ptr[i].lang_key); - - else - lang_key_len = 0; - } -# else /* PNG_iTXt_SUPPORTED */ - { - png_warning(png_ptr, "iTXt chunk not supported"); - continue; - } -# endif - - if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0') - { - text_length = 0; -# ifdef PNG_iTXt_SUPPORTED - if (text_ptr[i].compression > 0) - textp->compression = PNG_ITXT_COMPRESSION_NONE; - - else -# endif - textp->compression = PNG_TEXT_COMPRESSION_NONE; - } - - else - { - text_length = png_strlen(text_ptr[i].text); - textp->compression = text_ptr[i].compression; - } - - textp->key = (png_charp)png_malloc_warn(png_ptr, - (png_size_t) - (key_len + text_length + lang_len + lang_key_len + 4)); - - if (textp->key == NULL) - return(1); - - png_debug2(2, "Allocated %lu bytes at %p in png_set_text", - (unsigned long)(png_uint_32) - (key_len + lang_len + lang_key_len + text_length + 4), - textp->key); - - png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len)); - *(textp->key + key_len) = '\0'; - - if (text_ptr[i].compression > 0) - { - textp->lang = textp->key + key_len + 1; - png_memcpy(textp->lang, text_ptr[i].lang, lang_len); - *(textp->lang + lang_len) = '\0'; - textp->lang_key = textp->lang + lang_len + 1; - png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); - *(textp->lang_key + lang_key_len) = '\0'; - textp->text = textp->lang_key + lang_key_len + 1; - } - - else - { - textp->lang=NULL; - textp->lang_key=NULL; - textp->text = textp->key + key_len + 1; - } - - if (text_length) - png_memcpy(textp->text, text_ptr[i].text, - (png_size_t)(text_length)); - - *(textp->text + text_length) = '\0'; - -# ifdef PNG_iTXt_SUPPORTED - if (textp->compression > 0) - { - textp->text_length = 0; - textp->itxt_length = text_length; - } - - else -# endif - { - textp->text_length = text_length; - textp->itxt_length = 0; - } - - info_ptr->num_text++; - png_debug1(3, "transferred text chunk %d", info_ptr->num_text); - } - return(0); -} -#endif - -#ifdef PNG_tIME_SUPPORTED -void PNGAPI -png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time) -{ - png_debug1(1, "in %s storage function", "tIME"); - - if (png_ptr == NULL || info_ptr == NULL || - (png_ptr->mode & PNG_WROTE_tIME)) - return; - - if (mod_time->month == 0 || mod_time->month > 12 || - mod_time->day == 0 || mod_time->day > 31 || - mod_time->hour > 23 || mod_time->minute > 59 || - mod_time->second > 60) - { - png_warning(png_ptr, "Ignoring invalid time value"); - return; - } - - png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time)); - info_ptr->valid |= PNG_INFO_tIME; -} -#endif - -#ifdef PNG_tRNS_SUPPORTED -void PNGAPI -png_set_tRNS(png_structp png_ptr, png_infop info_ptr, - png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color) -{ - png_debug1(1, "in %s storage function", "tRNS"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - if (trans_alpha != NULL) - { - /* It may not actually be necessary to set png_ptr->trans_alpha here; - * we do it for backward compatibility with the way the png_handle_tRNS - * function used to do the allocation. - */ - - png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); - - /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */ - png_ptr->trans_alpha = info_ptr->trans_alpha = - (png_bytep)png_malloc(png_ptr, (png_size_t)PNG_MAX_PALETTE_LENGTH); - - if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH) - png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans); - } - - if (trans_color != NULL) - { - int sample_max = (1 << info_ptr->bit_depth); - - if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY && - (int)trans_color->gray > sample_max) || - (info_ptr->color_type == PNG_COLOR_TYPE_RGB && - ((int)trans_color->red > sample_max || - (int)trans_color->green > sample_max || - (int)trans_color->blue > sample_max))) - png_warning(png_ptr, - "tRNS chunk has out-of-range samples for bit_depth"); - - png_memcpy(&(info_ptr->trans_color), trans_color, - png_sizeof(png_color_16)); - - if (num_trans == 0) - num_trans = 1; - } - - info_ptr->num_trans = (png_uint_16)num_trans; - - if (num_trans != 0) - { - info_ptr->valid |= PNG_INFO_tRNS; - info_ptr->free_me |= PNG_FREE_TRNS; - } -} -#endif - -#ifdef PNG_sPLT_SUPPORTED -void PNGAPI -png_set_sPLT(png_structp png_ptr, - png_infop info_ptr, png_const_sPLT_tp entries, int nentries) -/* - * entries - array of png_sPLT_t structures - * to be added to the list of palettes - * in the info structure. - * - * nentries - number of palette structures to be - * added. - */ -{ - png_sPLT_tp np; - int i; - - if (png_ptr == NULL || info_ptr == NULL) - return; - - np = (png_sPLT_tp)png_malloc_warn(png_ptr, - (info_ptr->splt_palettes_num + nentries) * - (png_size_t)png_sizeof(png_sPLT_t)); - - if (np == NULL) - { - png_warning(png_ptr, "No memory for sPLT palettes"); - return; - } - - png_memcpy(np, info_ptr->splt_palettes, - info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t)); - - png_free(png_ptr, info_ptr->splt_palettes); - info_ptr->splt_palettes=NULL; - - for (i = 0; i < nentries; i++) - { - png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; - png_const_sPLT_tp from = entries + i; - png_size_t length; - - length = png_strlen(from->name) + 1; - to->name = (png_charp)png_malloc_warn(png_ptr, length); - - if (to->name == NULL) - { - png_warning(png_ptr, - "Out of memory while processing sPLT chunk"); - continue; - } - - png_memcpy(to->name, from->name, length); - to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr, - from->nentries * png_sizeof(png_sPLT_entry)); - - if (to->entries == NULL) - { - png_warning(png_ptr, - "Out of memory while processing sPLT chunk"); - png_free(png_ptr, to->name); - to->name = NULL; - continue; - } - - png_memcpy(to->entries, from->entries, - from->nentries * png_sizeof(png_sPLT_entry)); - - to->nentries = from->nentries; - to->depth = from->depth; - } - - info_ptr->splt_palettes = np; - info_ptr->splt_palettes_num += nentries; - info_ptr->valid |= PNG_INFO_sPLT; - info_ptr->free_me |= PNG_FREE_SPLT; -} -#endif /* PNG_sPLT_SUPPORTED */ - -#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED -void PNGAPI -png_set_unknown_chunks(png_structp png_ptr, - png_infop info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns) -{ - png_unknown_chunkp np; - int i; - - if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) - return; - - np = (png_unknown_chunkp)png_malloc_warn(png_ptr, - (png_size_t)(info_ptr->unknown_chunks_num + num_unknowns) * - png_sizeof(png_unknown_chunk)); - - if (np == NULL) - { - png_warning(png_ptr, - "Out of memory while processing unknown chunk"); - return; - } - - png_memcpy(np, info_ptr->unknown_chunks, - (png_size_t)info_ptr->unknown_chunks_num * - png_sizeof(png_unknown_chunk)); - - png_free(png_ptr, info_ptr->unknown_chunks); - info_ptr->unknown_chunks = NULL; - - for (i = 0; i < num_unknowns; i++) - { - png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; - png_const_unknown_chunkp from = unknowns + i; - - png_memcpy(to->name, from->name, png_sizeof(from->name)); - to->name[png_sizeof(to->name)-1] = '\0'; - to->size = from->size; - - /* Note our location in the read or write sequence */ - to->location = (png_byte)(png_ptr->mode & 0xff); - - if (from->size == 0) - to->data=NULL; - - else - { - to->data = (png_bytep)png_malloc_warn(png_ptr, - (png_size_t)from->size); - - if (to->data == NULL) - { - png_warning(png_ptr, - "Out of memory while processing unknown chunk"); - to->size = 0; - } - - else - png_memcpy(to->data, from->data, from->size); - } - } - - info_ptr->unknown_chunks = np; - info_ptr->unknown_chunks_num += num_unknowns; - info_ptr->free_me |= PNG_FREE_UNKN; -} - -void PNGAPI -png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, - int chunk, int location) -{ - if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < - info_ptr->unknown_chunks_num) - info_ptr->unknown_chunks[chunk].location = (png_byte)location; -} -#endif - - -#ifdef PNG_MNG_FEATURES_SUPPORTED -png_uint_32 PNGAPI -png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features) -{ - png_debug(1, "in png_permit_mng_features"); - - if (png_ptr == NULL) - return (png_uint_32)0; - - png_ptr->mng_features_permitted = - (png_byte)(mng_features & PNG_ALL_MNG_FEATURES); - - return (png_uint_32)png_ptr->mng_features_permitted; -} -#endif - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -void PNGAPI -png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_const_bytep - chunk_list, int num_chunks) -{ - png_bytep new_list, p; - int i, old_num_chunks; - if (png_ptr == NULL) - return; - - if (num_chunks == 0) - { - if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE) - png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; - - else - png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; - - if (keep == PNG_HANDLE_CHUNK_ALWAYS) - png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; - - else - png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; - - return; - } - - if (chunk_list == NULL) - return; - - old_num_chunks = png_ptr->num_chunk_list; - new_list=(png_bytep)png_malloc(png_ptr, - (png_size_t)(5*(num_chunks + old_num_chunks))); - - if (png_ptr->chunk_list != NULL) - { - png_memcpy(new_list, png_ptr->chunk_list, - (png_size_t)(5*old_num_chunks)); - png_free(png_ptr, png_ptr->chunk_list); - png_ptr->chunk_list=NULL; - } - - png_memcpy(new_list + 5*old_num_chunks, chunk_list, - (png_size_t)(5*num_chunks)); - - for (p = new_list + 5*old_num_chunks + 4, i = 0; inum_chunk_list = old_num_chunks + num_chunks; - png_ptr->chunk_list = new_list; - png_ptr->free_me |= PNG_FREE_LIST; -} -#endif - -#ifdef PNG_READ_USER_CHUNKS_SUPPORTED -void PNGAPI -png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, - png_user_chunk_ptr read_user_chunk_fn) -{ - png_debug(1, "in png_set_read_user_chunk_fn"); - - if (png_ptr == NULL) - return; - - png_ptr->read_user_chunk_fn = read_user_chunk_fn; - png_ptr->user_chunk_ptr = user_chunk_ptr; -} -#endif - -#ifdef PNG_INFO_IMAGE_SUPPORTED -void PNGAPI -png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers) -{ - png_debug1(1, "in %s storage function", "rows"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers)) - png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); - - info_ptr->row_pointers = row_pointers; - - if (row_pointers) - info_ptr->valid |= PNG_INFO_IDAT; -} -#endif - -void PNGAPI -png_set_compression_buffer_size(png_structp png_ptr, png_size_t size) -{ - if (png_ptr == NULL) - return; - - png_free(png_ptr, png_ptr->zbuf); - - if (size > ZLIB_IO_MAX) - { - png_warning(png_ptr, "Attempt to set buffer size beyond max ignored"); - png_ptr->zbuf_size = ZLIB_IO_MAX; - size = ZLIB_IO_MAX; /* must fit */ - } - - else - png_ptr->zbuf_size = (uInt)size; - - png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); - - /* The following ensures a relatively safe failure if this gets called while - * the buffer is actually in use. - */ - png_ptr->zstream.next_out = png_ptr->zbuf; - png_ptr->zstream.avail_out = 0; - png_ptr->zstream.avail_in = 0; -} - -void PNGAPI -png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) -{ - if (png_ptr && info_ptr) - info_ptr->valid &= ~mask; -} - - - -#ifdef PNG_SET_USER_LIMITS_SUPPORTED -/* This function was added to libpng 1.2.6 */ -void PNGAPI -png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, - png_uint_32 user_height_max) -{ - /* Images with dimensions larger than these limits will be - * rejected by png_set_IHDR(). To accept any PNG datastream - * regardless of dimensions, set both limits to 0x7ffffffL. - */ - if (png_ptr == NULL) - return; - - png_ptr->user_width_max = user_width_max; - png_ptr->user_height_max = user_height_max; -} - -/* This function was added to libpng 1.4.0 */ -void PNGAPI -png_set_chunk_cache_max (png_structp png_ptr, - png_uint_32 user_chunk_cache_max) -{ - if (png_ptr) - png_ptr->user_chunk_cache_max = user_chunk_cache_max; -} - -/* This function was added to libpng 1.4.1 */ -void PNGAPI -png_set_chunk_malloc_max (png_structp png_ptr, - png_alloc_size_t user_chunk_malloc_max) -{ - if (png_ptr) - png_ptr->user_chunk_malloc_max = user_chunk_malloc_max; -} -#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ - - -#ifdef PNG_BENIGN_ERRORS_SUPPORTED -void PNGAPI -png_set_benign_errors(png_structp png_ptr, int allowed) -{ - png_debug(1, "in png_set_benign_errors"); - - if (allowed) - png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; - - else - png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN; -} -#endif /* PNG_BENIGN_ERRORS_SUPPORTED */ - -#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED - /* Do not report invalid palette index; added at libng-1.5.10 */ -void PNGAPI -png_set_check_for_invalid_index(png_structp png_ptr, int allowed) -{ - png_debug(1, "in png_set_check_for_invalid_index"); - - if (allowed) - png_ptr->num_palette_max = 0; - - else - png_ptr->num_palette_max = -1; -} -#endif - -#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngtrans.c b/source/libpng/pngtrans.c deleted file mode 100644 index 9748b18..0000000 --- a/source/libpng/pngtrans.c +++ /dev/null @@ -1,781 +0,0 @@ - -/* pngtrans.c - transforms the data in a row (used by both readers and writers) - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -#include "pngpriv.h" - -#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) - -#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) -/* Turn on BGR-to-RGB mapping */ -void PNGAPI -png_set_bgr(png_structp png_ptr) -{ - png_debug(1, "in png_set_bgr"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_BGR; -} -#endif - -#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) -/* Turn on 16 bit byte swapping */ -void PNGAPI -png_set_swap(png_structp png_ptr) -{ - png_debug(1, "in png_set_swap"); - - if (png_ptr == NULL) - return; - - if (png_ptr->bit_depth == 16) - png_ptr->transformations |= PNG_SWAP_BYTES; -} -#endif - -#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) -/* Turn on pixel packing */ -void PNGAPI -png_set_packing(png_structp png_ptr) -{ - png_debug(1, "in png_set_packing"); - - if (png_ptr == NULL) - return; - - if (png_ptr->bit_depth < 8) - { - png_ptr->transformations |= PNG_PACK; - png_ptr->usr_bit_depth = 8; - } -} -#endif - -#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) -/* Turn on packed pixel swapping */ -void PNGAPI -png_set_packswap(png_structp png_ptr) -{ - png_debug(1, "in png_set_packswap"); - - if (png_ptr == NULL) - return; - - if (png_ptr->bit_depth < 8) - png_ptr->transformations |= PNG_PACKSWAP; -} -#endif - -#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) -void PNGAPI -png_set_shift(png_structp png_ptr, png_const_color_8p true_bits) -{ - png_debug(1, "in png_set_shift"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_SHIFT; - png_ptr->shift = *true_bits; -} -#endif - -#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ - defined(PNG_WRITE_INTERLACING_SUPPORTED) -int PNGAPI -png_set_interlace_handling(png_structp png_ptr) -{ - png_debug(1, "in png_set_interlace handling"); - - if (png_ptr && png_ptr->interlaced) - { - png_ptr->transformations |= PNG_INTERLACE; - return (7); - } - - return (1); -} -#endif - -#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) -/* Add a filler byte on read, or remove a filler or alpha byte on write. - * The filler type has changed in v0.95 to allow future 2-byte fillers - * for 48-bit input data, as well as to avoid problems with some compilers - * that don't like bytes as parameters. - */ -void PNGAPI -png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) -{ - png_debug(1, "in png_set_filler"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_FILLER; - png_ptr->filler = (png_uint_16)filler; - - if (filler_loc == PNG_FILLER_AFTER) - png_ptr->flags |= PNG_FLAG_FILLER_AFTER; - - else - png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; - - /* This should probably go in the "do_read_filler" routine. - * I attempted to do that in libpng-1.0.1a but that caused problems - * so I restored it in libpng-1.0.2a - */ - - if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) - { - png_ptr->usr_channels = 4; - } - - /* Also I added this in libpng-1.0.2a (what happens when we expand - * a less-than-8-bit grayscale to GA?) */ - - if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8) - { - png_ptr->usr_channels = 2; - } -} - -/* Added to libpng-1.2.7 */ -void PNGAPI -png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) -{ - png_debug(1, "in png_set_add_alpha"); - - if (png_ptr == NULL) - return; - - png_set_filler(png_ptr, filler, filler_loc); - png_ptr->transformations |= PNG_ADD_ALPHA; -} - -#endif - -#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ - defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) -void PNGAPI -png_set_swap_alpha(png_structp png_ptr) -{ - png_debug(1, "in png_set_swap_alpha"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_SWAP_ALPHA; -} -#endif - -#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ - defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -void PNGAPI -png_set_invert_alpha(png_structp png_ptr) -{ - png_debug(1, "in png_set_invert_alpha"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_INVERT_ALPHA; -} -#endif - -#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) -void PNGAPI -png_set_invert_mono(png_structp png_ptr) -{ - png_debug(1, "in png_set_invert_mono"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_INVERT_MONO; -} - -/* Invert monochrome grayscale data */ -void /* PRIVATE */ -png_do_invert(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_invert"); - - /* This test removed from libpng version 1.0.13 and 1.2.0: - * if (row_info->bit_depth == 1 && - */ - if (row_info->color_type == PNG_COLOR_TYPE_GRAY) - { - png_bytep rp = row; - png_size_t i; - png_size_t istop = row_info->rowbytes; - - for (i = 0; i < istop; i++) - { - *rp = (png_byte)(~(*rp)); - rp++; - } - } - - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && - row_info->bit_depth == 8) - { - png_bytep rp = row; - png_size_t i; - png_size_t istop = row_info->rowbytes; - - for (i = 0; i < istop; i += 2) - { - *rp = (png_byte)(~(*rp)); - rp += 2; - } - } - -#ifdef PNG_16BIT_SUPPORTED - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && - row_info->bit_depth == 16) - { - png_bytep rp = row; - png_size_t i; - png_size_t istop = row_info->rowbytes; - - for (i = 0; i < istop; i += 4) - { - *rp = (png_byte)(~(*rp)); - *(rp + 1) = (png_byte)(~(*(rp + 1))); - rp += 4; - } - } -#endif -} -#endif - -#ifdef PNG_16BIT_SUPPORTED -#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) -/* Swaps byte order on 16 bit depth images */ -void /* PRIVATE */ -png_do_swap(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_swap"); - - if (row_info->bit_depth == 16) - { - png_bytep rp = row; - png_uint_32 i; - png_uint_32 istop= row_info->width * row_info->channels; - - for (i = 0; i < istop; i++, rp += 2) - { - png_byte t = *rp; - *rp = *(rp + 1); - *(rp + 1) = t; - } - } -} -#endif -#endif - -#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) -static PNG_CONST png_byte onebppswaptable[256] = { - 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, - 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, - 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, - 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, - 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, - 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, - 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, - 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, - 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, - 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, - 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, - 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, - 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, - 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, - 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, - 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, - 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, - 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, - 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, - 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, - 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, - 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, - 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, - 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, - 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, - 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, - 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, - 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, - 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, - 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, - 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, - 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF -}; - -static PNG_CONST png_byte twobppswaptable[256] = { - 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, - 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, - 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, - 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4, - 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8, - 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8, - 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC, - 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC, - 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1, - 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1, - 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5, - 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5, - 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9, - 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9, - 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD, - 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD, - 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2, - 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2, - 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6, - 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6, - 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA, - 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA, - 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE, - 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE, - 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3, - 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3, - 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7, - 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7, - 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB, - 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB, - 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF, - 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF -}; - -static PNG_CONST png_byte fourbppswaptable[256] = { - 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, - 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, - 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, - 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1, - 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, - 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2, - 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, - 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3, - 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, - 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4, - 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, - 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5, - 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, - 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6, - 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, - 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7, - 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, - 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8, - 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, - 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9, - 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A, - 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA, - 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B, - 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB, - 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, - 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC, - 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D, - 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD, - 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E, - 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE, - 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F, - 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF -}; - -/* Swaps pixel packing order within bytes */ -void /* PRIVATE */ -png_do_packswap(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_packswap"); - - if (row_info->bit_depth < 8) - { - png_bytep rp; - png_const_bytep end, table; - - end = row + row_info->rowbytes; - - if (row_info->bit_depth == 1) - table = onebppswaptable; - - else if (row_info->bit_depth == 2) - table = twobppswaptable; - - else if (row_info->bit_depth == 4) - table = fourbppswaptable; - - else - return; - - for (rp = row; rp < end; rp++) - *rp = table[*rp]; - } -} -#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */ - -#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ - defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -/* Remove a channel - this used to be 'png_do_strip_filler' but it used a - * somewhat weird combination of flags to determine what to do. All the calls - * to png_do_strip_filler are changed in 1.5.2 to call this instead with the - * correct arguments. - * - * The routine isn't general - the channel must be the channel at the start or - * end (not in the middle) of each pixel. - */ -void /* PRIVATE */ -png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start) -{ - png_bytep sp = row; /* source pointer */ - png_bytep dp = row; /* destination pointer */ - png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */ - - /* At the start sp will point to the first byte to copy and dp to where - * it is copied to. ep always points just beyond the end of the row, so - * the loop simply copies (channels-1) channels until sp reaches ep. - * - * at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc. - * nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc. - */ - - /* GA, GX, XG cases */ - if (row_info->channels == 2) - { - if (row_info->bit_depth == 8) - { - if (at_start) /* Skip initial filler */ - ++sp; - else /* Skip initial channel and, for sp, the filler */ - sp += 2, ++dp; - - /* For a 1 pixel wide image there is nothing to do */ - while (sp < ep) - *dp++ = *sp, sp += 2; - - row_info->pixel_depth = 8; - } - - else if (row_info->bit_depth == 16) - { - if (at_start) /* Skip initial filler */ - sp += 2; - else /* Skip initial channel and, for sp, the filler */ - sp += 4, dp += 2; - - while (sp < ep) - *dp++ = *sp++, *dp++ = *sp, sp += 3; - - row_info->pixel_depth = 16; - } - - else - return; /* bad bit depth */ - - row_info->channels = 1; - - /* Finally fix the color type if it records an alpha channel */ - if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - row_info->color_type = PNG_COLOR_TYPE_GRAY; - } - - /* RGBA, RGBX, XRGB cases */ - else if (row_info->channels == 4) - { - if (row_info->bit_depth == 8) - { - if (at_start) /* Skip initial filler */ - ++sp; - else /* Skip initial channels and, for sp, the filler */ - sp += 4, dp += 3; - - /* Note that the loop adds 3 to dp and 4 to sp each time. */ - while (sp < ep) - *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2; - - row_info->pixel_depth = 24; - } - - else if (row_info->bit_depth == 16) - { - if (at_start) /* Skip initial filler */ - sp += 2; - else /* Skip initial channels and, for sp, the filler */ - sp += 8, dp += 6; - - while (sp < ep) - { - /* Copy 6 bytes, skip 2 */ - *dp++ = *sp++, *dp++ = *sp++; - *dp++ = *sp++, *dp++ = *sp++; - *dp++ = *sp++, *dp++ = *sp, sp += 3; - } - - row_info->pixel_depth = 48; - } - - else - return; /* bad bit depth */ - - row_info->channels = 3; - - /* Finally fix the color type if it records an alpha channel */ - if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - row_info->color_type = PNG_COLOR_TYPE_RGB; - } - - else - return; /* The filler channel has gone already */ - - /* Fix the rowbytes value. */ - row_info->rowbytes = dp-row; -} -#endif - -#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) -/* Swaps red and blue bytes within a pixel */ -void /* PRIVATE */ -png_do_bgr(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_bgr"); - - if ((row_info->color_type & PNG_COLOR_MASK_COLOR)) - { - png_uint_32 row_width = row_info->width; - if (row_info->bit_depth == 8) - { - if (row_info->color_type == PNG_COLOR_TYPE_RGB) - { - png_bytep rp; - png_uint_32 i; - - for (i = 0, rp = row; i < row_width; i++, rp += 3) - { - png_byte save = *rp; - *rp = *(rp + 2); - *(rp + 2) = save; - } - } - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - { - png_bytep rp; - png_uint_32 i; - - for (i = 0, rp = row; i < row_width; i++, rp += 4) - { - png_byte save = *rp; - *rp = *(rp + 2); - *(rp + 2) = save; - } - } - } - -#ifdef PNG_16BIT_SUPPORTED - else if (row_info->bit_depth == 16) - { - if (row_info->color_type == PNG_COLOR_TYPE_RGB) - { - png_bytep rp; - png_uint_32 i; - - for (i = 0, rp = row; i < row_width; i++, rp += 6) - { - png_byte save = *rp; - *rp = *(rp + 4); - *(rp + 4) = save; - save = *(rp + 1); - *(rp + 1) = *(rp + 5); - *(rp + 5) = save; - } - } - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - { - png_bytep rp; - png_uint_32 i; - - for (i = 0, rp = row; i < row_width; i++, rp += 8) - { - png_byte save = *rp; - *rp = *(rp + 4); - *(rp + 4) = save; - save = *(rp + 1); - *(rp + 1) = *(rp + 5); - *(rp + 5) = save; - } - } - } -#endif - } -} -#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ - -#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \ - defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED) -/* Added at libpng-1.5.10 */ -void /* PRIVATE */ -png_do_check_palette_indexes(png_structp png_ptr, png_row_infop row_info) -{ - if (png_ptr->num_palette < (1 << row_info->bit_depth) && - png_ptr->num_palette_max >= 0) - { - /* Calculations moved outside switch in an attempt to stop different - * compiler warnings. 'padding' is in *bits* within the last byte, it is - * an 'int' because pixel_depth becomes an 'int' in the expression below, - * and this calculation is used because it avoids warnings that other - * forms produced on either GCC or MSVC. - */ - int padding = (-row_info->pixel_depth * row_info->width) & 7; - png_bytep rp = png_ptr->row_buf + row_info->rowbytes; - - switch (row_info->bit_depth) - { - case 1: - { - /* in this case, all bytes must be 0 so we don't need - * to unpack the pixels except for the rightmost one. - */ - for (; rp > png_ptr->row_buf; rp--) - { - if (*rp >> padding != 0) - png_ptr->num_palette_max = 1; - padding = 0; - } - - break; - } - - case 2: - { - for (; rp > png_ptr->row_buf; rp--) - { - int i = ((*rp >> padding) & 0x03); - - if (i > png_ptr->num_palette_max) - png_ptr->num_palette_max = i; - - i = (((*rp >> padding) >> 2) & 0x03); - - if (i > png_ptr->num_palette_max) - png_ptr->num_palette_max = i; - - i = (((*rp >> padding) >> 4) & 0x03); - - if (i > png_ptr->num_palette_max) - png_ptr->num_palette_max = i; - - i = (((*rp >> padding) >> 6) & 0x03); - - if (i > png_ptr->num_palette_max) - png_ptr->num_palette_max = i; - - padding = 0; - } - - break; - } - - case 4: - { - for (; rp > png_ptr->row_buf; rp--) - { - int i = ((*rp >> padding) & 0x0f); - - if (i > png_ptr->num_palette_max) - png_ptr->num_palette_max = i; - - i = (((*rp >> padding) >> 4) & 0x0f); - - if (i > png_ptr->num_palette_max) - png_ptr->num_palette_max = i; - - padding = 0; - } - - break; - } - - case 8: - { - for (; rp > png_ptr->row_buf; rp--) - { - if (*rp >= png_ptr->num_palette_max) - png_ptr->num_palette_max = (int) *rp; - } - - break; - } - - default: - break; - } - } -} -#endif /* PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED */ - -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED -void PNGAPI -png_set_user_transform_info(png_structp png_ptr, png_voidp - user_transform_ptr, int user_transform_depth, int user_transform_channels) -{ - png_debug(1, "in png_set_user_transform_info"); - - if (png_ptr == NULL) - return; - png_ptr->user_transform_ptr = user_transform_ptr; - png_ptr->user_transform_depth = (png_byte)user_transform_depth; - png_ptr->user_transform_channels = (png_byte)user_transform_channels; -} -#endif - -/* This function returns a pointer to the user_transform_ptr associated with - * the user transform functions. The application should free any memory - * associated with this pointer before png_write_destroy and png_read_destroy - * are called. - */ -#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED -png_voidp PNGAPI -png_get_user_transform_ptr(png_const_structp png_ptr) -{ - if (png_ptr == NULL) - return (NULL); - - return ((png_voidp)png_ptr->user_transform_ptr); -} -#endif - -#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED -png_uint_32 PNGAPI -png_get_current_row_number(png_const_structp png_ptr) -{ - /* See the comments in png.h - this is the sub-image row when reading and - * interlaced image. - */ - if (png_ptr != NULL) - return png_ptr->row_number; - - return PNG_UINT_32_MAX; /* help the app not to fail silently */ -} - -png_byte PNGAPI -png_get_current_pass_number(png_const_structp png_ptr) -{ - if (png_ptr != NULL) - return png_ptr->pass; - return 8; /* invalid */ -} -#endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */ -#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED || - PNG_WRITE_USER_TRANSFORM_SUPPORTED */ -#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngwio.c b/source/libpng/pngwio.c deleted file mode 100644 index 8eacf9f..0000000 --- a/source/libpng/pngwio.c +++ /dev/null @@ -1,254 +0,0 @@ - -/* pngwio.c - functions for data output - * - * Last changed in libpng 1.5.0 [January 6, 2011] - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - * - * This file provides a location for all output. Users who need - * special handling are expected to write functions that have the same - * arguments as these and perform similar functions, but that possibly - * use different output methods. Note that you shouldn't change these - * functions, but rather write replacement functions and then change - * them at run time with png_set_write_fn(...). - */ - -#include "pngpriv.h" - -#ifdef PNG_WRITE_SUPPORTED - -/* Write the data to whatever output you are using. The default routine - * writes to a file pointer. Note that this routine sometimes gets called - * with very small lengths, so you should implement some kind of simple - * buffering if you are using unbuffered writes. This should never be asked - * to write more than 64K on a 16 bit machine. - */ - -void /* PRIVATE */ -png_write_data(png_structp png_ptr, png_const_bytep data, png_size_t length) -{ - /* NOTE: write_data_fn must not change the buffer! */ - if (png_ptr->write_data_fn != NULL ) - (*(png_ptr->write_data_fn))(png_ptr, (png_bytep)data, length); - - else - png_error(png_ptr, "Call to NULL write function"); -} - -#ifdef PNG_STDIO_SUPPORTED -/* This is the function that does the actual writing of data. If you are - * not writing to a standard C stream, you should create a replacement - * write_data function and use it at run time with png_set_write_fn(), rather - * than changing the library. - */ -#ifndef USE_FAR_KEYWORD -void PNGCBAPI -png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) -{ - png_size_t check; - - if (png_ptr == NULL) - return; - - check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); - - if (check != length) - png_error(png_ptr, "Write Error"); -} -#else -/* This is the model-independent version. Since the standard I/O library - * can't handle far buffers in the medium and small models, we have to copy - * the data. - */ - -#define NEAR_BUF_SIZE 1024 -#define MIN(a,b) (a <= b ? a : b) - -void PNGCBAPI -png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) -{ - png_uint_32 check; - png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ - png_FILE_p io_ptr; - - if (png_ptr == NULL) - return; - - /* Check if data really is near. If so, use usual code. */ - near_data = (png_byte *)CVT_PTR_NOCHECK(data); - io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); - - if ((png_bytep)near_data == data) - { - check = fwrite(near_data, 1, length, io_ptr); - } - - else - { - png_byte buf[NEAR_BUF_SIZE]; - png_size_t written, remaining, err; - check = 0; - remaining = length; - - do - { - written = MIN(NEAR_BUF_SIZE, remaining); - png_memcpy(buf, data, written); /* Copy far buffer to near buffer */ - err = fwrite(buf, 1, written, io_ptr); - - if (err != written) - break; - - else - check += err; - - data += written; - remaining -= written; - } - while (remaining != 0); - } - - if (check != length) - png_error(png_ptr, "Write Error"); -} - -#endif -#endif - -/* This function is called to output any data pending writing (normally - * to disk). After png_flush is called, there should be no data pending - * writing in any buffers. - */ -#ifdef PNG_WRITE_FLUSH_SUPPORTED -void /* PRIVATE */ -png_flush(png_structp png_ptr) -{ - if (png_ptr->output_flush_fn != NULL) - (*(png_ptr->output_flush_fn))(png_ptr); -} - -# ifdef PNG_STDIO_SUPPORTED -void PNGCBAPI -png_default_flush(png_structp png_ptr) -{ - png_FILE_p io_ptr; - - if (png_ptr == NULL) - return; - - io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); - fflush(io_ptr); -} -# endif -#endif - -/* This function allows the application to supply new output functions for - * libpng if standard C streams aren't being used. - * - * This function takes as its arguments: - * png_ptr - pointer to a png output data structure - * io_ptr - pointer to user supplied structure containing info about - * the output functions. May be NULL. - * write_data_fn - pointer to a new output function that takes as its - * arguments a pointer to a png_struct, a pointer to - * data to be written, and a 32-bit unsigned int that is - * the number of bytes to be written. The new write - * function should call png_error(png_ptr, "Error msg") - * to exit and output any fatal error messages. May be - * NULL, in which case libpng's default function will - * be used. - * flush_data_fn - pointer to a new flush function that takes as its - * arguments a pointer to a png_struct. After a call to - * the flush function, there should be no data in any buffers - * or pending transmission. If the output method doesn't do - * any buffering of output, a function prototype must still be - * supplied although it doesn't have to do anything. If - * PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile - * time, output_flush_fn will be ignored, although it must be - * supplied for compatibility. May be NULL, in which case - * libpng's default function will be used, if - * PNG_WRITE_FLUSH_SUPPORTED is defined. This is not - * a good idea if io_ptr does not point to a standard - * *FILE structure. - */ -void PNGAPI -png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, - png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) -{ - if (png_ptr == NULL) - return; - - png_ptr->io_ptr = io_ptr; - -#ifdef PNG_STDIO_SUPPORTED - if (write_data_fn != NULL) - png_ptr->write_data_fn = write_data_fn; - - else - png_ptr->write_data_fn = png_default_write_data; -#else - png_ptr->write_data_fn = write_data_fn; -#endif - -#ifdef PNG_WRITE_FLUSH_SUPPORTED -# ifdef PNG_STDIO_SUPPORTED - - if (output_flush_fn != NULL) - png_ptr->output_flush_fn = output_flush_fn; - - else - png_ptr->output_flush_fn = png_default_flush; - -# else - png_ptr->output_flush_fn = output_flush_fn; -# endif -#endif /* PNG_WRITE_FLUSH_SUPPORTED */ - - /* It is an error to read while writing a png file */ - if (png_ptr->read_data_fn != NULL) - { - png_ptr->read_data_fn = NULL; - - png_warning(png_ptr, - "Can't set both read_data_fn and write_data_fn in the" - " same structure"); - } -} - -#ifdef USE_FAR_KEYWORD -# ifdef _MSC_VER -void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check) -{ - void *near_ptr; - void FAR *far_ptr; - FP_OFF(near_ptr) = FP_OFF(ptr); - far_ptr = (void FAR *)near_ptr; - - if (check != 0) - if (FP_SEG(ptr) != FP_SEG(far_ptr)) - png_error(png_ptr, "segment lost in conversion"); - - return(near_ptr); -} -# else -void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check) -{ - void *near_ptr; - void FAR *far_ptr; - near_ptr = (void FAR *)ptr; - far_ptr = (void FAR *)near_ptr; - - if (check != 0) - if (far_ptr != ptr) - png_error(png_ptr, "segment lost in conversion"); - - return(near_ptr); -} -# endif -#endif -#endif /* PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngwrite.c b/source/libpng/pngwrite.c deleted file mode 100644 index 71d3171..0000000 --- a/source/libpng/pngwrite.c +++ /dev/null @@ -1,1674 +0,0 @@ - -/* pngwrite.c - general routines to write a PNG file - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -#include "pngpriv.h" - -#ifdef PNG_WRITE_SUPPORTED - -/* Writes all the PNG information. This is the suggested way to use the - * library. If you have a new chunk to add, make a function to write it, - * and put it in the correct location here. If you want the chunk written - * after the image data, put it in png_write_end(). I strongly encourage - * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing - * the chunk, as that will keep the code from breaking if you want to just - * write a plain PNG file. If you have long comments, I suggest writing - * them in png_write_end(), and compressing them. - */ -void PNGAPI -png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_write_info_before_PLTE"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) - { - /* Write PNG signature */ - png_write_sig(png_ptr); - -#ifdef PNG_MNG_FEATURES_SUPPORTED - if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) && \ - (png_ptr->mng_features_permitted)) - { - png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); - png_ptr->mng_features_permitted = 0; - } -#endif - - /* Write IHDR information. */ - png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, - info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, - info_ptr->filter_type, -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - info_ptr->interlace_type); -#else - 0); -#endif - /* The rest of these check to see if the valid field has the appropriate - * flag set, and if it does, writes the chunk. - */ -#ifdef PNG_WRITE_gAMA_SUPPORTED - if (info_ptr->valid & PNG_INFO_gAMA) - png_write_gAMA_fixed(png_ptr, info_ptr->gamma); -#endif -#ifdef PNG_WRITE_sRGB_SUPPORTED - if (info_ptr->valid & PNG_INFO_sRGB) - png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); -#endif - -#ifdef PNG_WRITE_iCCP_SUPPORTED - if (info_ptr->valid & PNG_INFO_iCCP) - png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, - (png_charp)info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); -#endif -#ifdef PNG_WRITE_sBIT_SUPPORTED - if (info_ptr->valid & PNG_INFO_sBIT) - png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); -#endif -#ifdef PNG_WRITE_cHRM_SUPPORTED - if (info_ptr->valid & PNG_INFO_cHRM) - png_write_cHRM_fixed(png_ptr, - info_ptr->x_white, info_ptr->y_white, - info_ptr->x_red, info_ptr->y_red, - info_ptr->x_green, info_ptr->y_green, - info_ptr->x_blue, info_ptr->y_blue); -#endif - -#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED - if (info_ptr->unknown_chunks_num) - { - png_unknown_chunk *up; - - png_debug(5, "writing extra chunks"); - - for (up = info_ptr->unknown_chunks; - up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; - up++) - { - int keep = png_handle_as_unknown(png_ptr, up->name); - - if (keep != PNG_HANDLE_CHUNK_NEVER && - up->location && - !(up->location & PNG_HAVE_PLTE) && - !(up->location & PNG_HAVE_IDAT) && - !(up->location & PNG_AFTER_IDAT) && - ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || - (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) - { - if (up->size == 0) - png_warning(png_ptr, "Writing zero-length unknown chunk"); - - png_write_chunk(png_ptr, up->name, up->data, up->size); - } - } - } -#endif - png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; - } -} - -void PNGAPI -png_write_info(png_structp png_ptr, png_infop info_ptr) -{ -#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) - int i; -#endif - - png_debug(1, "in png_write_info"); - - if (png_ptr == NULL || info_ptr == NULL) - return; - - png_write_info_before_PLTE(png_ptr, info_ptr); - - if (info_ptr->valid & PNG_INFO_PLTE) - png_write_PLTE(png_ptr, info_ptr->palette, - (png_uint_32)info_ptr->num_palette); - - else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - png_error(png_ptr, "Valid palette required for paletted images"); - -#ifdef PNG_WRITE_tRNS_SUPPORTED - if (info_ptr->valid & PNG_INFO_tRNS) - { -#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED - /* Invert the alpha channel (in tRNS) */ - if ((png_ptr->transformations & PNG_INVERT_ALPHA) && - info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - int j; - for (j = 0; j<(int)info_ptr->num_trans; j++) - info_ptr->trans_alpha[j] = - (png_byte)(255 - info_ptr->trans_alpha[j]); - } -#endif - png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color), - info_ptr->num_trans, info_ptr->color_type); - } -#endif -#ifdef PNG_WRITE_bKGD_SUPPORTED - if (info_ptr->valid & PNG_INFO_bKGD) - png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); -#endif - -#ifdef PNG_WRITE_hIST_SUPPORTED - if (info_ptr->valid & PNG_INFO_hIST) - png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); -#endif - -#ifdef PNG_WRITE_oFFs_SUPPORTED - if (info_ptr->valid & PNG_INFO_oFFs) - png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, - info_ptr->offset_unit_type); -#endif - -#ifdef PNG_WRITE_pCAL_SUPPORTED - if (info_ptr->valid & PNG_INFO_pCAL) - png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, - info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, - info_ptr->pcal_units, info_ptr->pcal_params); -#endif - -#ifdef PNG_WRITE_sCAL_SUPPORTED - if (info_ptr->valid & PNG_INFO_sCAL) - png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, - info_ptr->scal_s_width, info_ptr->scal_s_height); -#endif /* sCAL */ - -#ifdef PNG_WRITE_pHYs_SUPPORTED - if (info_ptr->valid & PNG_INFO_pHYs) - png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, - info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); -#endif /* pHYs */ - -#ifdef PNG_WRITE_tIME_SUPPORTED - if (info_ptr->valid & PNG_INFO_tIME) - { - png_write_tIME(png_ptr, &(info_ptr->mod_time)); - png_ptr->mode |= PNG_WROTE_tIME; - } -#endif /* tIME */ - -#ifdef PNG_WRITE_sPLT_SUPPORTED - if (info_ptr->valid & PNG_INFO_sPLT) - for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) - png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); -#endif /* sPLT */ - -#ifdef PNG_WRITE_TEXT_SUPPORTED - /* Check to see if we need to write text chunks */ - for (i = 0; i < info_ptr->num_text; i++) - { - png_debug2(2, "Writing header text chunk %d, type %d", i, - info_ptr->text[i].compression); - /* An internationalized chunk? */ - if (info_ptr->text[i].compression > 0) - { -#ifdef PNG_WRITE_iTXt_SUPPORTED - /* Write international chunk */ - png_write_iTXt(png_ptr, - info_ptr->text[i].compression, - info_ptr->text[i].key, - info_ptr->text[i].lang, - info_ptr->text[i].lang_key, - info_ptr->text[i].text); -#else - png_warning(png_ptr, "Unable to write international text"); -#endif - /* Mark this chunk as written */ - info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; - } - - /* If we want a compressed text chunk */ - else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) - { -#ifdef PNG_WRITE_zTXt_SUPPORTED - /* Write compressed chunk */ - png_write_zTXt(png_ptr, info_ptr->text[i].key, - info_ptr->text[i].text, 0, - info_ptr->text[i].compression); -#else - png_warning(png_ptr, "Unable to write compressed text"); -#endif - /* Mark this chunk as written */ - info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; - } - - else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) - { -#ifdef PNG_WRITE_tEXt_SUPPORTED - /* Write uncompressed chunk */ - png_write_tEXt(png_ptr, info_ptr->text[i].key, - info_ptr->text[i].text, - 0); - /* Mark this chunk as written */ - info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; -#else - /* Can't get here */ - png_warning(png_ptr, "Unable to write uncompressed text"); -#endif - } - } -#endif /* tEXt */ - -#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED - if (info_ptr->unknown_chunks_num) - { - png_unknown_chunk *up; - - png_debug(5, "writing extra chunks"); - - for (up = info_ptr->unknown_chunks; - up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; - up++) - { - int keep = png_handle_as_unknown(png_ptr, up->name); - if (keep != PNG_HANDLE_CHUNK_NEVER && - up->location && - (up->location & PNG_HAVE_PLTE) && - !(up->location & PNG_HAVE_IDAT) && - !(up->location & PNG_AFTER_IDAT) && - ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || - (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) - { - png_write_chunk(png_ptr, up->name, up->data, up->size); - } - } - } -#endif -} - -/* Writes the end of the PNG file. If you don't want to write comments or - * time information, you can pass NULL for info. If you already wrote these - * in png_write_info(), do not write them again here. If you have long - * comments, I suggest writing them here, and compressing them. - */ -void PNGAPI -png_write_end(png_structp png_ptr, png_infop info_ptr) -{ - png_debug(1, "in png_write_end"); - - if (png_ptr == NULL) - return; - - if (!(png_ptr->mode & PNG_HAVE_IDAT)) - png_error(png_ptr, "No IDATs written into file"); - -#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED - if (png_ptr->num_palette_max > png_ptr->num_palette) - png_benign_error(png_ptr, "Wrote palette index exceeding num_palette"); -#endif - - /* See if user wants us to write information chunks */ - if (info_ptr != NULL) - { -#ifdef PNG_WRITE_TEXT_SUPPORTED - int i; /* local index variable */ -#endif -#ifdef PNG_WRITE_tIME_SUPPORTED - /* Check to see if user has supplied a time chunk */ - if ((info_ptr->valid & PNG_INFO_tIME) && - !(png_ptr->mode & PNG_WROTE_tIME)) - png_write_tIME(png_ptr, &(info_ptr->mod_time)); - -#endif -#ifdef PNG_WRITE_TEXT_SUPPORTED - /* Loop through comment chunks */ - for (i = 0; i < info_ptr->num_text; i++) - { - png_debug2(2, "Writing trailer text chunk %d, type %d", i, - info_ptr->text[i].compression); - /* An internationalized chunk? */ - if (info_ptr->text[i].compression > 0) - { -#ifdef PNG_WRITE_iTXt_SUPPORTED - /* Write international chunk */ - png_write_iTXt(png_ptr, - info_ptr->text[i].compression, - info_ptr->text[i].key, - info_ptr->text[i].lang, - info_ptr->text[i].lang_key, - info_ptr->text[i].text); -#else - png_warning(png_ptr, "Unable to write international text"); -#endif - /* Mark this chunk as written */ - info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; - } - - else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) - { -#ifdef PNG_WRITE_zTXt_SUPPORTED - /* Write compressed chunk */ - png_write_zTXt(png_ptr, info_ptr->text[i].key, - info_ptr->text[i].text, 0, - info_ptr->text[i].compression); -#else - png_warning(png_ptr, "Unable to write compressed text"); -#endif - /* Mark this chunk as written */ - info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; - } - - else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) - { -#ifdef PNG_WRITE_tEXt_SUPPORTED - /* Write uncompressed chunk */ - png_write_tEXt(png_ptr, info_ptr->text[i].key, - info_ptr->text[i].text, 0); -#else - png_warning(png_ptr, "Unable to write uncompressed text"); -#endif - - /* Mark this chunk as written */ - info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; - } - } -#endif -#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED - if (info_ptr->unknown_chunks_num) - { - png_unknown_chunk *up; - - png_debug(5, "writing extra chunks"); - - for (up = info_ptr->unknown_chunks; - up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; - up++) - { - int keep = png_handle_as_unknown(png_ptr, up->name); - if (keep != PNG_HANDLE_CHUNK_NEVER && - up->location && - (up->location & PNG_AFTER_IDAT) && - ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || - (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) - { - png_write_chunk(png_ptr, up->name, up->data, up->size); - } - } - } -#endif - } - - png_ptr->mode |= PNG_AFTER_IDAT; - - /* Write end of PNG file */ - png_write_IEND(png_ptr); - /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03, - * and restored again in libpng-1.2.30, may cause some applications that - * do not set png_ptr->output_flush_fn to crash. If your application - * experiences a problem, please try building libpng with - * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to - * png-mng-implement at lists.sf.net . - */ -#ifdef PNG_WRITE_FLUSH_SUPPORTED -# ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED - png_flush(png_ptr); -# endif -#endif -} - -#ifdef PNG_CONVERT_tIME_SUPPORTED -/* "tm" structure is not supported on WindowsCE */ -#if defined(_MSC_VER) - #pragma warning(push) - #pragma warning(disable: 4028) // For some as-yet unknown reason, this warning can occur for the following function. -#endif -void PNGAPI -png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm FAR * ttime) -{ - png_debug(1, "in png_convert_from_struct_tm"); - - ptime->year = (png_uint_16)(1900 + ttime->tm_year); - ptime->month = (png_byte)(ttime->tm_mon + 1); - ptime->day = (png_byte)ttime->tm_mday; - ptime->hour = (png_byte)ttime->tm_hour; - ptime->minute = (png_byte)ttime->tm_min; - ptime->second = (png_byte)ttime->tm_sec; -} -#if defined(_MSC_VER) - #pragma warning(pop) -#endif - -void PNGAPI -png_convert_from_time_t(png_timep ptime, time_t ttime) -{ - struct tm *tbuf; - - png_debug(1, "in png_convert_from_time_t"); - - tbuf = gmtime(&ttime); - png_convert_from_struct_tm(ptime, tbuf); -} -#endif - -/* Initialize png_ptr structure, and allocate any memory needed */ -PNG_FUNCTION(png_structp,PNGAPI -png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) -{ -#ifdef PNG_USER_MEM_SUPPORTED - return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, - warn_fn, NULL, NULL, NULL)); -} - -/* Alternate initialize png_ptr structure, and allocate any memory needed */ -static void png_reset_filter_heuristics(png_structp png_ptr); /* forward decl */ - -PNG_FUNCTION(png_structp,PNGAPI -png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, - png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) -{ -#endif /* PNG_USER_MEM_SUPPORTED */ - volatile int png_cleanup_needed = 0; -#ifdef PNG_SETJMP_SUPPORTED - volatile -#endif - png_structp png_ptr; -#ifdef PNG_SETJMP_SUPPORTED -#ifdef USE_FAR_KEYWORD - jmp_buf tmp_jmpbuf; -#endif -#endif - - png_debug(1, "in png_create_write_struct"); - -#ifdef PNG_USER_MEM_SUPPORTED - png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, - (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); -#else - png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); -#endif /* PNG_USER_MEM_SUPPORTED */ - if (png_ptr == NULL) - return (NULL); - - /* Added at libpng-1.2.6 */ -#ifdef PNG_SET_USER_LIMITS_SUPPORTED - png_ptr->user_width_max = PNG_USER_WIDTH_MAX; - png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; -#endif - -#ifdef PNG_SETJMP_SUPPORTED -/* Applications that neglect to set up their own setjmp() and then - * encounter a png_error() will longjmp here. Since the jmpbuf is - * then meaningless we abort instead of returning. - */ -#ifdef USE_FAR_KEYWORD - if (setjmp(tmp_jmpbuf)) -#else - if (setjmp(png_jmpbuf(png_ptr))) /* sets longjmp to match setjmp */ -#endif -#ifdef USE_FAR_KEYWORD - png_memcpy(png_jmpbuf(png_ptr), tmp_jmpbuf, png_sizeof(jmp_buf)); -#endif - PNG_ABORT(); -#endif - -#ifdef PNG_USER_MEM_SUPPORTED - png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); -#endif /* PNG_USER_MEM_SUPPORTED */ - png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); - - if (!png_user_version_check(png_ptr, user_png_ver)) - png_cleanup_needed = 1; - - /* Initialize zbuf - compression buffer */ - png_ptr->zbuf_size = PNG_ZBUF_SIZE; - - if (!png_cleanup_needed) - { - png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, - png_ptr->zbuf_size); - if (png_ptr->zbuf == NULL) - png_cleanup_needed = 1; - } - - if (png_cleanup_needed) - { - /* Clean up PNG structure and deallocate any memory. */ - png_free(png_ptr, png_ptr->zbuf); - png_ptr->zbuf = NULL; -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)png_ptr, - (png_free_ptr)free_fn, (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)png_ptr); -#endif - return (NULL); - } - - png_set_write_fn(png_ptr, NULL, NULL, NULL); - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - png_reset_filter_heuristics(png_ptr); -#endif - - return (png_ptr); -} - - -/* Write a few rows of image data. If the image is interlaced, - * either you will have to write the 7 sub images, or, if you - * have called png_set_interlace_handling(), you will have to - * "write" the image seven times. - */ -void PNGAPI -png_write_rows(png_structp png_ptr, png_bytepp row, - png_uint_32 num_rows) -{ - png_uint_32 i; /* row counter */ - png_bytepp rp; /* row pointer */ - - png_debug(1, "in png_write_rows"); - - if (png_ptr == NULL) - return; - - /* Loop through the rows */ - for (i = 0, rp = row; i < num_rows; i++, rp++) - { - png_write_row(png_ptr, *rp); - } -} - -/* Write the image. You only need to call this function once, even - * if you are writing an interlaced image. - */ -void PNGAPI -png_write_image(png_structp png_ptr, png_bytepp image) -{ - png_uint_32 i; /* row index */ - int pass, num_pass; /* pass variables */ - png_bytepp rp; /* points to current row */ - - if (png_ptr == NULL) - return; - - png_debug(1, "in png_write_image"); - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* Initialize interlace handling. If image is not interlaced, - * this will set pass to 1 - */ - num_pass = png_set_interlace_handling(png_ptr); -#else - num_pass = 1; -#endif - /* Loop through passes */ - for (pass = 0; pass < num_pass; pass++) - { - /* Loop through image */ - for (i = 0, rp = image; i < png_ptr->height; i++, rp++) - { - png_write_row(png_ptr, *rp); - } - } -} - -/* Called by user to write a row of image data */ -void PNGAPI -png_write_row(png_structp png_ptr, png_const_bytep row) -{ - /* 1.5.6: moved from png_struct to be a local structure: */ - png_row_info row_info; - - if (png_ptr == NULL) - return; - - png_debug2(1, "in png_write_row (row %u, pass %d)", - png_ptr->row_number, png_ptr->pass); - - /* Initialize transformations and other stuff if first time */ - if (png_ptr->row_number == 0 && png_ptr->pass == 0) - { - /* Make sure we wrote the header info */ - if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) - png_error(png_ptr, - "png_write_info was never called before png_write_row"); - - /* Check for transforms that have been set but were defined out */ -#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) - if (png_ptr->transformations & PNG_INVERT_MONO) - png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined"); -#endif - -#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) - if (png_ptr->transformations & PNG_FILLER) - png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined"); -#endif -#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ - defined(PNG_READ_PACKSWAP_SUPPORTED) - if (png_ptr->transformations & PNG_PACKSWAP) - png_warning(png_ptr, - "PNG_WRITE_PACKSWAP_SUPPORTED is not defined"); -#endif - -#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) - if (png_ptr->transformations & PNG_PACK) - png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined"); -#endif - -#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) - if (png_ptr->transformations & PNG_SHIFT) - png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined"); -#endif - -#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) - if (png_ptr->transformations & PNG_BGR) - png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined"); -#endif - -#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) - if (png_ptr->transformations & PNG_SWAP_BYTES) - png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined"); -#endif - - png_write_start_row(png_ptr); - } - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* If interlaced and not interested in row, return */ - if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) - { - switch (png_ptr->pass) - { - case 0: - if (png_ptr->row_number & 0x07) - { - png_write_finish_row(png_ptr); - return; - } - break; - - case 1: - if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) - { - png_write_finish_row(png_ptr); - return; - } - break; - - case 2: - if ((png_ptr->row_number & 0x07) != 4) - { - png_write_finish_row(png_ptr); - return; - } - break; - - case 3: - if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) - { - png_write_finish_row(png_ptr); - return; - } - break; - - case 4: - if ((png_ptr->row_number & 0x03) != 2) - { - png_write_finish_row(png_ptr); - return; - } - break; - - case 5: - if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) - { - png_write_finish_row(png_ptr); - return; - } - break; - - case 6: - if (!(png_ptr->row_number & 0x01)) - { - png_write_finish_row(png_ptr); - return; - } - break; - - default: /* error: ignore it */ - break; - } - } -#endif - - /* Set up row info for transformations */ - row_info.color_type = png_ptr->color_type; - row_info.width = png_ptr->usr_width; - row_info.channels = png_ptr->usr_channels; - row_info.bit_depth = png_ptr->usr_bit_depth; - row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels); - row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width); - - png_debug1(3, "row_info->color_type = %d", row_info.color_type); - png_debug1(3, "row_info->width = %u", row_info.width); - png_debug1(3, "row_info->channels = %d", row_info.channels); - png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth); - png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth); - png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes); - - /* Copy user's row into buffer, leaving room for filter byte. */ - png_memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes); - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* Handle interlacing */ - if (png_ptr->interlaced && png_ptr->pass < 6 && - (png_ptr->transformations & PNG_INTERLACE)) - { - png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass); - /* This should always get caught above, but still ... */ - if (!(row_info.width)) - { - png_write_finish_row(png_ptr); - return; - } - } -#endif - -#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED - /* Handle other transformations */ - if (png_ptr->transformations) - png_do_write_transformations(png_ptr, &row_info); -#endif - - /* At this point the row_info pixel depth must match the 'transformed' depth, - * which is also the output depth. - */ - if (row_info.pixel_depth != png_ptr->pixel_depth || - row_info.pixel_depth != png_ptr->transformed_pixel_depth) - png_error(png_ptr, "internal write transform logic error"); - -#ifdef PNG_MNG_FEATURES_SUPPORTED - /* Write filter_method 64 (intrapixel differencing) only if - * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and - * 2. Libpng did not write a PNG signature (this filter_method is only - * used in PNG datastreams that are embedded in MNG datastreams) and - * 3. The application called png_permit_mng_features with a mask that - * included PNG_FLAG_MNG_FILTER_64 and - * 4. The filter_method is 64 and - * 5. The color_type is RGB or RGBA - */ - if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && - (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) - { - /* Intrapixel differencing */ - png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1); - } -#endif - -/* Added at libpng-1.5.10 */ -#ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED - /* Check for out-of-range palette index */ - if(row_info.color_type == PNG_COLOR_TYPE_PALETTE) - png_do_check_palette_indexes(png_ptr, &row_info); -#endif - - /* Find a filter if necessary, filter the row and write it out. */ - png_write_find_filter(png_ptr, &row_info); - - if (png_ptr->write_row_fn != NULL) - (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); -} - -#ifdef PNG_WRITE_FLUSH_SUPPORTED -/* Set the automatic flush interval or 0 to turn flushing off */ -void PNGAPI -png_set_flush(png_structp png_ptr, int nrows) -{ - png_debug(1, "in png_set_flush"); - - if (png_ptr == NULL) - return; - - png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); -} - -/* Flush the current output buffers now */ -void PNGAPI -png_write_flush(png_structp png_ptr) -{ - int wrote_IDAT; - - png_debug(1, "in png_write_flush"); - - if (png_ptr == NULL) - return; - - /* We have already written out all of the data */ - if (png_ptr->row_number >= png_ptr->num_rows) - return; - - do - { - int ret; - - /* Compress the data */ - ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); - wrote_IDAT = 0; - - /* Check for compression errors */ - if (ret != Z_OK) - { - if (png_ptr->zstream.msg != NULL) - png_error(png_ptr, png_ptr->zstream.msg); - - else - png_error(png_ptr, "zlib error"); - } - - if (!(png_ptr->zstream.avail_out)) - { - /* Write the IDAT and reset the zlib output buffer */ - png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); - wrote_IDAT = 1; - } - } while (wrote_IDAT == 1); - - /* If there is any data left to be output, write it into a new IDAT */ - if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) - { - /* Write the IDAT and reset the zlib output buffer */ - png_write_IDAT(png_ptr, png_ptr->zbuf, - png_ptr->zbuf_size - png_ptr->zstream.avail_out); - } - png_ptr->flush_rows = 0; - png_flush(png_ptr); -} -#endif /* PNG_WRITE_FLUSH_SUPPORTED */ - -/* Free all memory used by the write */ -void PNGAPI -png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) -{ - png_structp png_ptr = NULL; - png_infop info_ptr = NULL; -#ifdef PNG_USER_MEM_SUPPORTED - png_free_ptr free_fn = NULL; - png_voidp mem_ptr = NULL; -#endif - - png_debug(1, "in png_destroy_write_struct"); - - if (png_ptr_ptr != NULL) - png_ptr = *png_ptr_ptr; - -#ifdef PNG_USER_MEM_SUPPORTED - if (png_ptr != NULL) - { - free_fn = png_ptr->free_fn; - mem_ptr = png_ptr->mem_ptr; - } -#endif - - if (info_ptr_ptr != NULL) - info_ptr = *info_ptr_ptr; - - if (info_ptr != NULL) - { - if (png_ptr != NULL) - { - png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); - -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED - if (png_ptr->num_chunk_list) - { - png_free(png_ptr, png_ptr->chunk_list); - png_ptr->num_chunk_list = 0; - } -#endif - } - -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, - (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)info_ptr); -#endif - *info_ptr_ptr = NULL; - } - - if (png_ptr != NULL) - { - png_write_destroy(png_ptr); -#ifdef PNG_USER_MEM_SUPPORTED - png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, - (png_voidp)mem_ptr); -#else - png_destroy_struct((png_voidp)png_ptr); -#endif - *png_ptr_ptr = NULL; - } -} - - -/* Free any memory used in png_ptr struct (old method) */ -void /* PRIVATE */ -png_write_destroy(png_structp png_ptr) -{ -#ifdef PNG_SETJMP_SUPPORTED - jmp_buf tmp_jmp; /* Save jump buffer */ -#endif - png_error_ptr error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - png_error_ptr warning_fn; -#endif - png_voidp error_ptr; -#ifdef PNG_USER_MEM_SUPPORTED - png_free_ptr free_fn; -#endif - - png_debug(1, "in png_write_destroy"); - - /* Free any memory zlib uses */ - if (png_ptr->zlib_state != PNG_ZLIB_UNINITIALIZED) - deflateEnd(&png_ptr->zstream); - - /* Free our memory. png_free checks NULL for us. */ - png_free(png_ptr, png_ptr->zbuf); - png_free(png_ptr, png_ptr->row_buf); -#ifdef PNG_WRITE_FILTER_SUPPORTED - png_free(png_ptr, png_ptr->prev_row); - png_free(png_ptr, png_ptr->sub_row); - png_free(png_ptr, png_ptr->up_row); - png_free(png_ptr, png_ptr->avg_row); - png_free(png_ptr, png_ptr->paeth_row); -#endif - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - /* Use this to save a little code space, it doesn't free the filter_costs */ - png_reset_filter_heuristics(png_ptr); - png_free(png_ptr, png_ptr->filter_costs); - png_free(png_ptr, png_ptr->inv_filter_costs); -#endif - -#ifdef PNG_SETJMP_SUPPORTED - /* Reset structure */ - png_memcpy(tmp_jmp, png_ptr->longjmp_buffer, png_sizeof(jmp_buf)); -#endif - - error_fn = png_ptr->error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - warning_fn = png_ptr->warning_fn; -#endif - error_ptr = png_ptr->error_ptr; -#ifdef PNG_USER_MEM_SUPPORTED - free_fn = png_ptr->free_fn; -#endif - - png_memset(png_ptr, 0, png_sizeof(png_struct)); - - png_ptr->error_fn = error_fn; -#ifdef PNG_WARNINGS_SUPPORTED - png_ptr->warning_fn = warning_fn; -#endif - png_ptr->error_ptr = error_ptr; -#ifdef PNG_USER_MEM_SUPPORTED - png_ptr->free_fn = free_fn; -#endif - -#ifdef PNG_SETJMP_SUPPORTED - png_memcpy(png_ptr->longjmp_buffer, tmp_jmp, png_sizeof(jmp_buf)); -#endif -} - -/* Allow the application to select one or more row filters to use. */ -void PNGAPI -png_set_filter(png_structp png_ptr, int method, int filters) -{ - png_debug(1, "in png_set_filter"); - - if (png_ptr == NULL) - return; - -#ifdef PNG_MNG_FEATURES_SUPPORTED - if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && - (method == PNG_INTRAPIXEL_DIFFERENCING)) - method = PNG_FILTER_TYPE_BASE; - -#endif - if (method == PNG_FILTER_TYPE_BASE) - { - switch (filters & (PNG_ALL_FILTERS | 0x07)) - { -#ifdef PNG_WRITE_FILTER_SUPPORTED - case 5: - case 6: - case 7: png_warning(png_ptr, "Unknown row filter for method 0"); -#endif /* PNG_WRITE_FILTER_SUPPORTED */ - case PNG_FILTER_VALUE_NONE: - png_ptr->do_filter = PNG_FILTER_NONE; break; - -#ifdef PNG_WRITE_FILTER_SUPPORTED - case PNG_FILTER_VALUE_SUB: - png_ptr->do_filter = PNG_FILTER_SUB; break; - - case PNG_FILTER_VALUE_UP: - png_ptr->do_filter = PNG_FILTER_UP; break; - - case PNG_FILTER_VALUE_AVG: - png_ptr->do_filter = PNG_FILTER_AVG; break; - - case PNG_FILTER_VALUE_PAETH: - png_ptr->do_filter = PNG_FILTER_PAETH; break; - - default: - png_ptr->do_filter = (png_byte)filters; break; -#else - default: - png_warning(png_ptr, "Unknown row filter for method 0"); -#endif /* PNG_WRITE_FILTER_SUPPORTED */ - } - - /* If we have allocated the row_buf, this means we have already started - * with the image and we should have allocated all of the filter buffers - * that have been selected. If prev_row isn't already allocated, then - * it is too late to start using the filters that need it, since we - * will be missing the data in the previous row. If an application - * wants to start and stop using particular filters during compression, - * it should start out with all of the filters, and then add and - * remove them after the start of compression. - */ - if (png_ptr->row_buf != NULL) - { -#ifdef PNG_WRITE_FILTER_SUPPORTED - if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) - { - png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, - (png_ptr->rowbytes + 1)); - png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; - } - - if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) - { - if (png_ptr->prev_row == NULL) - { - png_warning(png_ptr, "Can't add Up filter after starting"); - png_ptr->do_filter = (png_byte)(png_ptr->do_filter & - ~PNG_FILTER_UP); - } - - else - { - png_ptr->up_row = (png_bytep)png_malloc(png_ptr, - (png_ptr->rowbytes + 1)); - png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; - } - } - - if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) - { - if (png_ptr->prev_row == NULL) - { - png_warning(png_ptr, "Can't add Average filter after starting"); - png_ptr->do_filter = (png_byte)(png_ptr->do_filter & - ~PNG_FILTER_AVG); - } - - else - { - png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, - (png_ptr->rowbytes + 1)); - png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; - } - } - - if ((png_ptr->do_filter & PNG_FILTER_PAETH) && - png_ptr->paeth_row == NULL) - { - if (png_ptr->prev_row == NULL) - { - png_warning(png_ptr, "Can't add Paeth filter after starting"); - png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); - } - - else - { - png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, - (png_ptr->rowbytes + 1)); - png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; - } - } - - if (png_ptr->do_filter == PNG_NO_FILTERS) -#endif /* PNG_WRITE_FILTER_SUPPORTED */ - png_ptr->do_filter = PNG_FILTER_NONE; - } - } - else - png_error(png_ptr, "Unknown custom filter method"); -} - -/* This allows us to influence the way in which libpng chooses the "best" - * filter for the current scanline. While the "minimum-sum-of-absolute- - * differences metric is relatively fast and effective, there is some - * question as to whether it can be improved upon by trying to keep the - * filtered data going to zlib more consistent, hopefully resulting in - * better compression. - */ -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* GRR 970116 */ -/* Convenience reset API. */ -static void -png_reset_filter_heuristics(png_structp png_ptr) -{ - /* Clear out any old values in the 'weights' - this must be done because if - * the app calls set_filter_heuristics multiple times with different - * 'num_weights' values we would otherwise potentially have wrong sized - * arrays. - */ - png_ptr->num_prev_filters = 0; - png_ptr->heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; - if (png_ptr->prev_filters != NULL) - { - png_bytep old = png_ptr->prev_filters; - png_ptr->prev_filters = NULL; - png_free(png_ptr, old); - } - if (png_ptr->filter_weights != NULL) - { - png_uint_16p old = png_ptr->filter_weights; - png_ptr->filter_weights = NULL; - png_free(png_ptr, old); - } - - if (png_ptr->inv_filter_weights != NULL) - { - png_uint_16p old = png_ptr->inv_filter_weights; - png_ptr->inv_filter_weights = NULL; - png_free(png_ptr, old); - } - - /* Leave the filter_costs - this array is fixed size. */ -} - -static int -png_init_filter_heuristics(png_structp png_ptr, int heuristic_method, - int num_weights) -{ - if (png_ptr == NULL) - return 0; - - /* Clear out the arrays */ - png_reset_filter_heuristics(png_ptr); - - /* Check arguments; the 'reset' function makes the correct settings for the - * unweighted case, but we must handle the weight case by initializing the - * arrays for the caller. - */ - if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int i; - - if (num_weights > 0) - { - png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, - (png_uint_32)(png_sizeof(png_byte) * num_weights)); - - /* To make sure that the weighting starts out fairly */ - for (i = 0; i < num_weights; i++) - { - png_ptr->prev_filters[i] = 255; - } - - png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, - (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); - - png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, - (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); - - for (i = 0; i < num_weights; i++) - { - png_ptr->inv_filter_weights[i] = - png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; - } - - /* Safe to set this now */ - png_ptr->num_prev_filters = (png_byte)num_weights; - } - - /* If, in the future, there are other filter methods, this would - * need to be based on png_ptr->filter. - */ - if (png_ptr->filter_costs == NULL) - { - png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, - (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); - - png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, - (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); - } - - for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) - { - png_ptr->inv_filter_costs[i] = - png_ptr->filter_costs[i] = PNG_COST_FACTOR; - } - - /* All the arrays are inited, safe to set this: */ - png_ptr->heuristic_method = PNG_FILTER_HEURISTIC_WEIGHTED; - - /* Return the 'ok' code. */ - return 1; - } - else if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT || - heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) - { - return 1; - } - else - { - png_warning(png_ptr, "Unknown filter heuristic method"); - return 0; - } -} - -/* Provide floating and fixed point APIs */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -void PNGAPI -png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, - int num_weights, png_const_doublep filter_weights, - png_const_doublep filter_costs) -{ - png_debug(1, "in png_set_filter_heuristics"); - - /* The internal API allocates all the arrays and ensures that the elements of - * those arrays are set to the default value. - */ - if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights)) - return; - - /* If using the weighted method copy in the weights. */ - if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int i; - for (i = 0; i < num_weights; i++) - { - if (filter_weights[i] <= 0.0) - { - png_ptr->inv_filter_weights[i] = - png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; - } - - else - { - png_ptr->inv_filter_weights[i] = - (png_uint_16)(PNG_WEIGHT_FACTOR*filter_weights[i]+.5); - - png_ptr->filter_weights[i] = - (png_uint_16)(PNG_WEIGHT_FACTOR/filter_weights[i]+.5); - } - } - - /* Here is where we set the relative costs of the different filters. We - * should take the desired compression level into account when setting - * the costs, so that Paeth, for instance, has a high relative cost at low - * compression levels, while it has a lower relative cost at higher - * compression settings. The filter types are in order of increasing - * relative cost, so it would be possible to do this with an algorithm. - */ - for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) if (filter_costs[i] >= 1.0) - { - png_ptr->inv_filter_costs[i] = - (png_uint_16)(PNG_COST_FACTOR / filter_costs[i] + .5); - - png_ptr->filter_costs[i] = - (png_uint_16)(PNG_COST_FACTOR * filter_costs[i] + .5); - } - } -} -#endif /* FLOATING_POINT */ - -#ifdef PNG_FIXED_POINT_SUPPORTED -void PNGAPI -png_set_filter_heuristics_fixed(png_structp png_ptr, int heuristic_method, - int num_weights, png_const_fixed_point_p filter_weights, - png_const_fixed_point_p filter_costs) -{ - png_debug(1, "in png_set_filter_heuristics_fixed"); - - /* The internal API allocates all the arrays and ensures that the elements of - * those arrays are set to the default value. - */ - if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights)) - return; - - /* If using the weighted method copy in the weights. */ - if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int i; - for (i = 0; i < num_weights; i++) - { - if (filter_weights[i] <= 0) - { - png_ptr->inv_filter_weights[i] = - png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; - } - - else - { - png_ptr->inv_filter_weights[i] = (png_uint_16) - ((PNG_WEIGHT_FACTOR*filter_weights[i]+PNG_FP_HALF)/PNG_FP_1); - - png_ptr->filter_weights[i] = (png_uint_16)((PNG_WEIGHT_FACTOR* - PNG_FP_1+(filter_weights[i]/2))/filter_weights[i]); - } - } - - /* Here is where we set the relative costs of the different filters. We - * should take the desired compression level into account when setting - * the costs, so that Paeth, for instance, has a high relative cost at low - * compression levels, while it has a lower relative cost at higher - * compression settings. The filter types are in order of increasing - * relative cost, so it would be possible to do this with an algorithm. - */ - for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) - if (filter_costs[i] >= PNG_FP_1) - { - png_uint_32 tmp; - - /* Use a 32 bit unsigned temporary here because otherwise the - * intermediate value will be a 32 bit *signed* integer (ANSI rules) - * and this will get the wrong answer on division. - */ - tmp = PNG_COST_FACTOR*PNG_FP_1 + (filter_costs[i]/2); - tmp /= filter_costs[i]; - - png_ptr->inv_filter_costs[i] = (png_uint_16)tmp; - - tmp = PNG_COST_FACTOR * filter_costs[i] + PNG_FP_HALF; - tmp /= PNG_FP_1; - - png_ptr->filter_costs[i] = (png_uint_16)tmp; - } - } -} -#endif /* FIXED_POINT */ -#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ - -void PNGAPI -png_set_compression_level(png_structp png_ptr, int level) -{ - png_debug(1, "in png_set_compression_level"); - - if (png_ptr == NULL) - return; - - png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; - png_ptr->zlib_level = level; -} - -void PNGAPI -png_set_compression_mem_level(png_structp png_ptr, int mem_level) -{ - png_debug(1, "in png_set_compression_mem_level"); - - if (png_ptr == NULL) - return; - - png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; - png_ptr->zlib_mem_level = mem_level; -} - -void PNGAPI -png_set_compression_strategy(png_structp png_ptr, int strategy) -{ - png_debug(1, "in png_set_compression_strategy"); - - if (png_ptr == NULL) - return; - - png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; - png_ptr->zlib_strategy = strategy; -} - -/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a - * smaller value of window_bits if it can do so safely. - */ -void PNGAPI -png_set_compression_window_bits(png_structp png_ptr, int window_bits) -{ - if (png_ptr == NULL) - return; - - if (window_bits > 15) - png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); - - else if (window_bits < 8) - png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); - -#ifndef WBITS_8_OK - /* Avoid libpng bug with 256-byte windows */ - if (window_bits == 8) - { - png_warning(png_ptr, "Compression window is being reset to 512"); - window_bits = 9; - } - -#endif - png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; - png_ptr->zlib_window_bits = window_bits; -} - -void PNGAPI -png_set_compression_method(png_structp png_ptr, int method) -{ - png_debug(1, "in png_set_compression_method"); - - if (png_ptr == NULL) - return; - - if (method != 8) - png_warning(png_ptr, "Only compression method 8 is supported by PNG"); - - png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; - png_ptr->zlib_method = method; -} - -/* The following were added to libpng-1.5.4 */ -#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED -void PNGAPI -png_set_text_compression_level(png_structp png_ptr, int level) -{ - png_debug(1, "in png_set_text_compression_level"); - - if (png_ptr == NULL) - return; - - png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_LEVEL; - png_ptr->zlib_text_level = level; -} - -void PNGAPI -png_set_text_compression_mem_level(png_structp png_ptr, int mem_level) -{ - png_debug(1, "in png_set_text_compression_mem_level"); - - if (png_ptr == NULL) - return; - - png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL; - png_ptr->zlib_text_mem_level = mem_level; -} - -void PNGAPI -png_set_text_compression_strategy(png_structp png_ptr, int strategy) -{ - png_debug(1, "in png_set_text_compression_strategy"); - - if (png_ptr == NULL) - return; - - png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_STRATEGY; - png_ptr->zlib_text_strategy = strategy; -} - -/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a - * smaller value of window_bits if it can do so safely. - */ -void PNGAPI -png_set_text_compression_window_bits(png_structp png_ptr, int window_bits) -{ - if (png_ptr == NULL) - return; - - if (window_bits > 15) - png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); - - else if (window_bits < 8) - png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); - -#ifndef WBITS_8_OK - /* Avoid libpng bug with 256-byte windows */ - if (window_bits == 8) - { - png_warning(png_ptr, "Text compression window is being reset to 512"); - window_bits = 9; - } - -#endif - png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS; - png_ptr->zlib_text_window_bits = window_bits; -} - -void PNGAPI -png_set_text_compression_method(png_structp png_ptr, int method) -{ - png_debug(1, "in png_set_text_compression_method"); - - if (png_ptr == NULL) - return; - - if (method != 8) - png_warning(png_ptr, "Only compression method 8 is supported by PNG"); - - png_ptr->flags |= PNG_FLAG_ZTXT_CUSTOM_METHOD; - png_ptr->zlib_text_method = method; -} -#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ -/* end of API added to libpng-1.5.4 */ - -void PNGAPI -png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) -{ - if (png_ptr == NULL) - return; - - png_ptr->write_row_fn = write_row_fn; -} - -#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED -void PNGAPI -png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr - write_user_transform_fn) -{ - png_debug(1, "in png_set_write_user_transform_fn"); - - if (png_ptr == NULL) - return; - - png_ptr->transformations |= PNG_USER_TRANSFORM; - png_ptr->write_user_transform_fn = write_user_transform_fn; -} -#endif - - -#ifdef PNG_INFO_IMAGE_SUPPORTED -void PNGAPI -png_write_png(png_structp png_ptr, png_infop info_ptr, - int transforms, voidp params) -{ - if (png_ptr == NULL || info_ptr == NULL) - return; - - /* Write the file header information. */ - png_write_info(png_ptr, info_ptr); - - /* ------ these transformations don't touch the info structure ------- */ - -#ifdef PNG_WRITE_INVERT_SUPPORTED - /* Invert monochrome pixels */ - if (transforms & PNG_TRANSFORM_INVERT_MONO) - png_set_invert_mono(png_ptr); -#endif - -#ifdef PNG_WRITE_SHIFT_SUPPORTED - /* Shift the pixels up to a legal bit depth and fill in - * as appropriate to correctly scale the image. - */ - if ((transforms & PNG_TRANSFORM_SHIFT) - && (info_ptr->valid & PNG_INFO_sBIT)) - png_set_shift(png_ptr, &info_ptr->sig_bit); -#endif - -#ifdef PNG_WRITE_PACK_SUPPORTED - /* Pack pixels into bytes */ - if (transforms & PNG_TRANSFORM_PACKING) - png_set_packing(png_ptr); -#endif - -#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED - /* Swap location of alpha bytes from ARGB to RGBA */ - if (transforms & PNG_TRANSFORM_SWAP_ALPHA) - png_set_swap_alpha(png_ptr); -#endif - -#ifdef PNG_WRITE_FILLER_SUPPORTED - /* Pack XRGB/RGBX/ARGB/RGBA into RGB (4 channels -> 3 channels) */ - if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) - png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); - - else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) - png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); -#endif - -#ifdef PNG_WRITE_BGR_SUPPORTED - /* Flip BGR pixels to RGB */ - if (transforms & PNG_TRANSFORM_BGR) - png_set_bgr(png_ptr); -#endif - -#ifdef PNG_WRITE_SWAP_SUPPORTED - /* Swap bytes of 16-bit files to most significant byte first */ - if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) - png_set_swap(png_ptr); -#endif - -#ifdef PNG_WRITE_PACKSWAP_SUPPORTED - /* Swap bits of 1, 2, 4 bit packed pixel formats */ - if (transforms & PNG_TRANSFORM_PACKSWAP) - png_set_packswap(png_ptr); -#endif - -#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED - /* Invert the alpha channel from opacity to transparency */ - if (transforms & PNG_TRANSFORM_INVERT_ALPHA) - png_set_invert_alpha(png_ptr); -#endif - - /* ----------------------- end of transformations ------------------- */ - - /* Write the bits */ - if (info_ptr->valid & PNG_INFO_IDAT) - png_write_image(png_ptr, info_ptr->row_pointers); - - /* It is REQUIRED to call this to finish writing the rest of the file */ - png_write_end(png_ptr, info_ptr); - - PNG_UNUSED(transforms) /* Quiet compiler warnings */ - PNG_UNUSED(params) -} -#endif -#endif /* PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngwtran.c b/source/libpng/pngwtran.c deleted file mode 100644 index b598149..0000000 --- a/source/libpng/pngwtran.c +++ /dev/null @@ -1,633 +0,0 @@ - -/* pngwtran.c - transforms the data in a row for PNG writers - * - * Last changed in libpng 1.5.6 [November 3, 2011] - * Copyright (c) 1998-2011 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -#include "pngpriv.h" - -#ifdef PNG_WRITE_SUPPORTED - -#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED -/* Transform the data according to the user's wishes. The order of - * transformations is significant. - */ -void /* PRIVATE */ -png_do_write_transformations(png_structp png_ptr, png_row_infop row_info) -{ - png_debug(1, "in png_do_write_transformations"); - - if (png_ptr == NULL) - return; - -#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED - if (png_ptr->transformations & PNG_USER_TRANSFORM) - if (png_ptr->write_user_transform_fn != NULL) - (*(png_ptr->write_user_transform_fn)) /* User write transform - function */ - (png_ptr, /* png_ptr */ - row_info, /* row_info: */ - /* png_uint_32 width; width of row */ - /* png_size_t rowbytes; number of bytes in row */ - /* png_byte color_type; color type of pixels */ - /* png_byte bit_depth; bit depth of samples */ - /* png_byte channels; number of channels (1-4) */ - /* png_byte pixel_depth; bits per pixel (depth*channels) */ - png_ptr->row_buf + 1); /* start of pixel data for row */ -#endif - -#ifdef PNG_WRITE_FILLER_SUPPORTED - if (png_ptr->transformations & PNG_FILLER) - png_do_strip_channel(row_info, png_ptr->row_buf + 1, - !(png_ptr->flags & PNG_FLAG_FILLER_AFTER)); -#endif - -#ifdef PNG_WRITE_PACKSWAP_SUPPORTED - if (png_ptr->transformations & PNG_PACKSWAP) - png_do_packswap(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_WRITE_PACK_SUPPORTED - if (png_ptr->transformations & PNG_PACK) - png_do_pack(row_info, png_ptr->row_buf + 1, - (png_uint_32)png_ptr->bit_depth); -#endif - -#ifdef PNG_WRITE_SWAP_SUPPORTED - if (png_ptr->transformations & PNG_SWAP_BYTES) - png_do_swap(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_WRITE_SHIFT_SUPPORTED - if (png_ptr->transformations & PNG_SHIFT) - png_do_shift(row_info, png_ptr->row_buf + 1, - &(png_ptr->shift)); -#endif - -#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED - if (png_ptr->transformations & PNG_SWAP_ALPHA) - png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED - if (png_ptr->transformations & PNG_INVERT_ALPHA) - png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_WRITE_BGR_SUPPORTED - if (png_ptr->transformations & PNG_BGR) - png_do_bgr(row_info, png_ptr->row_buf + 1); -#endif - -#ifdef PNG_WRITE_INVERT_SUPPORTED - if (png_ptr->transformations & PNG_INVERT_MONO) - png_do_invert(row_info, png_ptr->row_buf + 1); -#endif -} - -#ifdef PNG_WRITE_PACK_SUPPORTED -/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The - * row_info bit depth should be 8 (one pixel per byte). The channels - * should be 1 (this only happens on grayscale and paletted images). - */ -void /* PRIVATE */ -png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) -{ - png_debug(1, "in png_do_pack"); - - if (row_info->bit_depth == 8 && - row_info->channels == 1) - { - switch ((int)bit_depth) - { - case 1: - { - png_bytep sp, dp; - int mask, v; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - sp = row; - dp = row; - mask = 0x80; - v = 0; - - for (i = 0; i < row_width; i++) - { - if (*sp != 0) - v |= mask; - - sp++; - - if (mask > 1) - mask >>= 1; - - else - { - mask = 0x80; - *dp = (png_byte)v; - dp++; - v = 0; - } - } - - if (mask != 0x80) - *dp = (png_byte)v; - - break; - } - - case 2: - { - png_bytep sp, dp; - int shift, v; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - sp = row; - dp = row; - shift = 6; - v = 0; - - for (i = 0; i < row_width; i++) - { - png_byte value; - - value = (png_byte)(*sp & 0x03); - v |= (value << shift); - - if (shift == 0) - { - shift = 6; - *dp = (png_byte)v; - dp++; - v = 0; - } - - else - shift -= 2; - - sp++; - } - - if (shift != 6) - *dp = (png_byte)v; - - break; - } - - case 4: - { - png_bytep sp, dp; - int shift, v; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - sp = row; - dp = row; - shift = 4; - v = 0; - - for (i = 0; i < row_width; i++) - { - png_byte value; - - value = (png_byte)(*sp & 0x0f); - v |= (value << shift); - - if (shift == 0) - { - shift = 4; - *dp = (png_byte)v; - dp++; - v = 0; - } - - else - shift -= 4; - - sp++; - } - - if (shift != 4) - *dp = (png_byte)v; - - break; - } - - default: - break; - } - - row_info->bit_depth = (png_byte)bit_depth; - row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, - row_info->width); - } -} -#endif - -#ifdef PNG_WRITE_SHIFT_SUPPORTED -/* Shift pixel values to take advantage of whole range. Pass the - * true number of bits in bit_depth. The row should be packed - * according to row_info->bit_depth. Thus, if you had a row of - * bit depth 4, but the pixels only had values from 0 to 7, you - * would pass 3 as bit_depth, and this routine would translate the - * data to 0 to 15. - */ -void /* PRIVATE */ -png_do_shift(png_row_infop row_info, png_bytep row, - png_const_color_8p bit_depth) -{ - png_debug(1, "in png_do_shift"); - - if (row_info->color_type != PNG_COLOR_TYPE_PALETTE) - { - int shift_start[4], shift_dec[4]; - int channels = 0; - - if (row_info->color_type & PNG_COLOR_MASK_COLOR) - { - shift_start[channels] = row_info->bit_depth - bit_depth->red; - shift_dec[channels] = bit_depth->red; - channels++; - - shift_start[channels] = row_info->bit_depth - bit_depth->green; - shift_dec[channels] = bit_depth->green; - channels++; - - shift_start[channels] = row_info->bit_depth - bit_depth->blue; - shift_dec[channels] = bit_depth->blue; - channels++; - } - - else - { - shift_start[channels] = row_info->bit_depth - bit_depth->gray; - shift_dec[channels] = bit_depth->gray; - channels++; - } - - if (row_info->color_type & PNG_COLOR_MASK_ALPHA) - { - shift_start[channels] = row_info->bit_depth - bit_depth->alpha; - shift_dec[channels] = bit_depth->alpha; - channels++; - } - - /* With low row depths, could only be grayscale, so one channel */ - if (row_info->bit_depth < 8) - { - png_bytep bp = row; - png_size_t i; - png_byte mask; - png_size_t row_bytes = row_info->rowbytes; - - if (bit_depth->gray == 1 && row_info->bit_depth == 2) - mask = 0x55; - - else if (row_info->bit_depth == 4 && bit_depth->gray == 3) - mask = 0x11; - - else - mask = 0xff; - - for (i = 0; i < row_bytes; i++, bp++) - { - png_uint_16 v; - int j; - - v = *bp; - *bp = 0; - - for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) - { - if (j > 0) - *bp |= (png_byte)((v << j) & 0xff); - - else - *bp |= (png_byte)((v >> (-j)) & mask); - } - } - } - - else if (row_info->bit_depth == 8) - { - png_bytep bp = row; - png_uint_32 i; - png_uint_32 istop = channels * row_info->width; - - for (i = 0; i < istop; i++, bp++) - { - - png_uint_16 v; - int j; - int c = (int)(i%channels); - - v = *bp; - *bp = 0; - - for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) - { - if (j > 0) - *bp |= (png_byte)((v << j) & 0xff); - - else - *bp |= (png_byte)((v >> (-j)) & 0xff); - } - } - } - - else - { - png_bytep bp; - png_uint_32 i; - png_uint_32 istop = channels * row_info->width; - - for (bp = row, i = 0; i < istop; i++) - { - int c = (int)(i%channels); - png_uint_16 value, v; - int j; - - v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1)); - value = 0; - - for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) - { - if (j > 0) - value |= (png_uint_16)((v << j) & (png_uint_16)0xffff); - - else - value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff); - } - *bp++ = (png_byte)(value >> 8); - *bp++ = (png_byte)(value & 0xff); - } - } - } -} -#endif - -#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED -void /* PRIVATE */ -png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_write_swap_alpha"); - - { - if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This converts from ARGB to RGBA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - png_byte save = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = save; - } - } - -#ifdef PNG_WRITE_16BIT_SUPPORTED - else - { - /* This converts from AARRGGBB to RRGGBBAA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - png_byte save[2]; - save[0] = *(sp++); - save[1] = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = save[0]; - *(dp++) = save[1]; - } - } -#endif /* PNG_WRITE_16BIT_SUPPORTED */ - } - - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This converts from AG to GA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - png_byte save = *(sp++); - *(dp++) = *(sp++); - *(dp++) = save; - } - } - -#ifdef PNG_WRITE_16BIT_SUPPORTED - else - { - /* This converts from AAGG to GGAA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - png_byte save[2]; - save[0] = *(sp++); - save[1] = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = save[0]; - *(dp++) = save[1]; - } - } -#endif /* PNG_WRITE_16BIT_SUPPORTED */ - } - } -} -#endif - -#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED -void /* PRIVATE */ -png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_write_invert_alpha"); - - { - if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This inverts the alpha channel in RGBA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - /* Does nothing - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - */ - sp+=3; dp = sp; - *(dp++) = (png_byte)(255 - *(sp++)); - } - } - -#ifdef PNG_WRITE_16BIT_SUPPORTED - else - { - /* This inverts the alpha channel in RRGGBBAA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - /* Does nothing - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - *(dp++) = *(sp++); - */ - sp+=6; dp = sp; - *(dp++) = (png_byte)(255 - *(sp++)); - *(dp++) = (png_byte)(255 - *(sp++)); - } - } -#endif /* PNG_WRITE_16BIT_SUPPORTED */ - } - - else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) - { - if (row_info->bit_depth == 8) - { - /* This inverts the alpha channel in GA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - *(dp++) = *(sp++); - *(dp++) = (png_byte)(255 - *(sp++)); - } - } - -#ifdef PNG_WRITE_16BIT_SUPPORTED - else - { - /* This inverts the alpha channel in GGAA */ - png_bytep sp, dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - for (i = 0, sp = dp = row; i < row_width; i++) - { - /* Does nothing - *(dp++) = *(sp++); - *(dp++) = *(sp++); - */ - sp+=2; dp = sp; - *(dp++) = (png_byte)(255 - *(sp++)); - *(dp++) = (png_byte)(255 - *(sp++)); - } - } -#endif /* PNG_WRITE_16BIT_SUPPORTED */ - } - } -} -#endif -#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ - -#ifdef PNG_MNG_FEATURES_SUPPORTED -/* Undoes intrapixel differencing */ -void /* PRIVATE */ -png_do_write_intrapixel(png_row_infop row_info, png_bytep row) -{ - png_debug(1, "in png_do_write_intrapixel"); - - if ((row_info->color_type & PNG_COLOR_MASK_COLOR)) - { - int bytes_per_pixel; - png_uint_32 row_width = row_info->width; - if (row_info->bit_depth == 8) - { - png_bytep rp; - png_uint_32 i; - - if (row_info->color_type == PNG_COLOR_TYPE_RGB) - bytes_per_pixel = 3; - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - bytes_per_pixel = 4; - - else - return; - - for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) - { - *(rp) = (png_byte)((*rp - *(rp + 1)) & 0xff); - *(rp + 2) = (png_byte)((*(rp + 2) - *(rp + 1)) & 0xff); - } - } - -#ifdef PNG_WRITE_16BIT_SUPPORTED - else if (row_info->bit_depth == 16) - { - png_bytep rp; - png_uint_32 i; - - if (row_info->color_type == PNG_COLOR_TYPE_RGB) - bytes_per_pixel = 6; - - else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) - bytes_per_pixel = 8; - - else - return; - - for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) - { - png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1); - png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3); - png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5); - png_uint_32 red = (png_uint_32)((s0 - s1) & 0xffffL); - png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL); - *(rp ) = (png_byte)((red >> 8) & 0xff); - *(rp + 1) = (png_byte)(red & 0xff); - *(rp + 4) = (png_byte)((blue >> 8) & 0xff); - *(rp + 5) = (png_byte)(blue & 0xff); - } - } -#endif /* PNG_WRITE_16BIT_SUPPORTED */ - } -} -#endif /* PNG_MNG_FEATURES_SUPPORTED */ -#endif /* PNG_WRITE_SUPPORTED */ diff --git a/source/libpng/pngwutil.c b/source/libpng/pngwutil.c deleted file mode 100644 index c289e66..0000000 --- a/source/libpng/pngwutil.c +++ /dev/null @@ -1,3179 +0,0 @@ - -/* pngwutil.c - utilities to write a PNG file - * - * Last changed in libpng 1.5.10 [March 8, 2012] - * Copyright (c) 1998-2012 Glenn Randers-Pehrson - * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) - * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) - * - * This code is released under the libpng license. - * For conditions of distribution and use, see the disclaimer - * and license in png.h - */ - -#include "pngpriv.h" - -#ifdef PNG_WRITE_SUPPORTED - -#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED -/* Place a 32-bit number into a buffer in PNG byte order. We work - * with unsigned numbers for convenience, although one supported - * ancillary chunk uses signed (two's complement) numbers. - */ -void PNGAPI -png_save_uint_32(png_bytep buf, png_uint_32 i) -{ - buf[0] = (png_byte)((i >> 24) & 0xff); - buf[1] = (png_byte)((i >> 16) & 0xff); - buf[2] = (png_byte)((i >> 8) & 0xff); - buf[3] = (png_byte)(i & 0xff); -} - -#ifdef PNG_SAVE_INT_32_SUPPORTED -/* The png_save_int_32 function assumes integers are stored in two's - * complement format. If this isn't the case, then this routine needs to - * be modified to write data in two's complement format. Note that, - * the following works correctly even if png_int_32 has more than 32 bits - * (compare the more complex code required on read for sign extention.) - */ -void PNGAPI -png_save_int_32(png_bytep buf, png_int_32 i) -{ - buf[0] = (png_byte)((i >> 24) & 0xff); - buf[1] = (png_byte)((i >> 16) & 0xff); - buf[2] = (png_byte)((i >> 8) & 0xff); - buf[3] = (png_byte)(i & 0xff); -} -#endif - -/* Place a 16-bit number into a buffer in PNG byte order. - * The parameter is declared unsigned int, not png_uint_16, - * just to avoid potential problems on pre-ANSI C compilers. - */ -void PNGAPI -png_save_uint_16(png_bytep buf, unsigned int i) -{ - buf[0] = (png_byte)((i >> 8) & 0xff); - buf[1] = (png_byte)(i & 0xff); -} -#endif - -/* Simple function to write the signature. If we have already written - * the magic bytes of the signature, or more likely, the PNG stream is - * being embedded into another stream and doesn't need its own signature, - * we should call png_set_sig_bytes() to tell libpng how many of the - * bytes have already been written. - */ -void PNGAPI -png_write_sig(png_structp png_ptr) -{ - png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; - -#ifdef PNG_IO_STATE_SUPPORTED - /* Inform the I/O callback that the signature is being written */ - png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE; -#endif - - /* Write the rest of the 8 byte signature */ - png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], - (png_size_t)(8 - png_ptr->sig_bytes)); - - if (png_ptr->sig_bytes < 3) - png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; -} - -/* Write the start of a PNG chunk. The type is the chunk type. - * The total_length is the sum of the lengths of all the data you will be - * passing in png_write_chunk_data(). - */ -static void -png_write_chunk_header(png_structp png_ptr, png_uint_32 chunk_name, - png_uint_32 length) -{ - png_byte buf[8]; - -#if defined(PNG_DEBUG) && (PNG_DEBUG > 0) - PNG_CSTRING_FROM_CHUNK(buf, chunk_name); - png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length); -#endif - - if (png_ptr == NULL) - return; - -#ifdef PNG_IO_STATE_SUPPORTED - /* Inform the I/O callback that the chunk header is being written. - * PNG_IO_CHUNK_HDR requires a single I/O call. - */ - png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR; -#endif - - /* Write the length and the chunk name */ - png_save_uint_32(buf, length); - png_save_uint_32(buf + 4, chunk_name); - png_write_data(png_ptr, buf, 8); - - /* Put the chunk name into png_ptr->chunk_name */ - png_ptr->chunk_name = chunk_name; - - /* Reset the crc and run it over the chunk name */ - png_reset_crc(png_ptr); - - png_calculate_crc(png_ptr, buf + 4, 4); - -#ifdef PNG_IO_STATE_SUPPORTED - /* Inform the I/O callback that chunk data will (possibly) be written. - * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls. - */ - png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA; -#endif -} - -void PNGAPI -png_write_chunk_start(png_structp png_ptr, png_const_bytep chunk_string, - png_uint_32 length) -{ - png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length); -} - -/* Write the data of a PNG chunk started with png_write_chunk_header(). - * Note that multiple calls to this function are allowed, and that the - * sum of the lengths from these calls *must* add up to the total_length - * given to png_write_chunk_header(). - */ -void PNGAPI -png_write_chunk_data(png_structp png_ptr, png_const_bytep data, - png_size_t length) -{ - /* Write the data, and run the CRC over it */ - if (png_ptr == NULL) - return; - - if (data != NULL && length > 0) - { - png_write_data(png_ptr, data, length); - - /* Update the CRC after writing the data, - * in case that the user I/O routine alters it. - */ - png_calculate_crc(png_ptr, data, length); - } -} - -/* Finish a chunk started with png_write_chunk_header(). */ -void PNGAPI -png_write_chunk_end(png_structp png_ptr) -{ - png_byte buf[4]; - - if (png_ptr == NULL) return; - -#ifdef PNG_IO_STATE_SUPPORTED - /* Inform the I/O callback that the chunk CRC is being written. - * PNG_IO_CHUNK_CRC requires a single I/O function call. - */ - png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC; -#endif - - /* Write the crc in a single operation */ - png_save_uint_32(buf, png_ptr->crc); - - png_write_data(png_ptr, buf, (png_size_t)4); -} - -/* Write a PNG chunk all at once. The type is an array of ASCII characters - * representing the chunk name. The array must be at least 4 bytes in - * length, and does not need to be null terminated. To be safe, pass the - * pre-defined chunk names here, and if you need a new one, define it - * where the others are defined. The length is the length of the data. - * All the data must be present. If that is not possible, use the - * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() - * functions instead. - */ -static void -png_write_complete_chunk(png_structp png_ptr, png_uint_32 chunk_name, - png_const_bytep data, png_size_t length) -{ - if (png_ptr == NULL) - return; - - /* On 64 bit architectures 'length' may not fit in a png_uint_32. */ - if (length > PNG_UINT_32_MAX) - png_error(png_ptr, "length exceeds PNG maxima"); - - png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length); - png_write_chunk_data(png_ptr, data, length); - png_write_chunk_end(png_ptr); -} - -/* This is the API that calls the internal function above. */ -void PNGAPI -png_write_chunk(png_structp png_ptr, png_const_bytep chunk_string, - png_const_bytep data, png_size_t length) -{ - png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data, - length); -} - -/* Initialize the compressor for the appropriate type of compression. */ -static void -png_zlib_claim(png_structp png_ptr, png_uint_32 state) -{ - if (!(png_ptr->zlib_state & PNG_ZLIB_IN_USE)) - { - /* If already initialized for 'state' do not re-init. */ - if (png_ptr->zlib_state != state) - { - int ret = Z_OK; - png_const_charp who = "-"; - - /* If actually initialized for another state do a deflateEnd. */ - if (png_ptr->zlib_state != PNG_ZLIB_UNINITIALIZED) - { - ret = deflateEnd(&png_ptr->zstream); - who = "end"; - png_ptr->zlib_state = PNG_ZLIB_UNINITIALIZED; - } - - /* zlib itself detects an incomplete state on deflateEnd */ - if (ret == Z_OK) switch (state) - { -# ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED - case PNG_ZLIB_FOR_TEXT: - ret = deflateInit2(&png_ptr->zstream, - png_ptr->zlib_text_level, png_ptr->zlib_text_method, - png_ptr->zlib_text_window_bits, - png_ptr->zlib_text_mem_level, png_ptr->zlib_text_strategy); - who = "text"; - break; -# endif - - case PNG_ZLIB_FOR_IDAT: - ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, - png_ptr->zlib_method, png_ptr->zlib_window_bits, - png_ptr->zlib_mem_level, png_ptr->zlib_strategy); - who = "IDAT"; - break; - - default: - png_error(png_ptr, "invalid zlib state"); - } - - if (ret == Z_OK) - png_ptr->zlib_state = state; - - else /* an error in deflateEnd or deflateInit2 */ - { - size_t pos = 0; - char msg[64]; - - pos = png_safecat(msg, sizeof msg, pos, - "zlib failed to initialize compressor ("); - pos = png_safecat(msg, sizeof msg, pos, who); - - switch (ret) - { - case Z_VERSION_ERROR: - pos = png_safecat(msg, sizeof msg, pos, ") version error"); - break; - - case Z_STREAM_ERROR: - pos = png_safecat(msg, sizeof msg, pos, ") stream error"); - break; - - case Z_MEM_ERROR: - pos = png_safecat(msg, sizeof msg, pos, ") memory error"); - break; - - default: - pos = png_safecat(msg, sizeof msg, pos, ") unknown error"); - break; - } - - png_error(png_ptr, msg); - } - } - - /* Here on success, claim the zstream: */ - png_ptr->zlib_state |= PNG_ZLIB_IN_USE; - } - - else - png_error(png_ptr, "zstream already in use (internal error)"); -} - -/* The opposite: release the stream. It is also reset, this API will warn on - * error but will not fail. - */ -static void -png_zlib_release(png_structp png_ptr) -{ - if (png_ptr->zlib_state & PNG_ZLIB_IN_USE) - { - int ret = deflateReset(&png_ptr->zstream); - - png_ptr->zlib_state &= ~PNG_ZLIB_IN_USE; - - if (ret != Z_OK) - { - png_const_charp err; - PNG_WARNING_PARAMETERS(p) - - switch (ret) - { - case Z_VERSION_ERROR: - err = "version"; - break; - - case Z_STREAM_ERROR: - err = "stream"; - break; - - case Z_MEM_ERROR: - err = "memory"; - break; - - default: - err = "unknown"; - break; - } - - png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d, ret); - png_warning_parameter(p, 2, err); - - if (png_ptr->zstream.msg) - err = png_ptr->zstream.msg; - else - err = "[no zlib message]"; - - png_warning_parameter(p, 3, err); - - png_formatted_warning(png_ptr, p, - "zlib failed to reset compressor: @1(@2): @3"); - } - } - - else - png_warning(png_ptr, "zstream not in use (internal error)"); -} - -#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED -/* This pair of functions encapsulates the operation of (a) compressing a - * text string, and (b) issuing it later as a series of chunk data writes. - * The compression_state structure is shared context for these functions - * set up by the caller in order to make the whole mess thread-safe. - */ - -typedef struct -{ - png_const_bytep input; /* The uncompressed input data */ - png_size_t input_len; /* Its length */ - int num_output_ptr; /* Number of output pointers used */ - int max_output_ptr; /* Size of output_ptr */ - png_bytep *output_ptr; /* Array of pointers to output */ -} compression_state; - -/* Compress given text into storage in the png_ptr structure */ -static int /* PRIVATE */ -png_text_compress(png_structp png_ptr, - png_const_charp text, png_size_t text_len, int compression, - compression_state *comp) -{ - int ret; - - comp->num_output_ptr = 0; - comp->max_output_ptr = 0; - comp->output_ptr = NULL; - comp->input = NULL; - comp->input_len = text_len; - - /* We may just want to pass the text right through */ - if (compression == PNG_TEXT_COMPRESSION_NONE) - { - comp->input = (png_const_bytep)text; - return((int)text_len); - } - - if (compression >= PNG_TEXT_COMPRESSION_LAST) - { - PNG_WARNING_PARAMETERS(p) - - png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d, - compression); - png_formatted_warning(png_ptr, p, "Unknown compression type @1"); - } - - /* We can't write the chunk until we find out how much data we have, - * which means we need to run the compressor first and save the - * output. This shouldn't be a problem, as the vast majority of - * comments should be reasonable, but we will set up an array of - * malloc'd pointers to be sure. - * - * If we knew the application was well behaved, we could simplify this - * greatly by assuming we can always malloc an output buffer large - * enough to hold the compressed text ((1001 * text_len / 1000) + 12) - * and malloc this directly. The only time this would be a bad idea is - * if we can't malloc more than 64K and we have 64K of random input - * data, or if the input string is incredibly large (although this - * wouldn't cause a failure, just a slowdown due to swapping). - */ - png_zlib_claim(png_ptr, PNG_ZLIB_FOR_TEXT); - - /* Set up the compression buffers */ - /* TODO: the following cast hides a potential overflow problem. */ - png_ptr->zstream.avail_in = (uInt)text_len; - - /* NOTE: assume zlib doesn't overwrite the input */ - png_ptr->zstream.next_in = (Bytef *)text; - png_ptr->zstream.avail_out = png_ptr->zbuf_size; - png_ptr->zstream.next_out = png_ptr->zbuf; - - /* This is the same compression loop as in png_write_row() */ - do - { - /* Compress the data */ - ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); - - if (ret != Z_OK) - { - /* Error */ - if (png_ptr->zstream.msg != NULL) - png_error(png_ptr, png_ptr->zstream.msg); - - else - png_error(png_ptr, "zlib error"); - } - - /* Check to see if we need more room */ - if (!(png_ptr->zstream.avail_out)) - { - /* Make sure the output array has room */ - if (comp->num_output_ptr >= comp->max_output_ptr) - { - int old_max; - - old_max = comp->max_output_ptr; - comp->max_output_ptr = comp->num_output_ptr + 4; - if (comp->output_ptr != NULL) - { - png_bytepp old_ptr; - - old_ptr = comp->output_ptr; - - comp->output_ptr = (png_bytepp)png_malloc(png_ptr, - (png_alloc_size_t) - (comp->max_output_ptr * png_sizeof(png_charpp))); - - png_memcpy(comp->output_ptr, old_ptr, old_max - * png_sizeof(png_charp)); - - png_free(png_ptr, old_ptr); - } - else - comp->output_ptr = (png_bytepp)png_malloc(png_ptr, - (png_alloc_size_t) - (comp->max_output_ptr * png_sizeof(png_charp))); - } - - /* Save the data */ - comp->output_ptr[comp->num_output_ptr] = - (png_bytep)png_malloc(png_ptr, - (png_alloc_size_t)png_ptr->zbuf_size); - - png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, - png_ptr->zbuf_size); - - comp->num_output_ptr++; - - /* and reset the buffer */ - png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; - png_ptr->zstream.next_out = png_ptr->zbuf; - } - /* Continue until we don't have any more to compress */ - } while (png_ptr->zstream.avail_in); - - /* Finish the compression */ - do - { - /* Tell zlib we are finished */ - ret = deflate(&png_ptr->zstream, Z_FINISH); - - if (ret == Z_OK) - { - /* Check to see if we need more room */ - if (!(png_ptr->zstream.avail_out)) - { - /* Check to make sure our output array has room */ - if (comp->num_output_ptr >= comp->max_output_ptr) - { - int old_max; - - old_max = comp->max_output_ptr; - comp->max_output_ptr = comp->num_output_ptr + 4; - if (comp->output_ptr != NULL) - { - png_bytepp old_ptr; - - old_ptr = comp->output_ptr; - - /* This could be optimized to realloc() */ - comp->output_ptr = (png_bytepp)png_malloc(png_ptr, - (png_alloc_size_t)(comp->max_output_ptr * - png_sizeof(png_charp))); - - png_memcpy(comp->output_ptr, old_ptr, - old_max * png_sizeof(png_charp)); - - png_free(png_ptr, old_ptr); - } - - else - comp->output_ptr = (png_bytepp)png_malloc(png_ptr, - (png_alloc_size_t)(comp->max_output_ptr * - png_sizeof(png_charp))); - } - - /* Save the data */ - comp->output_ptr[comp->num_output_ptr] = - (png_bytep)png_malloc(png_ptr, - (png_alloc_size_t)png_ptr->zbuf_size); - - png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, - png_ptr->zbuf_size); - - comp->num_output_ptr++; - - /* and reset the buffer pointers */ - png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; - png_ptr->zstream.next_out = png_ptr->zbuf; - } - } - else if (ret != Z_STREAM_END) - { - /* We got an error */ - if (png_ptr->zstream.msg != NULL) - png_error(png_ptr, png_ptr->zstream.msg); - - else - png_error(png_ptr, "zlib error"); - } - } while (ret != Z_STREAM_END); - - /* Text length is number of buffers plus last buffer */ - text_len = png_ptr->zbuf_size * comp->num_output_ptr; - - if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) - text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; - - return((int)text_len); -} - -/* Ship the compressed text out via chunk writes */ -static void /* PRIVATE */ -png_write_compressed_data_out(png_structp png_ptr, compression_state *comp, - png_size_t data_len) -{ - int i; - - /* Handle the no-compression case */ - if (comp->input) - { - png_write_chunk_data(png_ptr, comp->input, data_len); - - return; - } - -#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED - /* The zbuf_size test is because the code below doesn't work if zbuf_size is - * '1'; simply skip it to avoid memory overwrite. - */ - if (data_len >= 2 && comp->input_len < 16384 && png_ptr->zbuf_size > 1) - { - unsigned int z_cmf; /* zlib compression method and flags */ - - /* Optimize the CMF field in the zlib stream. This hack of the zlib - * stream is compliant to the stream specification. - */ - - if (comp->num_output_ptr) - z_cmf = comp->output_ptr[0][0]; - else - z_cmf = png_ptr->zbuf[0]; - - if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) - { - unsigned int z_cinfo; - unsigned int half_z_window_size; - png_size_t uncompressed_text_size = comp->input_len; - - z_cinfo = z_cmf >> 4; - half_z_window_size = 1 << (z_cinfo + 7); - - while (uncompressed_text_size <= half_z_window_size && - half_z_window_size >= 256) - { - z_cinfo--; - half_z_window_size >>= 1; - } - - z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); - - if (comp->num_output_ptr) - { - - if (comp->output_ptr[0][0] != z_cmf) - { - int tmp; - - comp->output_ptr[0][0] = (png_byte)z_cmf; - tmp = comp->output_ptr[0][1] & 0xe0; - tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; - comp->output_ptr[0][1] = (png_byte)tmp; - } - } - else - { - int tmp; - - png_ptr->zbuf[0] = (png_byte)z_cmf; - tmp = png_ptr->zbuf[1] & 0xe0; - tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; - png_ptr->zbuf[1] = (png_byte)tmp; - } - } - - else - png_error(png_ptr, - "Invalid zlib compression method or flags in non-IDAT chunk"); - } -#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */ - - /* Write saved output buffers, if any */ - for (i = 0; i < comp->num_output_ptr; i++) - { - png_write_chunk_data(png_ptr, comp->output_ptr[i], - (png_size_t)png_ptr->zbuf_size); - - png_free(png_ptr, comp->output_ptr[i]); - } - - if (comp->max_output_ptr != 0) - png_free(png_ptr, comp->output_ptr); - - /* Write anything left in zbuf */ - if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) - png_write_chunk_data(png_ptr, png_ptr->zbuf, - (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); - - /* Reset zlib for another zTXt/iTXt or image data */ - png_zlib_release(png_ptr); -} -#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */ - -/* Write the IHDR chunk, and update the png_struct with the necessary - * information. Note that the rest of this code depends upon this - * information being correct. - */ -void /* PRIVATE */ -png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, - int bit_depth, int color_type, int compression_type, int filter_type, - int interlace_type) -{ - png_byte buf[13]; /* Buffer to store the IHDR info */ - - png_debug(1, "in png_write_IHDR"); - - /* Check that we have valid input data from the application info */ - switch (color_type) - { - case PNG_COLOR_TYPE_GRAY: - switch (bit_depth) - { - case 1: - case 2: - case 4: - case 8: -#ifdef PNG_WRITE_16BIT_SUPPORTED - case 16: -#endif - png_ptr->channels = 1; break; - - default: - png_error(png_ptr, - "Invalid bit depth for grayscale image"); - } - break; - - case PNG_COLOR_TYPE_RGB: -#ifdef PNG_WRITE_16BIT_SUPPORTED - if (bit_depth != 8 && bit_depth != 16) -#else - if (bit_depth != 8) -#endif - png_error(png_ptr, "Invalid bit depth for RGB image"); - - png_ptr->channels = 3; - break; - - case PNG_COLOR_TYPE_PALETTE: - switch (bit_depth) - { - case 1: - case 2: - case 4: - case 8: - png_ptr->channels = 1; - break; - - default: - png_error(png_ptr, "Invalid bit depth for paletted image"); - } - break; - - case PNG_COLOR_TYPE_GRAY_ALPHA: - if (bit_depth != 8 && bit_depth != 16) - png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); - - png_ptr->channels = 2; - break; - - case PNG_COLOR_TYPE_RGB_ALPHA: -#ifdef PNG_WRITE_16BIT_SUPPORTED - if (bit_depth != 8 && bit_depth != 16) -#else - if (bit_depth != 8) -#endif - png_error(png_ptr, "Invalid bit depth for RGBA image"); - - png_ptr->channels = 4; - break; - - default: - png_error(png_ptr, "Invalid image color type specified"); - } - - if (compression_type != PNG_COMPRESSION_TYPE_BASE) - { - png_warning(png_ptr, "Invalid compression type specified"); - compression_type = PNG_COMPRESSION_TYPE_BASE; - } - - /* Write filter_method 64 (intrapixel differencing) only if - * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and - * 2. Libpng did not write a PNG signature (this filter_method is only - * used in PNG datastreams that are embedded in MNG datastreams) and - * 3. The application called png_permit_mng_features with a mask that - * included PNG_FLAG_MNG_FILTER_64 and - * 4. The filter_method is 64 and - * 5. The color_type is RGB or RGBA - */ - if ( -#ifdef PNG_MNG_FEATURES_SUPPORTED - !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && - ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && - (color_type == PNG_COLOR_TYPE_RGB || - color_type == PNG_COLOR_TYPE_RGB_ALPHA) && - (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && -#endif - filter_type != PNG_FILTER_TYPE_BASE) - { - png_warning(png_ptr, "Invalid filter type specified"); - filter_type = PNG_FILTER_TYPE_BASE; - } - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - if (interlace_type != PNG_INTERLACE_NONE && - interlace_type != PNG_INTERLACE_ADAM7) - { - png_warning(png_ptr, "Invalid interlace type specified"); - interlace_type = PNG_INTERLACE_ADAM7; - } -#else - interlace_type=PNG_INTERLACE_NONE; -#endif - - /* Save the relevent information */ - png_ptr->bit_depth = (png_byte)bit_depth; - png_ptr->color_type = (png_byte)color_type; - png_ptr->interlaced = (png_byte)interlace_type; -#ifdef PNG_MNG_FEATURES_SUPPORTED - png_ptr->filter_type = (png_byte)filter_type; -#endif - png_ptr->compression_type = (png_byte)compression_type; - png_ptr->width = width; - png_ptr->height = height; - - png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); - png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); - /* Set the usr info, so any transformations can modify it */ - png_ptr->usr_width = png_ptr->width; - png_ptr->usr_bit_depth = png_ptr->bit_depth; - png_ptr->usr_channels = png_ptr->channels; - - /* Pack the header information into the buffer */ - png_save_uint_32(buf, width); - png_save_uint_32(buf + 4, height); - buf[8] = (png_byte)bit_depth; - buf[9] = (png_byte)color_type; - buf[10] = (png_byte)compression_type; - buf[11] = (png_byte)filter_type; - buf[12] = (png_byte)interlace_type; - - /* Write the chunk */ - png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13); - - /* Initialize zlib with PNG info */ - png_ptr->zstream.zalloc = png_zalloc; - png_ptr->zstream.zfree = png_zfree; - png_ptr->zstream.opaque = (voidpf)png_ptr; - - if (!(png_ptr->do_filter)) - { - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || - png_ptr->bit_depth < 8) - png_ptr->do_filter = PNG_FILTER_NONE; - - else - png_ptr->do_filter = PNG_ALL_FILTERS; - } - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) - { - if (png_ptr->do_filter != PNG_FILTER_NONE) - png_ptr->zlib_strategy = Z_FILTERED; - - else - png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; - } - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) - png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) - png_ptr->zlib_mem_level = 8; - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) - png_ptr->zlib_window_bits = 15; - - if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) - png_ptr->zlib_method = 8; - -#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED -#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED - if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_STRATEGY)) - png_ptr->zlib_text_strategy = Z_DEFAULT_STRATEGY; - - if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_LEVEL)) - png_ptr->zlib_text_level = png_ptr->zlib_level; - - if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_MEM_LEVEL)) - png_ptr->zlib_text_mem_level = png_ptr->zlib_mem_level; - - if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_WINDOW_BITS)) - png_ptr->zlib_text_window_bits = png_ptr->zlib_window_bits; - - if (!(png_ptr->flags & PNG_FLAG_ZTXT_CUSTOM_METHOD)) - png_ptr->zlib_text_method = png_ptr->zlib_method; -#else - png_ptr->zlib_text_strategy = Z_DEFAULT_STRATEGY; - png_ptr->zlib_text_level = png_ptr->zlib_level; - png_ptr->zlib_text_mem_level = png_ptr->zlib_mem_level; - png_ptr->zlib_text_window_bits = png_ptr->zlib_window_bits; - png_ptr->zlib_text_method = png_ptr->zlib_method; -#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ -#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */ - - /* Record that the compressor has not yet been initialized. */ - png_ptr->zlib_state = PNG_ZLIB_UNINITIALIZED; - - png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */ -} - -/* Write the palette. We are careful not to trust png_color to be in the - * correct order for PNG, so people can redefine it to any convenient - * structure. - */ -void /* PRIVATE */ -png_write_PLTE(png_structp png_ptr, png_const_colorp palette, - png_uint_32 num_pal) -{ - png_uint_32 i; - png_const_colorp pal_ptr; - png_byte buf[3]; - - png_debug(1, "in png_write_PLTE"); - - if (( -#ifdef PNG_MNG_FEATURES_SUPPORTED - !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) && -#endif - num_pal == 0) || num_pal > 256) - { - if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) - { - png_error(png_ptr, "Invalid number of colors in palette"); - } - - else - { - png_warning(png_ptr, "Invalid number of colors in palette"); - return; - } - } - - if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) - { - png_warning(png_ptr, - "Ignoring request to write a PLTE chunk in grayscale PNG"); - - return; - } - - png_ptr->num_palette = (png_uint_16)num_pal; - png_debug1(3, "num_palette = %d", png_ptr->num_palette); - - png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3)); -#ifdef PNG_POINTER_INDEXING_SUPPORTED - - for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) - { - buf[0] = pal_ptr->red; - buf[1] = pal_ptr->green; - buf[2] = pal_ptr->blue; - png_write_chunk_data(png_ptr, buf, (png_size_t)3); - } - -#else - /* This is a little slower but some buggy compilers need to do this - * instead - */ - pal_ptr=palette; - - for (i = 0; i < num_pal; i++) - { - buf[0] = pal_ptr[i].red; - buf[1] = pal_ptr[i].green; - buf[2] = pal_ptr[i].blue; - png_write_chunk_data(png_ptr, buf, (png_size_t)3); - } - -#endif - png_write_chunk_end(png_ptr); - png_ptr->mode |= PNG_HAVE_PLTE; -} - -/* Write an IDAT chunk */ -void /* PRIVATE */ -png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) -{ - png_debug(1, "in png_write_IDAT"); - -#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED - if (!(png_ptr->mode & PNG_HAVE_IDAT) && - png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) - { - /* Optimize the CMF field in the zlib stream. This hack of the zlib - * stream is compliant to the stream specification. - */ - unsigned int z_cmf = data[0]; /* zlib compression method and flags */ - - if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) - { - /* Avoid memory underflows and multiplication overflows. - * - * The conditions below are practically always satisfied; - * however, they still must be checked. - */ - if (length >= 2 && - png_ptr->height < 16384 && png_ptr->width < 16384) - { - /* Compute the maximum possible length of the datastream */ - - /* Number of pixels, plus for each row a filter byte - * and possibly a padding byte, so increase the maximum - * size to account for these. - */ - unsigned int z_cinfo; - unsigned int half_z_window_size; - png_uint_32 uncompressed_idat_size = png_ptr->height * - ((png_ptr->width * - png_ptr->channels * png_ptr->bit_depth + 15) >> 3); - - /* If it's interlaced, each block of 8 rows is sent as up to - * 14 rows, i.e., 6 additional rows, each with a filter byte - * and possibly a padding byte - */ - if (png_ptr->interlaced) - uncompressed_idat_size += ((png_ptr->height + 7)/8) * - (png_ptr->bit_depth < 8 ? 12 : 6); - - z_cinfo = z_cmf >> 4; - half_z_window_size = 1 << (z_cinfo + 7); - - while (uncompressed_idat_size <= half_z_window_size && - half_z_window_size >= 256) - { - z_cinfo--; - half_z_window_size >>= 1; - } - - z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); - - if (data[0] != z_cmf) - { - int tmp; - data[0] = (png_byte)z_cmf; - tmp = data[1] & 0xe0; - tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; - data[1] = (png_byte)tmp; - } - } - } - - else - png_error(png_ptr, - "Invalid zlib compression method or flags in IDAT"); - } -#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */ - - png_write_complete_chunk(png_ptr, png_IDAT, data, length); - png_ptr->mode |= PNG_HAVE_IDAT; - - /* Prior to 1.5.4 this code was replicated in every caller (except at the - * end, where it isn't technically necessary). Since this function has - * flushed the data we can safely reset the zlib output buffer here. - */ - png_ptr->zstream.next_out = png_ptr->zbuf; - png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -} - -/* Write an IEND chunk */ -void /* PRIVATE */ -png_write_IEND(png_structp png_ptr) -{ - png_debug(1, "in png_write_IEND"); - - png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0); - png_ptr->mode |= PNG_HAVE_IEND; -} - -#ifdef PNG_WRITE_gAMA_SUPPORTED -/* Write a gAMA chunk */ -void /* PRIVATE */ -png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) -{ - png_byte buf[4]; - - png_debug(1, "in png_write_gAMA"); - - /* file_gamma is saved in 1/100,000ths */ - png_save_uint_32(buf, (png_uint_32)file_gamma); - png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); -} -#endif - -#ifdef PNG_WRITE_sRGB_SUPPORTED -/* Write a sRGB chunk */ -void /* PRIVATE */ -png_write_sRGB(png_structp png_ptr, int srgb_intent) -{ - png_byte buf[1]; - - png_debug(1, "in png_write_sRGB"); - - if (srgb_intent >= PNG_sRGB_INTENT_LAST) - png_warning(png_ptr, - "Invalid sRGB rendering intent specified"); - - buf[0]=(png_byte)srgb_intent; - png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1); -} -#endif - -#ifdef PNG_WRITE_iCCP_SUPPORTED -/* Write an iCCP chunk */ -void /* PRIVATE */ -png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type, - png_const_charp profile, int profile_len) -{ - png_size_t name_len; - png_charp new_name; - compression_state comp; - int embedded_profile_len = 0; - - png_debug(1, "in png_write_iCCP"); - - comp.num_output_ptr = 0; - comp.max_output_ptr = 0; - comp.output_ptr = NULL; - comp.input = NULL; - comp.input_len = 0; - - if ((name_len = png_check_keyword(png_ptr, name, &new_name)) == 0) - return; - - if (compression_type != PNG_COMPRESSION_TYPE_BASE) - png_warning(png_ptr, "Unknown compression type in iCCP chunk"); - - if (profile == NULL) - profile_len = 0; - - if (profile_len > 3) - embedded_profile_len = - ((*( (png_const_bytep)profile ))<<24) | - ((*( (png_const_bytep)profile + 1))<<16) | - ((*( (png_const_bytep)profile + 2))<< 8) | - ((*( (png_const_bytep)profile + 3)) ); - - if (embedded_profile_len < 0) - { - png_warning(png_ptr, - "Embedded profile length in iCCP chunk is negative"); - - png_free(png_ptr, new_name); - return; - } - - if (profile_len < embedded_profile_len) - { - png_warning(png_ptr, - "Embedded profile length too large in iCCP chunk"); - - png_free(png_ptr, new_name); - return; - } - - if (profile_len > embedded_profile_len) - { - png_warning(png_ptr, - "Truncating profile to actual length in iCCP chunk"); - - profile_len = embedded_profile_len; - } - - if (profile_len) - profile_len = png_text_compress(png_ptr, profile, - (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp); - - /* Make sure we include the NULL after the name and the compression type */ - png_write_chunk_header(png_ptr, png_iCCP, - (png_uint_32)(name_len + profile_len + 2)); - - new_name[name_len + 1] = 0x00; - - png_write_chunk_data(png_ptr, (png_bytep)new_name, - (png_size_t)(name_len + 2)); - - if (profile_len) - { - png_write_compressed_data_out(png_ptr, &comp, profile_len); - } - - png_write_chunk_end(png_ptr); - png_free(png_ptr, new_name); -} -#endif - -#ifdef PNG_WRITE_sPLT_SUPPORTED -/* Write a sPLT chunk */ -void /* PRIVATE */ -png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette) -{ - png_size_t name_len; - png_charp new_name; - png_byte entrybuf[10]; - png_size_t entry_size = (spalette->depth == 8 ? 6 : 10); - png_size_t palette_size = entry_size * spalette->nentries; - png_sPLT_entryp ep; -#ifndef PNG_POINTER_INDEXING_SUPPORTED - int i; -#endif - - png_debug(1, "in png_write_sPLT"); - - if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0) - return; - - /* Make sure we include the NULL after the name */ - png_write_chunk_header(png_ptr, png_sPLT, - (png_uint_32)(name_len + 2 + palette_size)); - - png_write_chunk_data(png_ptr, (png_bytep)new_name, - (png_size_t)(name_len + 1)); - - png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1); - - /* Loop through each palette entry, writing appropriately */ -#ifdef PNG_POINTER_INDEXING_SUPPORTED - for (ep = spalette->entries; epentries + spalette->nentries; ep++) - { - if (spalette->depth == 8) - { - entrybuf[0] = (png_byte)ep->red; - entrybuf[1] = (png_byte)ep->green; - entrybuf[2] = (png_byte)ep->blue; - entrybuf[3] = (png_byte)ep->alpha; - png_save_uint_16(entrybuf + 4, ep->frequency); - } - - else - { - png_save_uint_16(entrybuf + 0, ep->red); - png_save_uint_16(entrybuf + 2, ep->green); - png_save_uint_16(entrybuf + 4, ep->blue); - png_save_uint_16(entrybuf + 6, ep->alpha); - png_save_uint_16(entrybuf + 8, ep->frequency); - } - - png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); - } -#else - ep=spalette->entries; - for (i = 0; i>spalette->nentries; i++) - { - if (spalette->depth == 8) - { - entrybuf[0] = (png_byte)ep[i].red; - entrybuf[1] = (png_byte)ep[i].green; - entrybuf[2] = (png_byte)ep[i].blue; - entrybuf[3] = (png_byte)ep[i].alpha; - png_save_uint_16(entrybuf + 4, ep[i].frequency); - } - - else - { - png_save_uint_16(entrybuf + 0, ep[i].red); - png_save_uint_16(entrybuf + 2, ep[i].green); - png_save_uint_16(entrybuf + 4, ep[i].blue); - png_save_uint_16(entrybuf + 6, ep[i].alpha); - png_save_uint_16(entrybuf + 8, ep[i].frequency); - } - - png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); - } -#endif - - png_write_chunk_end(png_ptr); - png_free(png_ptr, new_name); -} -#endif - -#ifdef PNG_WRITE_sBIT_SUPPORTED -/* Write the sBIT chunk */ -void /* PRIVATE */ -png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type) -{ - png_byte buf[4]; - png_size_t size; - - png_debug(1, "in png_write_sBIT"); - - /* Make sure we don't depend upon the order of PNG_COLOR_8 */ - if (color_type & PNG_COLOR_MASK_COLOR) - { - png_byte maxbits; - - maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : - png_ptr->usr_bit_depth); - - if (sbit->red == 0 || sbit->red > maxbits || - sbit->green == 0 || sbit->green > maxbits || - sbit->blue == 0 || sbit->blue > maxbits) - { - png_warning(png_ptr, "Invalid sBIT depth specified"); - return; - } - - buf[0] = sbit->red; - buf[1] = sbit->green; - buf[2] = sbit->blue; - size = 3; - } - - else - { - if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) - { - png_warning(png_ptr, "Invalid sBIT depth specified"); - return; - } - - buf[0] = sbit->gray; - size = 1; - } - - if (color_type & PNG_COLOR_MASK_ALPHA) - { - if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) - { - png_warning(png_ptr, "Invalid sBIT depth specified"); - return; - } - - buf[size++] = sbit->alpha; - } - - png_write_complete_chunk(png_ptr, png_sBIT, buf, size); -} -#endif - -#ifdef PNG_WRITE_cHRM_SUPPORTED -/* Write the cHRM chunk */ -void /* PRIVATE */ -png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, - png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, - png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, - png_fixed_point blue_y) -{ - png_byte buf[32]; - - png_debug(1, "in png_write_cHRM"); - - /* Each value is saved in 1/100,000ths */ -#ifdef PNG_CHECK_cHRM_SUPPORTED - if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y, - green_x, green_y, blue_x, blue_y)) -#endif - { - png_save_uint_32(buf, (png_uint_32)white_x); - png_save_uint_32(buf + 4, (png_uint_32)white_y); - - png_save_uint_32(buf + 8, (png_uint_32)red_x); - png_save_uint_32(buf + 12, (png_uint_32)red_y); - - png_save_uint_32(buf + 16, (png_uint_32)green_x); - png_save_uint_32(buf + 20, (png_uint_32)green_y); - - png_save_uint_32(buf + 24, (png_uint_32)blue_x); - png_save_uint_32(buf + 28, (png_uint_32)blue_y); - - png_write_complete_chunk(png_ptr, png_cHRM, buf, (png_size_t)32); - } -} -#endif - -#ifdef PNG_WRITE_tRNS_SUPPORTED -/* Write the tRNS chunk */ -void /* PRIVATE */ -png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha, - png_const_color_16p tran, int num_trans, int color_type) -{ - png_byte buf[6]; - - png_debug(1, "in png_write_tRNS"); - - if (color_type == PNG_COLOR_TYPE_PALETTE) - { - if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) - { - png_warning(png_ptr, "Invalid number of transparent colors specified"); - return; - } - - /* Write the chunk out as it is */ - png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha, (png_size_t)num_trans); - } - - else if (color_type == PNG_COLOR_TYPE_GRAY) - { - /* One 16 bit value */ - if (tran->gray >= (1 << png_ptr->bit_depth)) - { - png_warning(png_ptr, - "Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); - - return; - } - - png_save_uint_16(buf, tran->gray); - png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2); - } - - else if (color_type == PNG_COLOR_TYPE_RGB) - { - /* Three 16 bit values */ - png_save_uint_16(buf, tran->red); - png_save_uint_16(buf + 2, tran->green); - png_save_uint_16(buf + 4, tran->blue); -#ifdef PNG_WRITE_16BIT_SUPPORTED - if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) -#else - if (buf[0] | buf[2] | buf[4]) -#endif - { - png_warning(png_ptr, - "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); - return; - } - - png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6); - } - - else - { - png_warning(png_ptr, "Can't write tRNS with an alpha channel"); - } -} -#endif - -#ifdef PNG_WRITE_bKGD_SUPPORTED -/* Write the background chunk */ -void /* PRIVATE */ -png_write_bKGD(png_structp png_ptr, png_const_color_16p back, int color_type) -{ - png_byte buf[6]; - - png_debug(1, "in png_write_bKGD"); - - if (color_type == PNG_COLOR_TYPE_PALETTE) - { - if ( -#ifdef PNG_MNG_FEATURES_SUPPORTED - (png_ptr->num_palette || - (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) && -#endif - back->index >= png_ptr->num_palette) - { - png_warning(png_ptr, "Invalid background palette index"); - return; - } - - buf[0] = back->index; - png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1); - } - - else if (color_type & PNG_COLOR_MASK_COLOR) - { - png_save_uint_16(buf, back->red); - png_save_uint_16(buf + 2, back->green); - png_save_uint_16(buf + 4, back->blue); -#ifdef PNG_WRITE_16BIT_SUPPORTED - if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) -#else - if (buf[0] | buf[2] | buf[4]) -#endif - { - png_warning(png_ptr, - "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); - - return; - } - - png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6); - } - - else - { - if (back->gray >= (1 << png_ptr->bit_depth)) - { - png_warning(png_ptr, - "Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); - - return; - } - - png_save_uint_16(buf, back->gray); - png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2); - } -} -#endif - -#ifdef PNG_WRITE_hIST_SUPPORTED -/* Write the histogram */ -void /* PRIVATE */ -png_write_hIST(png_structp png_ptr, png_const_uint_16p hist, int num_hist) -{ - int i; - png_byte buf[3]; - - png_debug(1, "in png_write_hIST"); - - if (num_hist > (int)png_ptr->num_palette) - { - png_debug2(3, "num_hist = %d, num_palette = %d", num_hist, - png_ptr->num_palette); - - png_warning(png_ptr, "Invalid number of histogram entries specified"); - return; - } - - png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2)); - - for (i = 0; i < num_hist; i++) - { - png_save_uint_16(buf, hist[i]); - png_write_chunk_data(png_ptr, buf, (png_size_t)2); - } - - png_write_chunk_end(png_ptr); -} -#endif - -#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ - defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) -/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, - * and if invalid, correct the keyword rather than discarding the entire - * chunk. The PNG 1.0 specification requires keywords 1-79 characters in - * length, forbids leading or trailing whitespace, multiple internal spaces, - * and the non-break space (0x80) from ISO 8859-1. Returns keyword length. - * - * The new_key is allocated to hold the corrected keyword and must be freed - * by the calling routine. This avoids problems with trying to write to - * static keywords without having to have duplicate copies of the strings. - */ -png_size_t /* PRIVATE */ -png_check_keyword(png_structp png_ptr, png_const_charp key, png_charpp new_key) -{ - png_size_t key_len; - png_const_charp ikp; - png_charp kp, dp; - int kflag; - int kwarn=0; - - png_debug(1, "in png_check_keyword"); - - *new_key = NULL; - - if (key == NULL || (key_len = png_strlen(key)) == 0) - { - png_warning(png_ptr, "zero length keyword"); - return ((png_size_t)0); - } - - png_debug1(2, "Keyword to be checked is '%s'", key); - - *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2)); - - if (*new_key == NULL) - { - png_warning(png_ptr, "Out of memory while procesing keyword"); - return ((png_size_t)0); - } - - /* Replace non-printing characters with a blank and print a warning */ - for (ikp = key, dp = *new_key; *ikp != '\0'; ikp++, dp++) - { - if ((png_byte)*ikp < 0x20 || - ((png_byte)*ikp > 0x7E && (png_byte)*ikp < 0xA1)) - { - PNG_WARNING_PARAMETERS(p) - - png_warning_parameter_unsigned(p, 1, PNG_NUMBER_FORMAT_02x, - (png_byte)*ikp); - png_formatted_warning(png_ptr, p, "invalid keyword character 0x@1"); - *dp = ' '; - } - - else - { - *dp = *ikp; - } - } - *dp = '\0'; - - /* Remove any trailing white space. */ - kp = *new_key + key_len - 1; - if (*kp == ' ') - { - png_warning(png_ptr, "trailing spaces removed from keyword"); - - while (*kp == ' ') - { - *(kp--) = '\0'; - key_len--; - } - } - - /* Remove any leading white space. */ - kp = *new_key; - if (*kp == ' ') - { - png_warning(png_ptr, "leading spaces removed from keyword"); - - while (*kp == ' ') - { - kp++; - key_len--; - } - } - - png_debug1(2, "Checking for multiple internal spaces in '%s'", kp); - - /* Remove multiple internal spaces. */ - for (kflag = 0, dp = *new_key; *kp != '\0'; kp++) - { - if (*kp == ' ' && kflag == 0) - { - *(dp++) = *kp; - kflag = 1; - } - - else if (*kp == ' ') - { - key_len--; - kwarn = 1; - } - - else - { - *(dp++) = *kp; - kflag = 0; - } - } - *dp = '\0'; - if (kwarn) - png_warning(png_ptr, "extra interior spaces removed from keyword"); - - if (key_len == 0) - { - png_free(png_ptr, *new_key); - png_warning(png_ptr, "Zero length keyword"); - } - - if (key_len > 79) - { - png_warning(png_ptr, "keyword length must be 1 - 79 characters"); - (*new_key)[79] = '\0'; - key_len = 79; - } - - return (key_len); -} -#endif - -#ifdef PNG_WRITE_tEXt_SUPPORTED -/* Write a tEXt chunk */ -void /* PRIVATE */ -png_write_tEXt(png_structp png_ptr, png_const_charp key, png_const_charp text, - png_size_t text_len) -{ - png_size_t key_len; - png_charp new_key; - - png_debug(1, "in png_write_tEXt"); - - if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0) - return; - - if (text == NULL || *text == '\0') - text_len = 0; - - else - text_len = png_strlen(text); - - /* Make sure we include the 0 after the key */ - png_write_chunk_header(png_ptr, png_tEXt, - (png_uint_32)(key_len + text_len + 1)); - /* - * We leave it to the application to meet PNG-1.0 requirements on the - * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of - * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. - * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. - */ - png_write_chunk_data(png_ptr, (png_bytep)new_key, - (png_size_t)(key_len + 1)); - - if (text_len) - png_write_chunk_data(png_ptr, (png_const_bytep)text, - (png_size_t)text_len); - - png_write_chunk_end(png_ptr); - png_free(png_ptr, new_key); -} -#endif - -#ifdef PNG_WRITE_zTXt_SUPPORTED -/* Write a compressed text chunk */ -void /* PRIVATE */ -png_write_zTXt(png_structp png_ptr, png_const_charp key, png_const_charp text, - png_size_t text_len, int compression) -{ - png_size_t key_len; - png_byte buf; - png_charp new_key; - compression_state comp; - - png_debug(1, "in png_write_zTXt"); - - comp.num_output_ptr = 0; - comp.max_output_ptr = 0; - comp.output_ptr = NULL; - comp.input = NULL; - comp.input_len = 0; - - if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0) - { - png_free(png_ptr, new_key); - return; - } - - if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE) - { - png_write_tEXt(png_ptr, new_key, text, (png_size_t)0); - png_free(png_ptr, new_key); - return; - } - - text_len = png_strlen(text); - - /* Compute the compressed data; do it now for the length */ - text_len = png_text_compress(png_ptr, text, text_len, compression, - &comp); - - /* Write start of chunk */ - png_write_chunk_header(png_ptr, png_zTXt, - (png_uint_32)(key_len+text_len + 2)); - - /* Write key */ - png_write_chunk_data(png_ptr, (png_bytep)new_key, - (png_size_t)(key_len + 1)); - - png_free(png_ptr, new_key); - - buf = (png_byte)compression; - - /* Write compression */ - png_write_chunk_data(png_ptr, &buf, (png_size_t)1); - - /* Write the compressed data */ - png_write_compressed_data_out(png_ptr, &comp, text_len); - - /* Close the chunk */ - png_write_chunk_end(png_ptr); -} -#endif - -#ifdef PNG_WRITE_iTXt_SUPPORTED -/* Write an iTXt chunk */ -void /* PRIVATE */ -png_write_iTXt(png_structp png_ptr, int compression, png_const_charp key, - png_const_charp lang, png_const_charp lang_key, png_const_charp text) -{ - png_size_t lang_len, key_len, lang_key_len, text_len; - png_charp new_lang; - png_charp new_key = NULL; - png_byte cbuf[2]; - compression_state comp; - - png_debug(1, "in png_write_iTXt"); - - comp.num_output_ptr = 0; - comp.max_output_ptr = 0; - comp.output_ptr = NULL; - comp.input = NULL; - - if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0) - return; - - if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang)) == 0) - { - png_warning(png_ptr, "Empty language field in iTXt chunk"); - new_lang = NULL; - lang_len = 0; - } - - if (lang_key == NULL) - lang_key_len = 0; - - else - lang_key_len = png_strlen(lang_key); - - if (text == NULL) - text_len = 0; - - else - text_len = png_strlen(text); - - /* Compute the compressed data; do it now for the length */ - text_len = png_text_compress(png_ptr, text, text_len, compression - 2, - &comp); - - - /* Make sure we include the compression flag, the compression byte, - * and the NULs after the key, lang, and lang_key parts - */ - - png_write_chunk_header(png_ptr, png_iTXt, (png_uint_32)( - 5 /* comp byte, comp flag, terminators for key, lang and lang_key */ - + key_len - + lang_len - + lang_key_len - + text_len)); - - /* We leave it to the application to meet PNG-1.0 requirements on the - * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of - * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. - * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. - */ - png_write_chunk_data(png_ptr, (png_bytep)new_key, (png_size_t)(key_len + 1)); - - /* Set the compression flag */ - if (compression == PNG_ITXT_COMPRESSION_NONE || - compression == PNG_TEXT_COMPRESSION_NONE) - cbuf[0] = 0; - - else /* compression == PNG_ITXT_COMPRESSION_zTXt */ - cbuf[0] = 1; - - /* Set the compression method */ - cbuf[1] = 0; - - png_write_chunk_data(png_ptr, cbuf, (png_size_t)2); - - cbuf[0] = 0; - png_write_chunk_data(png_ptr, (new_lang ? (png_const_bytep)new_lang : cbuf), - (png_size_t)(lang_len + 1)); - - png_write_chunk_data(png_ptr, (lang_key ? (png_const_bytep)lang_key : cbuf), - (png_size_t)(lang_key_len + 1)); - - png_write_compressed_data_out(png_ptr, &comp, text_len); - - png_write_chunk_end(png_ptr); - - png_free(png_ptr, new_key); - png_free(png_ptr, new_lang); -} -#endif - -#ifdef PNG_WRITE_oFFs_SUPPORTED -/* Write the oFFs chunk */ -void /* PRIVATE */ -png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, - int unit_type) -{ - png_byte buf[9]; - - png_debug(1, "in png_write_oFFs"); - - if (unit_type >= PNG_OFFSET_LAST) - png_warning(png_ptr, "Unrecognized unit type for oFFs chunk"); - - png_save_int_32(buf, x_offset); - png_save_int_32(buf + 4, y_offset); - buf[8] = (png_byte)unit_type; - - png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9); -} -#endif -#ifdef PNG_WRITE_pCAL_SUPPORTED -/* Write the pCAL chunk (described in the PNG extensions document) */ -void /* PRIVATE */ -png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, - png_int_32 X1, int type, int nparams, png_const_charp units, - png_charpp params) -{ - png_size_t purpose_len, units_len, total_len; - png_size_tp params_len; - png_byte buf[10]; - png_charp new_purpose; - int i; - - png_debug1(1, "in png_write_pCAL (%d parameters)", nparams); - - if (type >= PNG_EQUATION_LAST) - png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); - - purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; - png_debug1(3, "pCAL purpose length = %d", (int)purpose_len); - units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); - png_debug1(3, "pCAL units length = %d", (int)units_len); - total_len = purpose_len + units_len + 10; - - params_len = (png_size_tp)png_malloc(png_ptr, - (png_alloc_size_t)(nparams * png_sizeof(png_size_t))); - - /* Find the length of each parameter, making sure we don't count the - * null terminator for the last parameter. - */ - for (i = 0; i < nparams; i++) - { - params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1); - png_debug2(3, "pCAL parameter %d length = %lu", i, - (unsigned long)params_len[i]); - total_len += params_len[i]; - } - - png_debug1(3, "pCAL total length = %d", (int)total_len); - png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len); - png_write_chunk_data(png_ptr, (png_const_bytep)new_purpose, purpose_len); - png_save_int_32(buf, X0); - png_save_int_32(buf + 4, X1); - buf[8] = (png_byte)type; - buf[9] = (png_byte)nparams; - png_write_chunk_data(png_ptr, buf, (png_size_t)10); - png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len); - - png_free(png_ptr, new_purpose); - - for (i = 0; i < nparams; i++) - { - png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]); - } - - png_free(png_ptr, params_len); - png_write_chunk_end(png_ptr); -} -#endif - -#ifdef PNG_WRITE_sCAL_SUPPORTED -/* Write the sCAL chunk */ -void /* PRIVATE */ -png_write_sCAL_s(png_structp png_ptr, int unit, png_const_charp width, - png_const_charp height) -{ - png_byte buf[64]; - png_size_t wlen, hlen, total_len; - - png_debug(1, "in png_write_sCAL_s"); - - wlen = png_strlen(width); - hlen = png_strlen(height); - total_len = wlen + hlen + 2; - - if (total_len > 64) - { - png_warning(png_ptr, "Can't write sCAL (buffer too small)"); - return; - } - - buf[0] = (png_byte)unit; - png_memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */ - png_memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */ - - png_debug1(3, "sCAL total length = %u", (unsigned int)total_len); - png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len); -} -#endif - -#ifdef PNG_WRITE_pHYs_SUPPORTED -/* Write the pHYs chunk */ -void /* PRIVATE */ -png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, - png_uint_32 y_pixels_per_unit, - int unit_type) -{ - png_byte buf[9]; - - png_debug(1, "in png_write_pHYs"); - - if (unit_type >= PNG_RESOLUTION_LAST) - png_warning(png_ptr, "Unrecognized unit type for pHYs chunk"); - - png_save_uint_32(buf, x_pixels_per_unit); - png_save_uint_32(buf + 4, y_pixels_per_unit); - buf[8] = (png_byte)unit_type; - - png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9); -} -#endif - -#ifdef PNG_WRITE_tIME_SUPPORTED -/* Write the tIME chunk. Use either png_convert_from_struct_tm() - * or png_convert_from_time_t(), or fill in the structure yourself. - */ -void /* PRIVATE */ -png_write_tIME(png_structp png_ptr, png_const_timep mod_time) -{ - png_byte buf[7]; - - png_debug(1, "in png_write_tIME"); - - if (mod_time->month > 12 || mod_time->month < 1 || - mod_time->day > 31 || mod_time->day < 1 || - mod_time->hour > 23 || mod_time->second > 60) - { - png_warning(png_ptr, "Invalid time specified for tIME chunk"); - return; - } - - png_save_uint_16(buf, mod_time->year); - buf[2] = mod_time->month; - buf[3] = mod_time->day; - buf[4] = mod_time->hour; - buf[5] = mod_time->minute; - buf[6] = mod_time->second; - - png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7); -} -#endif - -/* Initializes the row writing capability of libpng */ -void /* PRIVATE */ -png_write_start_row(png_structp png_ptr) -{ -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - - /* Start of interlace block */ - static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; - - /* Offset to next interlace block */ - static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; - - /* Start of interlace block in the y direction */ - static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; - - /* Offset to next interlace block in the y direction */ - static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; -#endif - - png_alloc_size_t buf_size; - int usr_pixel_depth; - - png_debug(1, "in png_write_start_row"); - - usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth; - buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1; - - /* 1.5.6: added to allow checking in the row write code. */ - png_ptr->transformed_pixel_depth = png_ptr->pixel_depth; - png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth; - - /* Set up row buffer */ - png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size); - - png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; - -#ifdef PNG_WRITE_FILTER_SUPPORTED - /* Set up filtering buffer, if using this filter */ - if (png_ptr->do_filter & PNG_FILTER_SUB) - { - png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1); - - png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; - } - - /* We only need to keep the previous row if we are using one of these. */ - if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) - { - /* Set up previous row buffer */ - png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size); - - if (png_ptr->do_filter & PNG_FILTER_UP) - { - png_ptr->up_row = (png_bytep)png_malloc(png_ptr, - png_ptr->rowbytes + 1); - - png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; - } - - if (png_ptr->do_filter & PNG_FILTER_AVG) - { - png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, - png_ptr->rowbytes + 1); - - png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; - } - - if (png_ptr->do_filter & PNG_FILTER_PAETH) - { - png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, - png_ptr->rowbytes + 1); - - png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; - } - } -#endif /* PNG_WRITE_FILTER_SUPPORTED */ - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* If interlaced, we need to set up width and height of pass */ - if (png_ptr->interlaced) - { - if (!(png_ptr->transformations & PNG_INTERLACE)) - { - png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - - png_pass_ystart[0]) / png_pass_yinc[0]; - - png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - - png_pass_start[0]) / png_pass_inc[0]; - } - - else - { - png_ptr->num_rows = png_ptr->height; - png_ptr->usr_width = png_ptr->width; - } - } - - else -#endif - { - png_ptr->num_rows = png_ptr->height; - png_ptr->usr_width = png_ptr->width; - } - - png_zlib_claim(png_ptr, PNG_ZLIB_FOR_IDAT); - png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; - png_ptr->zstream.next_out = png_ptr->zbuf; -} - -/* Internal use only. Called when finished processing a row of data. */ -void /* PRIVATE */ -png_write_finish_row(png_structp png_ptr) -{ -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - - /* Start of interlace block */ - static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; - - /* Offset to next interlace block */ - static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; - - /* Start of interlace block in the y direction */ - static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; - - /* Offset to next interlace block in the y direction */ - static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; -#endif - - int ret; - - png_debug(1, "in png_write_finish_row"); - - /* Next row */ - png_ptr->row_number++; - - /* See if we are done */ - if (png_ptr->row_number < png_ptr->num_rows) - return; - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED - /* If interlaced, go to next pass */ - if (png_ptr->interlaced) - { - png_ptr->row_number = 0; - if (png_ptr->transformations & PNG_INTERLACE) - { - png_ptr->pass++; - } - - else - { - /* Loop until we find a non-zero width or height pass */ - do - { - png_ptr->pass++; - - if (png_ptr->pass >= 7) - break; - - png_ptr->usr_width = (png_ptr->width + - png_pass_inc[png_ptr->pass] - 1 - - png_pass_start[png_ptr->pass]) / - png_pass_inc[png_ptr->pass]; - - png_ptr->num_rows = (png_ptr->height + - png_pass_yinc[png_ptr->pass] - 1 - - png_pass_ystart[png_ptr->pass]) / - png_pass_yinc[png_ptr->pass]; - - if (png_ptr->transformations & PNG_INTERLACE) - break; - - } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); - - } - - /* Reset the row above the image for the next pass */ - if (png_ptr->pass < 7) - { - if (png_ptr->prev_row != NULL) - png_memset(png_ptr->prev_row, 0, - (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels* - png_ptr->usr_bit_depth, png_ptr->width)) + 1); - - return; - } - } -#endif - - /* If we get here, we've just written the last row, so we need - to flush the compressor */ - do - { - /* Tell the compressor we are done */ - ret = deflate(&png_ptr->zstream, Z_FINISH); - - /* Check for an error */ - if (ret == Z_OK) - { - /* Check to see if we need more room */ - if (!(png_ptr->zstream.avail_out)) - { - png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); - png_ptr->zstream.next_out = png_ptr->zbuf; - png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; - } - } - - else if (ret != Z_STREAM_END) - { - if (png_ptr->zstream.msg != NULL) - png_error(png_ptr, png_ptr->zstream.msg); - - else - png_error(png_ptr, "zlib error"); - } - } while (ret != Z_STREAM_END); - - /* Write any extra space */ - if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) - { - png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - - png_ptr->zstream.avail_out); - } - - png_zlib_release(png_ptr); - png_ptr->zstream.data_type = Z_BINARY; -} - -#ifdef PNG_WRITE_INTERLACING_SUPPORTED -/* Pick out the correct pixels for the interlace pass. - * The basic idea here is to go through the row with a source - * pointer and a destination pointer (sp and dp), and copy the - * correct pixels for the pass. As the row gets compacted, - * sp will always be >= dp, so we should never overwrite anything. - * See the default: case for the easiest code to understand. - */ -void /* PRIVATE */ -png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) -{ - /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ - - /* Start of interlace block */ - static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; - - /* Offset to next interlace block */ - static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; - - png_debug(1, "in png_do_write_interlace"); - - /* We don't have to do anything on the last pass (6) */ - if (pass < 6) - { - /* Each pixel depth is handled separately */ - switch (row_info->pixel_depth) - { - case 1: - { - png_bytep sp; - png_bytep dp; - int shift; - int d; - int value; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - dp = row; - d = 0; - shift = 7; - - for (i = png_pass_start[pass]; i < row_width; - i += png_pass_inc[pass]) - { - sp = row + (png_size_t)(i >> 3); - value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; - d |= (value << shift); - - if (shift == 0) - { - shift = 7; - *dp++ = (png_byte)d; - d = 0; - } - - else - shift--; - - } - if (shift != 7) - *dp = (png_byte)d; - - break; - } - - case 2: - { - png_bytep sp; - png_bytep dp; - int shift; - int d; - int value; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - dp = row; - shift = 6; - d = 0; - - for (i = png_pass_start[pass]; i < row_width; - i += png_pass_inc[pass]) - { - sp = row + (png_size_t)(i >> 2); - value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; - d |= (value << shift); - - if (shift == 0) - { - shift = 6; - *dp++ = (png_byte)d; - d = 0; - } - - else - shift -= 2; - } - if (shift != 6) - *dp = (png_byte)d; - - break; - } - - case 4: - { - png_bytep sp; - png_bytep dp; - int shift; - int d; - int value; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - - dp = row; - shift = 4; - d = 0; - for (i = png_pass_start[pass]; i < row_width; - i += png_pass_inc[pass]) - { - sp = row + (png_size_t)(i >> 1); - value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; - d |= (value << shift); - - if (shift == 0) - { - shift = 4; - *dp++ = (png_byte)d; - d = 0; - } - - else - shift -= 4; - } - if (shift != 4) - *dp = (png_byte)d; - - break; - } - - default: - { - png_bytep sp; - png_bytep dp; - png_uint_32 i; - png_uint_32 row_width = row_info->width; - png_size_t pixel_bytes; - - /* Start at the beginning */ - dp = row; - - /* Find out how many bytes each pixel takes up */ - pixel_bytes = (row_info->pixel_depth >> 3); - - /* Loop through the row, only looking at the pixels that matter */ - for (i = png_pass_start[pass]; i < row_width; - i += png_pass_inc[pass]) - { - /* Find out where the original pixel is */ - sp = row + (png_size_t)i * pixel_bytes; - - /* Move the pixel */ - if (dp != sp) - png_memcpy(dp, sp, pixel_bytes); - - /* Next pixel */ - dp += pixel_bytes; - } - break; - } - } - /* Set new row width */ - row_info->width = (row_info->width + - png_pass_inc[pass] - 1 - - png_pass_start[pass]) / - png_pass_inc[pass]; - - row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, - row_info->width); - } -} -#endif - -/* This filters the row, chooses which filter to use, if it has not already - * been specified by the application, and then writes the row out with the - * chosen filter. - */ -static void png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row, - png_size_t row_bytes); - -#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1) -#define PNG_HISHIFT 10 -#define PNG_LOMASK ((png_uint_32)0xffffL) -#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) -void /* PRIVATE */ -png_write_find_filter(png_structp png_ptr, png_row_infop row_info) -{ - png_bytep best_row; -#ifdef PNG_WRITE_FILTER_SUPPORTED - png_bytep prev_row, row_buf; - png_uint_32 mins, bpp; - png_byte filter_to_do = png_ptr->do_filter; - png_size_t row_bytes = row_info->rowbytes; -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - int num_p_filters = png_ptr->num_prev_filters; -#endif - - png_debug(1, "in png_write_find_filter"); - -#ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS) - { - /* These will never be selected so we need not test them. */ - filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH); - } -#endif - - /* Find out how many bytes offset each pixel is */ - bpp = (row_info->pixel_depth + 7) >> 3; - - prev_row = png_ptr->prev_row; -#endif - best_row = png_ptr->row_buf; -#ifdef PNG_WRITE_FILTER_SUPPORTED - row_buf = best_row; - mins = PNG_MAXSUM; - - /* The prediction method we use is to find which method provides the - * smallest value when summing the absolute values of the distances - * from zero, using anything >= 128 as negative numbers. This is known - * as the "minimum sum of absolute differences" heuristic. Other - * heuristics are the "weighted minimum sum of absolute differences" - * (experimental and can in theory improve compression), and the "zlib - * predictive" method (not implemented yet), which does test compressions - * of lines using different filter methods, and then chooses the - * (series of) filter(s) that give minimum compressed data size (VERY - * computationally expensive). - * - * GRR 980525: consider also - * - * (1) minimum sum of absolute differences from running average (i.e., - * keep running sum of non-absolute differences & count of bytes) - * [track dispersion, too? restart average if dispersion too large?] - * - * (1b) minimum sum of absolute differences from sliding average, probably - * with window size <= deflate window (usually 32K) - * - * (2) minimum sum of squared differences from zero or running average - * (i.e., ~ root-mean-square approach) - */ - - - /* We don't need to test the 'no filter' case if this is the only filter - * that has been chosen, as it doesn't actually do anything to the data. - */ - if ((filter_to_do & PNG_FILTER_NONE) && filter_to_do != PNG_FILTER_NONE) - { - png_bytep rp; - png_uint_32 sum = 0; - png_size_t i; - int v; - - for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) - { - v = *rp; - sum += (v < 128) ? v : 256 - v; - } - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - png_uint_32 sumhi, sumlo; - int j; - sumlo = sum & PNG_LOMASK; - sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */ - - /* Reduce the sum if we match any of the previous rows */ - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) - { - sumlo = (sumlo * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - sumhi = (sumhi * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - /* Factor in the cost of this filter (this is here for completeness, - * but it makes no sense to have a "cost" for the NONE filter, as - * it has the minimum possible computational cost - none). - */ - sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> - PNG_COST_SHIFT; - - sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> - PNG_COST_SHIFT; - - if (sumhi > PNG_HIMASK) - sum = PNG_MAXSUM; - - else - sum = (sumhi << PNG_HISHIFT) + sumlo; - } -#endif - mins = sum; - } - - /* Sub filter */ - if (filter_to_do == PNG_FILTER_SUB) - /* It's the only filter so no testing is needed */ - { - png_bytep rp, lp, dp; - png_size_t i; - - for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; - i++, rp++, dp++) - { - *dp = *rp; - } - - for (lp = row_buf + 1; i < row_bytes; - i++, rp++, lp++, dp++) - { - *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); - } - - best_row = png_ptr->sub_row; - } - - else if (filter_to_do & PNG_FILTER_SUB) - { - png_bytep rp, dp, lp; - png_uint_32 sum = 0, lmins = mins; - png_size_t i; - int v; - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - /* We temporarily increase the "minimum sum" by the factor we - * would reduce the sum of this filter, so that we can do the - * early exit comparison without scaling the sum each time. - */ - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 lmhi, lmlo; - lmlo = lmins & PNG_LOMASK; - lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) - { - lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> - PNG_COST_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> - PNG_COST_SHIFT; - - if (lmhi > PNG_HIMASK) - lmins = PNG_MAXSUM; - - else - lmins = (lmhi << PNG_HISHIFT) + lmlo; - } -#endif - - for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; - i++, rp++, dp++) - { - v = *dp = *rp; - - sum += (v < 128) ? v : 256 - v; - } - - for (lp = row_buf + 1; i < row_bytes; - i++, rp++, lp++, dp++) - { - v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); - - sum += (v < 128) ? v : 256 - v; - - if (sum > lmins) /* We are already worse, don't continue. */ - break; - } - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 sumhi, sumlo; - sumlo = sum & PNG_LOMASK; - sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) - { - sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> - PNG_COST_SHIFT; - - sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> - PNG_COST_SHIFT; - - if (sumhi > PNG_HIMASK) - sum = PNG_MAXSUM; - - else - sum = (sumhi << PNG_HISHIFT) + sumlo; - } -#endif - - if (sum < mins) - { - mins = sum; - best_row = png_ptr->sub_row; - } - } - - /* Up filter */ - if (filter_to_do == PNG_FILTER_UP) - { - png_bytep rp, dp, pp; - png_size_t i; - - for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, - pp = prev_row + 1; i < row_bytes; - i++, rp++, pp++, dp++) - { - *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); - } - - best_row = png_ptr->up_row; - } - - else if (filter_to_do & PNG_FILTER_UP) - { - png_bytep rp, dp, pp; - png_uint_32 sum = 0, lmins = mins; - png_size_t i; - int v; - - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 lmhi, lmlo; - lmlo = lmins & PNG_LOMASK; - lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) - { - lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> - PNG_COST_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> - PNG_COST_SHIFT; - - if (lmhi > PNG_HIMASK) - lmins = PNG_MAXSUM; - - else - lmins = (lmhi << PNG_HISHIFT) + lmlo; - } -#endif - - for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, - pp = prev_row + 1; i < row_bytes; i++) - { - v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); - - sum += (v < 128) ? v : 256 - v; - - if (sum > lmins) /* We are already worse, don't continue. */ - break; - } - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 sumhi, sumlo; - sumlo = sum & PNG_LOMASK; - sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) - { - sumlo = (sumlo * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - sumhi = (sumhi * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> - PNG_COST_SHIFT; - - sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> - PNG_COST_SHIFT; - - if (sumhi > PNG_HIMASK) - sum = PNG_MAXSUM; - - else - sum = (sumhi << PNG_HISHIFT) + sumlo; - } -#endif - - if (sum < mins) - { - mins = sum; - best_row = png_ptr->up_row; - } - } - - /* Avg filter */ - if (filter_to_do == PNG_FILTER_AVG) - { - png_bytep rp, dp, pp, lp; - png_uint_32 i; - - for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, - pp = prev_row + 1; i < bpp; i++) - { - *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); - } - - for (lp = row_buf + 1; i < row_bytes; i++) - { - *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) - & 0xff); - } - best_row = png_ptr->avg_row; - } - - else if (filter_to_do & PNG_FILTER_AVG) - { - png_bytep rp, dp, pp, lp; - png_uint_32 sum = 0, lmins = mins; - png_size_t i; - int v; - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 lmhi, lmlo; - lmlo = lmins & PNG_LOMASK; - lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG) - { - lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> - PNG_COST_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> - PNG_COST_SHIFT; - - if (lmhi > PNG_HIMASK) - lmins = PNG_MAXSUM; - - else - lmins = (lmhi << PNG_HISHIFT) + lmlo; - } -#endif - - for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, - pp = prev_row + 1; i < bpp; i++) - { - v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); - - sum += (v < 128) ? v : 256 - v; - } - - for (lp = row_buf + 1; i < row_bytes; i++) - { - v = *dp++ = - (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff); - - sum += (v < 128) ? v : 256 - v; - - if (sum > lmins) /* We are already worse, don't continue. */ - break; - } - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 sumhi, sumlo; - sumlo = sum & PNG_LOMASK; - sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) - { - sumlo = (sumlo * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - sumhi = (sumhi * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> - PNG_COST_SHIFT; - - sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> - PNG_COST_SHIFT; - - if (sumhi > PNG_HIMASK) - sum = PNG_MAXSUM; - - else - sum = (sumhi << PNG_HISHIFT) + sumlo; - } -#endif - - if (sum < mins) - { - mins = sum; - best_row = png_ptr->avg_row; - } - } - - /* Paeth filter */ - if (filter_to_do == PNG_FILTER_PAETH) - { - png_bytep rp, dp, pp, cp, lp; - png_size_t i; - - for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, - pp = prev_row + 1; i < bpp; i++) - { - *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); - } - - for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) - { - int a, b, c, pa, pb, pc, p; - - b = *pp++; - c = *cp++; - a = *lp++; - - p = b - c; - pc = a - c; - -#ifdef PNG_USE_ABS - pa = abs(p); - pb = abs(pc); - pc = abs(p + pc); -#else - pa = p < 0 ? -p : p; - pb = pc < 0 ? -pc : pc; - pc = (p + pc) < 0 ? -(p + pc) : p + pc; -#endif - - p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; - - *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); - } - best_row = png_ptr->paeth_row; - } - - else if (filter_to_do & PNG_FILTER_PAETH) - { - png_bytep rp, dp, pp, cp, lp; - png_uint_32 sum = 0, lmins = mins; - png_size_t i; - int v; - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 lmhi, lmlo; - lmlo = lmins & PNG_LOMASK; - lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) - { - lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> - PNG_COST_SHIFT; - - lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> - PNG_COST_SHIFT; - - if (lmhi > PNG_HIMASK) - lmins = PNG_MAXSUM; - - else - lmins = (lmhi << PNG_HISHIFT) + lmlo; - } -#endif - - for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, - pp = prev_row + 1; i < bpp; i++) - { - v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); - - sum += (v < 128) ? v : 256 - v; - } - - for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) - { - int a, b, c, pa, pb, pc, p; - - b = *pp++; - c = *cp++; - a = *lp++; - -#ifndef PNG_SLOW_PAETH - p = b - c; - pc = a - c; -#ifdef PNG_USE_ABS - pa = abs(p); - pb = abs(pc); - pc = abs(p + pc); -#else - pa = p < 0 ? -p : p; - pb = pc < 0 ? -pc : pc; - pc = (p + pc) < 0 ? -(p + pc) : p + pc; -#endif - p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; -#else /* PNG_SLOW_PAETH */ - p = a + b - c; - pa = abs(p - a); - pb = abs(p - b); - pc = abs(p - c); - - if (pa <= pb && pa <= pc) - p = a; - - else if (pb <= pc) - p = b; - - else - p = c; -#endif /* PNG_SLOW_PAETH */ - - v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); - - sum += (v < 128) ? v : 256 - v; - - if (sum > lmins) /* We are already worse, don't continue. */ - break; - } - -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) - { - int j; - png_uint_32 sumhi, sumlo; - sumlo = sum & PNG_LOMASK; - sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; - - for (j = 0; j < num_p_filters; j++) - { - if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) - { - sumlo = (sumlo * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - - sumhi = (sumhi * png_ptr->filter_weights[j]) >> - PNG_WEIGHT_SHIFT; - } - } - - sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> - PNG_COST_SHIFT; - - sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> - PNG_COST_SHIFT; - - if (sumhi > PNG_HIMASK) - sum = PNG_MAXSUM; - - else - sum = (sumhi << PNG_HISHIFT) + sumlo; - } -#endif - - if (sum < mins) - { - best_row = png_ptr->paeth_row; - } - } -#endif /* PNG_WRITE_FILTER_SUPPORTED */ - - /* Do the actual writing of the filtered row data from the chosen filter. */ - png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1); - -#ifdef PNG_WRITE_FILTER_SUPPORTED -#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED - /* Save the type of filter we picked this time for future calculations */ - if (png_ptr->num_prev_filters > 0) - { - int j; - - for (j = 1; j < num_p_filters; j++) - { - png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1]; - } - - png_ptr->prev_filters[j] = best_row[0]; - } -#endif -#endif /* PNG_WRITE_FILTER_SUPPORTED */ -} - - -/* Do the actual writing of a previously filtered row. */ -static void -png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row, - png_size_t avail/*includes filter byte*/) -{ - png_debug(1, "in png_write_filtered_row"); - - png_debug1(2, "filter = %d", filtered_row[0]); - /* Set up the zlib input buffer */ - - png_ptr->zstream.next_in = filtered_row; - png_ptr->zstream.avail_in = 0; - /* Repeat until we have compressed all the data */ - do - { - int ret; /* Return of zlib */ - - /* Record the number of bytes available - zlib supports at least 65535 - * bytes at one step, depending on the size of the zlib type 'uInt', the - * maximum size zlib can write at once is ZLIB_IO_MAX (from pngpriv.h). - * Use this because on 16 bit systems 'rowbytes' can be up to 65536 (i.e. - * one more than 16 bits) and, in this case 'rowbytes+1' can overflow a - * uInt. ZLIB_IO_MAX can be safely reduced to cause zlib to be called - * with smaller chunks of data. - */ - if (png_ptr->zstream.avail_in == 0) - { - if (avail > ZLIB_IO_MAX) - { - png_ptr->zstream.avail_in = ZLIB_IO_MAX; - avail -= ZLIB_IO_MAX; - } - - else - { - /* So this will fit in the available uInt space: */ - png_ptr->zstream.avail_in = (uInt)avail; - avail = 0; - } - } - - /* Compress the data */ - ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); - - /* Check for compression errors */ - if (ret != Z_OK) - { - if (png_ptr->zstream.msg != NULL) - png_error(png_ptr, png_ptr->zstream.msg); - - else - png_error(png_ptr, "zlib error"); - } - - /* See if it is time to write another IDAT */ - if (!(png_ptr->zstream.avail_out)) - { - /* Write the IDAT and reset the zlib output buffer */ - png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); - } - /* Repeat until all data has been compressed */ - } while (avail > 0 || png_ptr->zstream.avail_in > 0); - - /* Swap the current and previous rows */ - if (png_ptr->prev_row != NULL) - { - png_bytep tptr; - - tptr = png_ptr->prev_row; - png_ptr->prev_row = png_ptr->row_buf; - png_ptr->row_buf = tptr; - } - - /* Finish row - updates counters and flushes zlib if last row */ - png_write_finish_row(png_ptr); - -#ifdef PNG_WRITE_FLUSH_SUPPORTED - png_ptr->flush_rows++; - - if (png_ptr->flush_dist > 0 && - png_ptr->flush_rows >= png_ptr->flush_dist) - { - png_write_flush(png_ptr); - } -#endif -} -#endif /* PNG_WRITE_SUPPORTED */ diff --git a/source/libsxmlc/LICENSE b/source/libsxmlc/LICENSE deleted file mode 100644 index dfbe3dd..0000000 --- a/source/libsxmlc/LICENSE +++ /dev/null @@ -1,23 +0,0 @@ -Copyright (c) 2014, matthieu-labas -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/source/libsxmlc/sxmlc.c b/source/libsxmlc/sxmlc.c deleted file mode 100755 index 1963be9..0000000 --- a/source/libsxmlc/sxmlc.c +++ /dev/null @@ -1,2458 +0,0 @@ -/* - Copyright (c) 2010, Matthieu Labas - All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY - OF SUCH DAMAGE. - - The views and conclusions contained in the software and documentation are those of the - authors and should not be interpreted as representing official policies, either expressed - or implied, of the FreeBSD Project. -*/ -#if defined(WIN32) || defined(WIN64) -#pragma warning(disable : 4996) -#else -#ifndef strdup -#define _GNU_SOURCE -#endif -#endif - -#include -#include -#include -#include -#include "sxmlc.h" - -#define CHECK_NODE(node,ret) if (!XMLNode_is_valid(node)) return (ret) - -/* - Struct defining "special" tags such as "" or "". - These tags are considered having a start and an end with some data in between that will - be stored in the 'tag' member of an XMLNode. - The 'tag_type' member is a constant that is associated to such tag. - All 'len_*' members are basically the "sx_strlen()" of 'start' and 'end' members. - */ -typedef struct _Tag { - TagType tag_type; - SXML_CHAR* start; - int len_start; - SXML_CHAR* end; - int len_end; -} _TAG; - -typedef struct _SpecialTag { - _TAG *tags; - int n_tags; -} SPECIAL_TAG; - -/* - List of "special" tags handled by sxmlc. - NB the "' or ']>'). - */ -static _TAG _spec[] = { - { TAG_INSTR, C2SX(""), 2 }, - { TAG_COMMENT, C2SX(""), 3 }, - { TAG_CDATA, C2SX(""), 3 } -}; -static int NB_SPECIAL_TAGS = (int)(sizeof(_spec) / sizeof(_TAG)); /* Auto computation of number of special tags */ - -/* - User-registered tags. - */ -static SPECIAL_TAG _user_tags = { NULL, 0 }; - -int XML_register_user_tag(TagType tag_type, SXML_CHAR* start, SXML_CHAR* end) -{ - _TAG* p; - int i, n, le; - - if (tag_type < TAG_USER) - return -1; - - if (start == NULL || end == NULL || *start != C2SX('<')) - return -1; - - le = sx_strlen(end); - if (end[le-1] != C2SX('>')) - return -1; - - i = _user_tags.n_tags; - n = i + 1; - p = __realloc(_user_tags.tags, n * sizeof(_TAG)); - if (p == NULL) - return -1; - - p[i].tag_type = tag_type; - p[i].start = start; - p[i].end = end; - p[i].len_start = sx_strlen(start); - p[i].len_end = le; - _user_tags.tags = p; - _user_tags.n_tags = n; - - return i; -} - -int XML_unregister_user_tag(int i_tag) -{ - _TAG* pt; - - if (i_tag < 0 || i_tag >= _user_tags.n_tags) - return -1; - - if (_user_tags.n_tags == 1) - pt = NULL; - else { - pt = __malloc((_user_tags.n_tags - 1) * sizeof(_TAG)); - if (pt == NULL) - return -1; - } - - if (pt != NULL) { - memcpy(pt, _user_tags.tags, i_tag * sizeof(_TAG)); - memcpy(&pt[i_tag], &_user_tags.tags[i_tag + 1], (_user_tags.n_tags - i_tag - 1) * sizeof(_TAG)); - } - if (_user_tags.tags != NULL) - __free(_user_tags.tags); - _user_tags.tags = pt; - _user_tags.n_tags--; - - return _user_tags.n_tags; -} - -int XML_get_nb_registered_user_tags(void) -{ - return _user_tags.n_tags; -} - -int XML_get_registered_user_tag(TagType tag_type) -{ - int i; - - for (i = 0; i < _user_tags.n_tags; i++) - if (_user_tags.tags[i].tag_type == tag_type) - return i; - - return -1; -} - -/* --- XMLNode methods --- */ - -/* - Add 'node' to given '*children_array' of '*len_array' elements. - '*len_array' is overwritten with the number of elements in '*children_array' after its reallocation. - Return the index of the newly added 'node' in '*children_array', or '-1' for memory error. - */ -static int _add_node(XMLNode*** children_array, int* len_array, XMLNode* node) -{ - XMLNode** pt = __realloc(*children_array, (*len_array+1) * sizeof(XMLNode*)); - - if (pt == NULL) - return -1; - - pt[*len_array] = node; - *children_array = pt; - - return (*len_array)++; -} - -int XMLNode_init(XMLNode* node) -{ - if (node == NULL) - return false; - - if (node->init_value == XML_INIT_DONE) - return true; /*(void)XMLNode_free(node);*/ - - node->tag = NULL; - node->text = NULL; - - node->attributes = NULL; - node->n_attributes = 0; - - node->father = NULL; - node->children = NULL; - node->n_children = 0; - - node->tag_type = TAG_NONE; - node->active = true; - - node->init_value = XML_INIT_DONE; - - return true; -} - -XMLNode* XMLNode_allocN(int n) -{ - int i; - XMLNode* p; - - if (n <= 0) - return NULL; - - p = __calloc(n, sizeof(XMLNode)); - if (p == NULL) - return NULL; - - for (i = 0; i < n; i++) - (void)XMLNode_init(&p[i]); - - return p; -} - -XMLNode* XMLNode_new(const TagType tag_type, const char* tag, const char* text) -{ - XMLNode* node = XMLNode_alloc(); - if (node == NULL) - return NULL; - - if (!XMLNode_set_tag(node, tag) || (text != NULL && !XMLNode_set_text(node, text))) { - __free(node); - return NULL; - } - - node->tag_type = tag_type; - - return node; -} - -XMLNode* XMLNode_dup(const XMLNode* node, int copy_children) -{ - XMLNode* n; - - if (node == NULL) - return NULL; - - n = __calloc(1, sizeof(XMLNode)); - if (n == NULL) - return NULL; - - XMLNode_init(n); - if (!XMLNode_copy(n, node, copy_children)) { - XMLNode_free(n); - - return NULL; - } - - return n; -} - -int XMLNode_free(XMLNode* node) -{ - CHECK_NODE(node, false); - - if (node->tag != NULL) { - __free(node->tag); - node->tag = NULL; - } - - XMLNode_remove_text(node); - XMLNode_remove_all_attributes(node); - XMLNode_remove_children(node); - - node->tag_type = TAG_NONE; - - return true; -} - -int XMLNode_copy(XMLNode* dst, const XMLNode* src, int copy_children) -{ - int i; - - if (dst == NULL || (src != NULL && src->init_value != XML_INIT_DONE)) - return false; - - (void)XMLNode_free(dst); /* 'dst' is freed first */ - - /* NULL 'src' resets 'dst' */ - if (src == NULL) - return true; - - /* Tag */ - if (src->tag != NULL) { - dst->tag = sx_strdup(src->tag); - if (dst->tag == NULL) goto copy_err; - } - - /* Text */ - if (dst->text != NULL) { - dst->text = sx_strdup(src->text); - if (dst->text == NULL) goto copy_err; - } - - /* Attributes */ - if (src->n_attributes > 0) { - dst->attributes = __calloc(src->n_attributes, sizeof(XMLAttribute)); - if (dst->attributes== NULL) goto copy_err; - dst->n_attributes = src->n_attributes; - for (i = 0; i < src->n_attributes; i++) { - dst->attributes[i].name = sx_strdup(src->attributes[i].name); - dst->attributes[i].value = sx_strdup(src->attributes[i].value); - if (dst->attributes[i].name == NULL || dst->attributes[i].value == NULL) goto copy_err; - dst->attributes[i].active = src->attributes[i].active; - } - } - - dst->tag_type = src->tag_type; - dst->father = src->father; - dst->user = src->user; - dst->active = src->active; - - /* Copy children if required (and there are any) */ - if (copy_children && src->n_children > 0) { - dst->children = __calloc(src->n_children, sizeof(XMLNode*)); - if (dst->children == NULL) goto copy_err; - dst->n_children = src->n_children; - for (i = 0; i < src->n_children; i++) { - if (!XMLNode_copy(dst->children[i], src->children[i], true)) goto copy_err; - } - } - - return true; - -copy_err: - (void)XMLNode_free(dst); - - return false; -} - -int XMLNode_set_active(XMLNode* node, int active) -{ - CHECK_NODE(node, false); - - node->active = active; - - return true; -} - -int XMLNode_set_tag(XMLNode* node, const SXML_CHAR* tag) -{ - SXML_CHAR* newtag; - if (node == NULL || tag == NULL || node->init_value != XML_INIT_DONE) - return false; - - newtag = sx_strdup(tag); - if (newtag == NULL) - return false; - if (node->tag != NULL) __free(node->tag); - node->tag = newtag; - - return true; -} - -int XMLNode_set_type(XMLNode* node, const TagType tag_type) -{ - CHECK_NODE(node, false); - - switch (tag_type) { - case TAG_ERROR: - case TAG_END: - case TAG_PARTIAL: - case TAG_NONE: - return false; - - default: - node->tag_type = tag_type; - return true; - } -} - -int XMLNode_set_attribute(XMLNode* node, const SXML_CHAR* attr_name, const SXML_CHAR* attr_value) -{ - XMLAttribute* pt; - int i; - - if (node == NULL || attr_name == NULL || attr_name[0] == NULC || node->init_value != XML_INIT_DONE) - return -1; - - i = XMLNode_search_attribute(node, attr_name, 0); - if (i >= 0) { /* Attribute found: update it */ - SXML_CHAR* value = NULL; - if (attr_value != NULL && (value = sx_strdup(attr_value)) == NULL) - return -1; - pt = node->attributes; - if (pt[i].value != NULL) - __free(pt[i].value); - pt[i].value = value; - } else { /* Attribute not found: add it */ - SXML_CHAR* name = sx_strdup(attr_name); - SXML_CHAR* value = (attr_value == NULL ? NULL : sx_strdup(attr_value)); - if (name == NULL || (value == NULL && attr_value != NULL)) { - if (value != NULL) - __free(value); - if (name != NULL) - __free(name); - return -1; - } - i = node->n_attributes; - pt = __realloc(node->attributes, (i+1) * sizeof(XMLAttribute)); - if (pt == NULL) { - if (value != NULL) - __free(value); - __free(name); - return -1; - } - - pt[i].name = name; - pt[i].value = value; - pt[i].active = true; - node->attributes = pt; - node->n_attributes = i + 1; - } - - return node->n_attributes; -} - -int XMLNode_get_attribute_with_default(XMLNode* node, const SXML_CHAR* attr_name, const SXML_CHAR** attr_value, const SXML_CHAR* default_attr_value) -{ - XMLAttribute* pt; - int i; - - if (node == NULL || attr_name == NULL || attr_name[0] == NULC || attr_value == NULL || node->init_value != XML_INIT_DONE) - return false; - - i = XMLNode_search_attribute(node, attr_name, 0); - if (i >= 0) - { - pt = node->attributes; - if (pt[i].value != NULL) - { - //printf("%s\n",pt[i].value); - *attr_value = sx_strdup(pt[i].value); - //printf("%s\n",*attr_value); - - if (*attr_value == NULL) - return false; - } - else - { - *attr_value = NULL; /* NULL but returns 'true' as 'NULL' is the actual attribute value */ - } - } - else - { - if (default_attr_value != NULL) - { - *attr_value = sx_strdup(default_attr_value); - if (*attr_value == NULL) - return false; - } - else - { - *attr_value = NULL; - } - } - return true; -} - -int XMLNode_get_attribute_count(const XMLNode* node) -{ - int i, n; - - CHECK_NODE(node, -1); - - for (i = n = 0; i < node->n_attributes; i++) - if (node->attributes[i].active) n++; - - return n; -} - -int XMLNode_search_attribute(const XMLNode* node, const SXML_CHAR* attr_name, int i_search) -{ - int i; - - if (node == NULL || attr_name == NULL || attr_name[0] == NULC || i_search < 0 || i_search >= node->n_attributes) - return -1; - - for (i = i_search; i < node->n_attributes; i++) - if (node->attributes[i].active && !sx_strcmp(node->attributes[i].name, attr_name)) - return i; - - return -1; -} - -int XMLNode_remove_attribute(XMLNode* node, int i_attr) -{ - XMLAttribute* pt; - if (node == NULL || node->init_value != XML_INIT_DONE || i_attr < 0 || i_attr >= node->n_attributes) - return -1; - - /* Before modifying first see if we run out of memory */ - if (node->n_attributes == 1) - pt = NULL; - else { - pt = __malloc((node->n_attributes - 1) * sizeof(XMLAttribute)); - if (pt == NULL) - return -1; - } - - /* Can't fail anymore, free item */ - if (node->attributes[i_attr].name != NULL) __free(node->attributes[i_attr].name); - if (node->attributes[i_attr].value != NULL) __free(node->attributes[i_attr].value); - - if (pt != NULL) { - memcpy(pt, node->attributes, i_attr * sizeof(XMLAttribute)); - memcpy(&pt[i_attr], &node->attributes[i_attr + 1], (node->n_attributes - i_attr - 1) * sizeof(XMLAttribute)); - } - if (node->attributes != NULL) - __free(node->attributes); - node->attributes = pt; - node->n_attributes--; - - return node->n_attributes; -} - -int XMLNode_remove_all_attributes(XMLNode* node) -{ - int i; - - CHECK_NODE(node, false); - - if (node->attributes != NULL) { - for (i = 0; i < node->n_attributes; i++) { - if (node->attributes[i].name != NULL) - __free(node->attributes[i].name); - if (node->attributes[i].value != NULL) - __free(node->attributes[i].value); - } - __free(node->attributes); - node->attributes = NULL; - } - node->n_attributes = 0; - - return true; -} - -int XMLNode_set_text(XMLNode* node, const SXML_CHAR* text) -{ - SXML_CHAR* p; - CHECK_NODE(node, false); - - if (text == NULL) { /* We want to remove it => free node text */ - if (node->text != NULL) { - __free(node->text); - node->text = NULL; - } - - return true; - } - - p = sx_strdup(text); - if (p == NULL) - return false; - node->text = p; - - return true; -} - -int XMLNode_add_child(XMLNode* node, XMLNode* child) -{ - if (node == NULL || child == NULL || node->init_value != XML_INIT_DONE || child->init_value != XML_INIT_DONE) - return false; - - if (_add_node(&node->children, &node->n_children, child) >= 0) { - node->tag_type = TAG_FATHER; - child->father = node; - return true; - } else - return false; -} - -int XMLNode_insert_child(XMLNode* node, XMLNode* child, int index) -{ - int i, j; - - CHECK_NODE(node, -1); - - /* We could process cases "first" and "last" in an optimized way, but we prefer readability to (micro-)optimization */ - if (index < 0) /* Before first => first */ - index = 0; - if (index >= node->n_children) /* After last => last */ - index = node->n_children - 1; - - for (i = 0; i < node->n_children; i++) { - if (!node->children[i]->active || index-- > 0) - continue; - /* Insert it here, at 'i' */ - if (_add_node(&node->children, &node->n_children, child) >= 0) { - node->tag_type = TAG_FATHER; - child->father = node; - /* Erase 'child', which is the last node ('n_children' has been incremented by '_add_node()') */ - for (j = node->n_children - 1; j >= i; j--) - node->children[j] = node->children[j-1]; - node->children[i] = child; /* Set it */ - return true; - } else - return false; - } - - return false; /* Oops! */ -} - -int XMLNode_move_child(XMLNode* node, int from, int to) -{ - XMLNode* nfrom; - - CHECK_NODE(node, false); - if (from < 0 || from >= node->n_children) - return false; - if (to < 0) /* Before first => first */ - to = 0; - if (to >= node->n_children) /* After last => last */ - to = node->n_children - 1; - - nfrom = node->children[from]; - if (to > from) { /* Move forward: bring following nodes (up to 'to') backward one position */ - int i; - for (i = from; i < to; i++) - node->children[i] = node->children[i+1]; - } else { /* Move backward: bring previous nodes (up to 'from') forward one position */ - int i; - for (i = from - 1; i >= to; i--) - node->children[i+1] = node->children[i]; - } - node->children[to] = nfrom; - - return true; -} - - -int XMLNode_get_children_count(const XMLNode* node) -{ - int i, n; - - CHECK_NODE(node, -1); - - for (i = n = 0; i < node->n_children; i++) - if (node->children[i]->active) - n++; - - return n; -} - -int XMLNode_get_index(const XMLNode* node) -{ - int i, i_child; - - CHECK_NODE(node, -1); - - if (node->father == NULL) - return 0; - - for (i = i_child = 0; i < node->father->n_children; i++) { - if (!node->father->children[i]->active) - continue; - if (node->father->children[i] == node) - return i_child; - i_child++; - } - - return -2; /* Oops! */ -} - -XMLNode* XMLNode_get_child(const XMLNode* node, int i_child) -{ - int i; - - if (node == NULL || node->init_value != XML_INIT_DONE || i_child < 0 || i_child >= node->n_children) - return NULL; - - for (i = 0; i < node->n_children; i++) { - if (!node->children[i]->active) - i_child++; - else if (i == i_child) - return node->children[i]; - } - - return NULL; -} - -int XMLNode_remove_child(XMLNode* node, int i_child, int free_child) -{ - int i; - XMLNode** pt; - - if (node == NULL || node->init_value != XML_INIT_DONE || i_child < 0 || i_child >= node->n_children) - return -1; - - /* Lookup 'i_child'th active child */ - for (i = 0; i < node->n_children; i++) { - if (!node->children[i]->active) - i_child++; - else if (i == i_child) - break; - } - if (i >= node->n_children) - return -1; /* Children is not found */ - - /* Before modifying first see if we run out of memory */ - if (node->n_children == 1) { - pt = NULL; - } else { - pt = __malloc((node->n_children - 1) * sizeof(XMLNode*)); - if (pt == NULL) - return -1; - } - - /* Can't fail anymore, free item */ - (void)XMLNode_free(node->children[i_child]); - if (free_child) - __free(node->children[i_child]); - - if (pt != NULL) { - memcpy(pt, node->children, i_child * sizeof(XMLNode*)); - memcpy(&pt[i_child], &node->children[i_child + 1], (node->n_children - i_child - 1) * sizeof(XMLNode*)); - } - if (node->children != NULL) - __free(node->children); - node->children = pt; - node->n_children--; - if (node->n_children == 0) - node->tag_type = TAG_SELF; - - return node->n_children; -} - -int XMLNode_remove_children(XMLNode* node) -{ - int i; - - CHECK_NODE(node, false); - - if (node->children != NULL) { - for (i = 0; i < node->n_children; i++) - if (node->children[i] != NULL) { - (void)XMLNode_free(node->children[i]); - __free(node->children[i]); - } - __free(node->children); - node->children = NULL; - } - node->n_children = 0; - - return true; -} - -int XMLNode_equal(const XMLNode* node1, const XMLNode* node2) -{ - int i, j; - - if (node1 == node2) - return true; - - if (node1 == NULL || node2 == NULL || node1->init_value != XML_INIT_DONE || node2->init_value != XML_INIT_DONE) - return false; - - if (sx_strcmp(node1->tag, node2->tag)) - return false; - - /* Test all attributes from 'node1' */ - for (i = 0; i < node1->n_attributes; i++) { - if (!node1->attributes[i].active) - continue; - j = XMLNode_search_attribute(node2, node1->attributes[i].name, 0); - if (j < 0) - return false; - if (sx_strcmp(node1->attributes[i].value, node2->attributes[j].value)) - return false; - } - - /* Test other attributes from 'node2' that might not be in 'node1' */ - for (i = 0; i < node2->n_attributes; i++) { - if (!node2->attributes[i].active) - continue; - j = XMLNode_search_attribute(node1, node2->attributes[i].name, 0); - if (j < 0) - return false; - if (sx_strcmp(node2->attributes[i].name, node1->attributes[j].name)) - return false; - } - - return true; -} - -XMLNode* XMLNode_next_sibling(const XMLNode* node) -{ - int i; - XMLNode* father; - - if (node == NULL || node->init_value != XML_INIT_DONE || node->father == NULL) - return NULL; - - father = node->father; - for (i = 0; i < father->n_children && father->children[i] != node; i++) ; - i++; /* father->children[i] is now 'node' next sibling */ - - return i < father->n_children ? father->children[i] : NULL; -} - -static XMLNode* _XMLNode_next(const XMLNode* node, int in_children) -{ - XMLNode* node2; - - CHECK_NODE(node, NULL); - - /* Check first child */ - if (in_children && node->n_children > 0) - return node->children[0]; - - /* Check next sibling */ - if ((node2 = XMLNode_next_sibling(node)) != NULL) - return node2; - - /* Check next uncle */ - return _XMLNode_next(node->father, false); -} - -XMLNode* XMLNode_next(const XMLNode* node) -{ - return _XMLNode_next(node, true); -} - -/* --- XMLDoc methods --- */ - -int XMLDoc_init(XMLDoc* doc) -{ - if (doc == NULL) - return false; - - doc->filename[0] = NULC; -#ifdef SXMLC_UNICODE - memset(&doc->bom, 0, sizeof(doc->bom)); -#endif - doc->nodes = NULL; - doc->n_nodes = 0; - doc->i_root = -1; - doc->init_value = XML_INIT_DONE; - - return true; -} - -int XMLDoc_free(XMLDoc* doc) -{ - int i; - - if (doc == NULL || doc->init_value != XML_INIT_DONE) - return false; - - for (i = 0; i < doc->n_nodes; i++) { - (void)XMLNode_free(doc->nodes[i]); - __free(doc->nodes[i]); - } - __free(doc->nodes); - doc->nodes = NULL; - doc->n_nodes = 0; - doc->i_root = -1; - - return true; -} - -int XMLDoc_set_root(XMLDoc* doc, int i_root) -{ - if (doc == NULL || doc->init_value != XML_INIT_DONE || i_root < 0 || i_root >= doc->n_nodes) - return false; - - doc->i_root = i_root; - - return true; -} - -int XMLDoc_add_node(XMLDoc* doc, XMLNode* node) -{ - if (doc == NULL || node == NULL || doc->init_value != XML_INIT_DONE) - return -1; - - if (_add_node(&doc->nodes, &doc->n_nodes, node) < 0) - return -1; - - if (node->tag_type == TAG_FATHER) - doc->i_root = doc->n_nodes - 1; /* Main root node is the last father node */ - - return doc->n_nodes; -} - -int XMLDoc_remove_node(XMLDoc* doc, int i_node, int free_node) -{ - XMLNode** pt; - if (doc == NULL || doc->init_value != XML_INIT_DONE || i_node < 0 || i_node > doc->n_nodes) - return false; - - /* Before modifying first see if we run out of memory */ - if (doc->n_nodes == 1) - pt = NULL; - else { - pt = __malloc((doc->n_nodes - 1) * sizeof(XMLNode*)); - if (pt == NULL) - return false; - } - - /* Can't fail anymore, free item */ - (void)XMLNode_free(doc->nodes[i_node]); - if (free_node) __free(doc->nodes[i_node]); - - if (pt != NULL) { - memcpy(pt, &doc->nodes[i_node], i_node * sizeof(XMLNode*)); - memcpy(&pt[i_node], &doc->nodes[i_node + 1], (doc->n_nodes - i_node - 1) * sizeof(XMLNode*)); - } - - if (doc->nodes != NULL) - __free(doc->nodes); - doc->nodes = pt; - doc->n_nodes--; - - return true; -} - -/* - Helper functions to print formatting before a new tag. - Returns the new number of characters in the line. - */ -static int _count_new_char_line(const SXML_CHAR* str, int nb_char_tab, int cur_sz_line) -{ - for (; *str; str++) { - if (*str == C2SX('\n')) - cur_sz_line = 0; - else if (*str == C2SX('\t')) - cur_sz_line += nb_char_tab; - else - cur_sz_line++; - } - - return cur_sz_line; -} -static int _print_formatting(const XMLNode* node, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, int nb_char_tab, int cur_sz_line) -{ - if (tag_sep != NULL) { - sx_fputs(tag_sep, f); - cur_sz_line = _count_new_char_line(tag_sep, nb_char_tab, cur_sz_line); - } - if (child_sep != NULL) { - for (node = node->father; node != NULL; node = node->father) { - sx_fputs(child_sep, f); - cur_sz_line = _count_new_char_line(child_sep, nb_char_tab, cur_sz_line); - } - } - - return cur_sz_line; -} - -static int _XMLNode_print_header(const XMLNode* node, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, const SXML_CHAR* attr_sep, int sz_line, int cur_sz_line, int nb_char_tab) -{ - int i; - SXML_CHAR* p; - - if (node == NULL || f == NULL || !node->active || node->tag == NULL || node->tag[0] == NULC) - return -1; - - /* Special handling of DOCTYPE */ - if (node->tag_type == TAG_DOCTYPE) { - /* Search for an unescaped '[' in the DOCTYPE definition, in which case the end delimiter should be ']>' instead of '>' */ - for (p = sx_strchr(node->tag, C2SX('[')); p != NULL && *(p-1) == C2SX('\\'); p = sx_strchr(p+1, C2SX('['))) ; - cur_sz_line += sx_fprintf(f, C2SX(""), node->tag, p != NULL ? C2SX("]") : C2SX("")); - return cur_sz_line; - } - - /* Check for special tags first */ - for (i = 0; i < NB_SPECIAL_TAGS; i++) { - if (node->tag_type == _spec[i].tag_type) { - sx_fprintf(f, C2SX("%s%s%s"), _spec[i].start, node->tag, _spec[i].end); - cur_sz_line += sx_strlen(_spec[i].start) + sx_strlen(node->tag) + sx_strlen(_spec[i].end); - return cur_sz_line; - } - } - - /* Check for user tags */ - for (i = 0; i < _user_tags.n_tags; i++) { - if (node->tag_type == _user_tags.tags[i].tag_type) { - sx_fprintf(f, C2SX("%s%s%s"), _user_tags.tags[i].start, node->tag, _user_tags.tags[i].end); - cur_sz_line += sx_strlen(_user_tags.tags[i].start) + sx_strlen(node->tag) + sx_strlen(_user_tags.tags[i].end); - return cur_sz_line; - } - } - - /* Print tag name */ - cur_sz_line += sx_fprintf(f, C2SX("<%s"), node->tag); - - /* Print attributes */ - if (attr_sep == NULL) - attr_sep = C2SX(" "); - for (i = 0; i < node->n_attributes; i++) { - if (!node->attributes[i].active) - continue; - cur_sz_line += sx_strlen(node->attributes[i].name) + sx_strlen(node->attributes[i].value) + 3; - if (sz_line > 0 && cur_sz_line > sz_line) { - cur_sz_line = _print_formatting(node, f, tag_sep, child_sep, nb_char_tab, cur_sz_line); - /* Add extra separator, as if new line was a child of the previous one */ - if (child_sep != NULL) { - sx_fputs(child_sep, f); - cur_sz_line = _count_new_char_line(child_sep, nb_char_tab, cur_sz_line); - } - } - /* Attribute name */ - cur_sz_line = _count_new_char_line(attr_sep, nb_char_tab, cur_sz_line); - sx_fprintf(f, C2SX("%s%s="), attr_sep, node->attributes[i].name); - - /* Attribute value */ - (void)sx_fputc(XML_DEFAULT_QUOTE, f); - cur_sz_line += fprintHTML(f, node->attributes[i].value) + 2; - (void)sx_fputc(XML_DEFAULT_QUOTE, f); - } - - /* End the tag if there are no children and no text */ - if (node->n_children == 0 && (node->text == NULL || node->text[0] == NULC)) { - cur_sz_line += sx_fprintf(f, C2SX("/>")); - } else { - (void)sx_fputc(C2SX('>'), f); - cur_sz_line++; - } - - return cur_sz_line; -} - -int XMLNode_print_header(const XMLNode* node, FILE* f, int sz_line, int nb_char_tab) -{ - return _XMLNode_print_header(node, f, NULL, NULL, NULL, sz_line, 0, nb_char_tab) < 0 ? false : true; -} - -static int _XMLNode_print(const XMLNode* node, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, const SXML_CHAR* attr_sep, int keep_text_spaces, int sz_line, int cur_sz_line, int nb_char_tab, int depth) -{ - int i; - SXML_CHAR* p; - - if (node != NULL && node->tag_type==TAG_TEXT) { /* Text has to be printed: check if it is only spaces */ - if (!keep_text_spaces) { - for (p = node->text; *p != NULC && sx_isspace(*p); p++) ; /* 'p' points to first non-space character, or to '\0' if only spaces */ - } else - p = node->text; /* '*p' won't be '\0' */ - if (*p != NULC) - cur_sz_line += fprintHTML(f, node->text); - return cur_sz_line; - } - - if (node == NULL || f == NULL || !node->active || node->tag == NULL || node->tag[0] == NULC) - return -1; - - if (nb_char_tab <= 0) - nb_char_tab = 1; - - /* Print formatting */ - if (depth < 0) /* UGLY HACK: 'depth' forced negative on very first line so we don't print an extra 'tag_sep' (usually "\n" when pretty-printing) */ - depth = 0; - else - cur_sz_line = _print_formatting(node, f, tag_sep, child_sep, nb_char_tab, cur_sz_line); - - _XMLNode_print_header(node, f, tag_sep, child_sep, attr_sep, sz_line, cur_sz_line, nb_char_tab); - - if (node->text != NULL && node->text[0] != NULC) { - /* Text has to be printed: check if it is only spaces */ - if (!keep_text_spaces) { - for (p = node->text; *p != NULC && sx_isspace(*p); p++) ; /* 'p' points to first non-space character, or to '\0' if only spaces */ - } else - p = node->text; /* '*p' won't be '\0' */ - if (*p != NULC) cur_sz_line += fprintHTML(f, node->text); - } else if (node->n_children <= 0) /* Everything has already been printed */ - return cur_sz_line; - - /* Recursively print children */ - for (i = 0; i < node->n_children; i++) - (void)_XMLNode_print(node->children[i], f, tag_sep, child_sep, attr_sep, keep_text_spaces, sz_line, cur_sz_line, nb_char_tab, depth+1); - - /* Print tag end after children */ - /* Print formatting */ - if (node->n_children > 0) - cur_sz_line = _print_formatting(node, f, tag_sep, child_sep, nb_char_tab, cur_sz_line); - cur_sz_line += sx_fprintf(f, C2SX(""), node->tag); - - return cur_sz_line; -} - -int XMLNode_print_attr_sep(const XMLNode* node, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, const SXML_CHAR* attr_sep, int keep_text_spaces, int sz_line, int nb_char_tab) -{ - return _XMLNode_print(node, f, tag_sep, child_sep, attr_sep, keep_text_spaces, sz_line, 0, nb_char_tab, 0); -} - -int XMLDoc_print_attr_sep(const XMLDoc* doc, FILE* f, const SXML_CHAR* tag_sep, const SXML_CHAR* child_sep, const SXML_CHAR* attr_sep, int keep_text_spaces, int sz_line, int nb_char_tab) -{ - int i, depth, cur_sz_line; - - if (doc == NULL || f == NULL || doc->init_value != XML_INIT_DONE) - return false; - -#ifdef SXMLC_UNICODE - /* Write BOM if it exist */ - if (doc->sz_bom > 0) fwrite(doc->bom, sizeof(unsigned char), doc->sz_bom, f); -#endif - - depth = -1; /* UGLY HACK: 'depth' forced negative on very first line so we don't print an extra 'tag_sep' (usually "\n") */ - for (i = 0, cur_sz_line = 0; i < doc->n_nodes; i++) { - cur_sz_line = _XMLNode_print(doc->nodes[i], f, tag_sep, child_sep, attr_sep, keep_text_spaces, sz_line, cur_sz_line, nb_char_tab, depth); - depth = 0; - } - /* TODO: Find something more graceful than 'depth=-1', even though everyone knows I probably never will ;) */ - - return true; -} - -/* --- */ - -int XML_parse_attribute_to(const SXML_CHAR* str, int to, XMLAttribute* xmlattr) -{ - const SXML_CHAR *p; - int i, n0, n1, remQ = 0; - int ret = 1; - SXML_CHAR quote = '\0'; - - if (str == NULL || xmlattr == NULL) - return 0; - - if (to < 0) - to = sx_strlen(str) - 1; - - /* Search for the '=' */ - /* 'n0' is where the attribute name stops, 'n1' is where the attribute value starts */ - for (n0 = 0; n0 != to && str[n0] != C2SX('=') && !sx_isspace(str[n0]); n0++) ; /* Search for '=' or a space */ - for (n1 = n0; n1 != to && sx_isspace(str[n1]); n1++) ; /* Search for something not a space */ - if (str[n1] != C2SX('=')) - return 0; /* '=' not found: malformed string */ - for (n1++; n1 != to && sx_isspace(str[n1]); n1++) ; /* Search for something not a space */ - if (isquote(str[n1])) { /* Remove quotes */ - quote = str[n1]; - remQ = 1; - } - - xmlattr->name = __malloc((n0+1)*sizeof(SXML_CHAR)); - xmlattr->value = __malloc((to+1 - n1 - remQ + 1) * sizeof(SXML_CHAR)); - xmlattr->active = true; - if (xmlattr->name != NULL && xmlattr->value != NULL) { - /* Copy name */ - sx_strncpy(xmlattr->name, str, n0); - xmlattr->name[n0] = NULC; - /* (void)str_unescape(xmlattr->name); do not unescape the name */ - /* Copy value (p starts after the quote (if any) and stops at the end of 'str' - (skipping the quote if any, hence the '*(p+remQ)') */ - for (i = 0, p = str + n1 + remQ; i + n1 + remQ < to && *(p+remQ) != NULC; i++, p++) - xmlattr->value[i] = *p; - xmlattr->value[i] = NULC; - (void)html2str(xmlattr->value, NULL); /* Convert HTML escape sequences, do not str_unescape(xmlattr->value) */ - if (remQ && *p != quote) - ret = 2; /* Quote at the beginning but not at the end: probable presence of '>' inside attribute value, so we need to read more data! */ - } else - ret = 0; - - if (ret == 0) { - if (xmlattr->name != NULL) { - __free(xmlattr->name); - xmlattr->name = NULL; - } - if (xmlattr->value != NULL) { - __free(xmlattr->value); - xmlattr->value = NULL; - } - } - - return ret; -} - -static TagType _parse_special_tag(const SXML_CHAR* str, int len, _TAG* tag, XMLNode* node) -{ - if (sx_strncmp(str, tag->start, tag->len_start)) - return TAG_NONE; - - if (sx_strncmp(str + len - tag->len_end, tag->end, tag->len_end)) /* There probably is a '>' inside the tag */ - return TAG_PARTIAL; - - node->tag = __malloc((len - tag->len_start - tag->len_end + 1)*sizeof(SXML_CHAR)); - if (node->tag == NULL) - return TAG_ERROR; - sx_strncpy(node->tag, str + tag->len_start, len - tag->len_start - tag->len_end); - node->tag[len - tag->len_start - tag->len_end] = NULC; - node->tag_type = tag->tag_type; - - return node->tag_type; -} - -/* - Reads a string that is supposed to be an xml tag like '' or ''. - Fills the 'xmlnode' structure with the tag name and its attributes. - Returns 'TAG_ERROR' if an error occurred (malformed 'str' or memory). 'TAG_*' when string is recognized. - */ -TagType XML_parse_1string(const SXML_CHAR* str, XMLNode* xmlnode) -{ - SXML_CHAR *p; - XMLAttribute* pt; - int n, nn, len, rc, tag_end = 0; - - if (str == NULL || xmlnode == NULL) - return TAG_ERROR; - len = sx_strlen(str); - - /* Check for malformed string */ - if (str[0] != C2SX('<') || str[len-1] != C2SX('>')) - return TAG_NONE; /* Syntax error */ - - for (nn = 0; nn < NB_SPECIAL_TAGS; nn++) { - n = (int)_parse_special_tag(str, len, &_spec[nn], xmlnode); - switch (n) { - case TAG_NONE: break; /* Nothing found => do nothing */ - default: return (TagType)n; /* Tag found => return it */ - } - } - - /* "" instead of ">" if a '[' is found inside */ - if (str[1] == C2SX('!')) { - /* DOCTYPE */ - if (!sx_strncmp(str, C2SX("" tag end */ - nn = 0; - if (str[n]) { /* '[' was found */ - if (sx_strncmp(str+len-2, C2SX("]>"), 2)) /* There probably is a '>' inside the DOCTYPE */ - return TAG_PARTIAL; - nn = 1; - } - xmlnode->tag = __malloc((len - 9 - nn)*sizeof(SXML_CHAR)); /* 'len' - "" + '\0' */ - if (xmlnode->tag == NULL) - return TAG_ERROR; - sx_strncpy(xmlnode->tag, &str[9], len - 10 - nn); - xmlnode->tag[len - 10 - nn] = NULC; - xmlnode->tag_type = TAG_DOCTYPE; - - return TAG_DOCTYPE; - } - } - - /* Test user tags */ - for (nn = 0; nn < _user_tags.n_tags; nn++) { - n = _parse_special_tag(str, len, &_user_tags.tags[nn], xmlnode); - switch (n) { - case TAG_ERROR: return TAG_ERROR; /* Error => exit */ - case TAG_NONE: break; /* Not this one */ - default: return (TagType)n; /* Tag found => return it */ - } - } - - if (str[1] == C2SX('/')) - tag_end = 1; - - /* tag starts at index 1 (or 2 if tag end) and ends at the first space or '/>' */ - for (n = 1 + tag_end; str[n] != NULC && str[n] != C2SX('>') && str[n] != C2SX('/') && !sx_isspace(str[n]); n++) ; - xmlnode->tag = __malloc((n - tag_end)*sizeof(SXML_CHAR)); - if (xmlnode->tag == NULL) - return TAG_ERROR; - sx_strncpy(xmlnode->tag, &str[1 + tag_end], n - 1 - tag_end); - xmlnode->tag[n - 1 - tag_end] = NULC; - if (tag_end) { - xmlnode->tag_type = TAG_END; - return TAG_END; - } - - /* Here, 'n' is the position of the first space after tag name */ - while (n < len) { - /* Skips spaces */ - while (sx_isspace(str[n])) n++; - - /* Check for XML end ('>' or '/>') */ - if (str[n] == C2SX('>')) { /* Tag with children */ - int type = (str[n-1] == '/' ? TAG_SELF : TAG_FATHER); /* TODO: Find something better to cope with */ - xmlnode->tag_type = type; - return type; - } - if (!sx_strcmp(str+n, C2SX("/>"))) { /* Tag without children */ - xmlnode->tag_type = TAG_SELF; - return TAG_SELF; - } - - /* New attribute found */ - p = sx_strchr(str+n, C2SX('=')); - if (p == NULL) goto parse_err; - pt = __realloc(xmlnode->attributes, (xmlnode->n_attributes + 1) * sizeof(XMLAttribute)); - if (pt == NULL) goto parse_err; - - pt[xmlnode->n_attributes].name = NULL; - pt[xmlnode->n_attributes].value = NULL; - pt[xmlnode->n_attributes].active = false; - xmlnode->n_attributes++; - xmlnode->attributes = pt; - while (*p != NULC && sx_isspace(*++p)) ; /* Skip spaces */ - if (isquote(*p)) { /* Attribute value starts with a quote, look for next one, ignoring protected ones with '\' */ - for (nn = p-str+1; str[nn] && str[nn] != *p; nn++) { /* CHECK UNICODE "nn = p-str+1" */ - /* if (str[nn] == C2SX('\\')) nn++; [bugs:#7]: '\' is valid in values */ - } - } else { /* Attribute value stops at first space or end of XML string */ - for (nn = p-str+1; str[nn] != NULC && !sx_isspace(str[nn]) && str[nn] != C2SX('/') && str[nn] != C2SX('>'); nn++) ; /* Go to the end of the attribute value */ /* CHECK UNICODE */ - } - - /* Here 'str[nn]' is the character after value */ - /* the attribute definition ('attrName="attrVal"') is between 'str[n]' and 'str[nn]' */ - rc = XML_parse_attribute_to(&str[n], nn - n, &xmlnode->attributes[xmlnode->n_attributes - 1]); - if (!rc) goto parse_err; - if (rc == 2) { /* Probable presence of '>' inside attribute value, which is legal XML. Remove attribute to re-parse it later */ - XMLNode_remove_attribute(xmlnode, xmlnode->n_attributes - 1); - return TAG_ERROR; /* was TAG_PARTIAL */ - } - - n = nn + 1; - } - - sx_fprintf(stderr, C2SX("\nWE SHOULD NOT BE HERE!\n[%s]\n\n"), str); - -parse_err: - (void)XMLNode_free(xmlnode); - - return TAG_ERROR; -} - -static int _parse_data_SAX(void* in, const DataSourceType in_type, const SAX_Callbacks* sax, SAX_Data* sd) -{ - SXML_CHAR *line = NULL, *txt_end, *p; - XMLNode node; - int ret, exit, sz, n0, ncr; - TagType tag_type; - int (*meos)(void* ds) = (in_type == DATA_SOURCE_BUFFER ? (int(*)(void*))_beob : (int(*)(void*))sx_feof); - - if (sax->start_doc != NULL && !sax->start_doc(sd)) - return true; - if (sax->all_event != NULL && !sax->all_event(XML_EVENT_START_DOC, NULL, (SXML_CHAR*)sd->name, 0, sd)) - return true; - - ret = true; - exit = false; - sd->line_num = 1; /* Line counter, starts at 1 */ - sz = 0; /* 'line' buffer size */ - node.init_value = 0; - (void)XMLNode_init(&node); - while ((n0 = read_line_alloc(in, in_type, &line, &sz, 0, NULC, C2SX('>'), true, C2SX('\n'), &ncr)) != 0) { - (void)XMLNode_free(&node); - for (p = line; *p != NULC && sx_isspace(*p) && p - line < n0; p++) ; /* Checks if text is only spaces */ - if (*p == NULC || p - line >= n0) - break; - sd->line_num += ncr; - - /* Get text for 'father' (i.e. what is before '<') */ - while ((txt_end = sx_strchr(line, C2SX('<'))) == NULL) { /* '<' was not found, indicating a probable '>' inside text (should have been escaped with '>' but we'll handle that ;) */ - int n1 = read_line_alloc(in, in_type, &line, &sz, n0, 0, C2SX('>'), true, C2SX('\n'), &ncr); /* Go on reading the file from current position until next '>' */ - sd->line_num += ncr; - if (n1 <= n0) { - ret = false; - if (sax->on_error == NULL && sax->all_event == NULL) { - sx_fprintf(stderr, C2SX("%s:%d: MEMORY ERROR.\n"), sd->name, sd->line_num); - } else { - if (sax->on_error != NULL && !sax->on_error(PARSE_ERR_MEMORY, sd->line_num, sd)) - break; - if (sax->all_event != NULL && !sax->all_event(XML_EVENT_ERROR, NULL, (SXML_CHAR*)sd->name, PARSE_ERR_MEMORY, sd)) - break; - } - break; /* 'txt_end' is still NULL here so we'll display the syntax error below */ - } - n0 = n1; - } - if (txt_end == NULL) { /* Missing tag start */ - ret = false; - if (sax->on_error == NULL && sax->all_event == NULL) { - sx_fprintf(stderr, C2SX("%s:%d: ERROR: Unexpected end character '>', without matching '<'!\n"), sd->name, sd->line_num); - } else { - if (sax->on_error != NULL && !sax->on_error(PARSE_ERR_UNEXPECTED_TAG_END, sd->line_num, sd)) - break; - if (sax->all_event != NULL && !sax->all_event(XML_EVENT_ERROR, NULL, (SXML_CHAR*)sd->name, PARSE_ERR_UNEXPECTED_TAG_END, sd)) - break; - } - break; - } - /* First part of 'line' (before '<') is to be added to 'father->text' */ - *txt_end = NULC; /* Have 'line' be the text for 'father' */ - if (*line != NULC && (sax->new_text != NULL || sax->all_event != NULL)) { - if (sax->new_text != NULL && (exit = !sax->new_text(line, sd))) /* no str_unescape(line) */ - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_TEXT, NULL, line, sd->line_num, sd))) - break; - } - *txt_end = '<'; /* Restores tag start */ - - switch (tag_type = XML_parse_1string(txt_end, &node)) { - case TAG_ERROR: /* Memory error */ - ret = false; - if (sax->on_error == NULL && sax->all_event == NULL) { - sx_fprintf(stderr, C2SX("%s:%d: MEMORY ERROR.\n"), sd->name, sd->line_num); - } else { - if (sax->on_error != NULL && (exit = !sax->on_error(PARSE_ERR_MEMORY, sd->line_num, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_ERROR, NULL, (SXML_CHAR*)sd->name, PARSE_ERR_MEMORY, sd))) - break; - } - break; - - case TAG_NONE: /* Syntax error */ - ret = false; - p = sx_strchr(txt_end, C2SX('\n')); - if (p != NULL) - *p = NULC; - if (sax->on_error == NULL && sax->all_event == NULL) { - sx_fprintf(stderr, C2SX("%s:%d: SYNTAX ERROR (%s%s).\n"), sd->name, sd->line_num, txt_end, p == NULL ? C2SX("") : C2SX("...")); - if (p != NULL) - *p = C2SX('\n'); - } else { - if (sax->on_error != NULL && (exit = !sax->on_error(PARSE_ERR_SYNTAX, sd->line_num, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_ERROR, NULL, (SXML_CHAR*)sd->name, PARSE_ERR_SYNTAX, sd))) - break; - } - break; - - case TAG_END: - if (sax->end_node != NULL || sax->all_event != NULL) { - if (sax->end_node != NULL && (exit = !sax->end_node(&node, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_END_NODE, &node, NULL, sd->line_num, sd))) - break; - } - break; - - default: /* Add 'node' to 'father' children */ - /* If the line looks like a comment (or CDATA) but is not properly finished, loop until we find the end. */ - while (tag_type == TAG_PARTIAL) { - int n1 = read_line_alloc(in, in_type, &line, &sz, n0, NULC, C2SX('>'), true, C2SX('\n'), &ncr); /* Go on reading the file from current position until next '>' */ - sd->line_num += ncr; - if (n1 <= n0) { - ret = false; - if (sax->on_error == NULL && sax->all_event == NULL) { - sx_fprintf(stderr, C2SX("%s:%d: SYNTAX ERROR.\n"), sd->name, sd->line_num); - } else { - if (sax->on_error != NULL && (exit = !sax->on_error(meos(in) ? PARSE_ERR_EOF : PARSE_ERR_MEMORY, sd->line_num, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_ERROR, NULL, (SXML_CHAR*)sd->name, meos(in) ? PARSE_ERR_EOF : PARSE_ERR_MEMORY, sd))) - break; - } - break; - } - n0 = n1; - txt_end = sx_strchr(line, C2SX('<')); /* In case 'line' has been moved by the '__realloc' in 'read_line_alloc' */ - tag_type = XML_parse_1string(txt_end, &node); - if (tag_type == TAG_ERROR) { - ret = false; - if (sax->on_error == NULL && sax->all_event == NULL) { - sx_fprintf(stderr, C2SX("%s:%d: PARSE ERROR.\n"), sd->name, sd->line_num); - } else { - if (sax->on_error != NULL && (exit = !sax->on_error(meos(in) ? PARSE_ERR_EOF : PARSE_ERR_SYNTAX, sd->line_num, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_ERROR, NULL, (SXML_CHAR*)sd->name, meos(in) ? PARSE_ERR_EOF : PARSE_ERR_SYNTAX, sd))) - break; - } - break; - } - } - if (ret == false) - break; - if (sax->start_node != NULL && (exit = !sax->start_node(&node, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_START_NODE, &node, NULL, sd->line_num, sd))) - break; - if (node.tag_type != TAG_FATHER && (sax->end_node != NULL || sax->all_event != NULL)) { - if (sax->end_node != NULL && (exit = !sax->end_node(&node, sd))) - break; - if (sax->all_event != NULL && (exit = !sax->all_event(XML_EVENT_END_NODE, &node, NULL, sd->line_num, sd))) - break; - } - break; - } - if (exit == true) /* Return false when exit is requested */ - ret = false; - if (ret == false || meos(in)) - break; - } - __free(line); - (void)XMLNode_free(&node); - - if (sax->end_doc != NULL && !sax->end_doc(sd)) - return ret; - if (sax->all_event != NULL) - (void)sax->all_event(XML_EVENT_END_DOC, NULL, (SXML_CHAR*)sd->name, sd->line_num, sd); - - return ret; -} - -int SAX_Callbacks_init(SAX_Callbacks* sax) -{ - if (sax == NULL) - return false; - - sax->start_doc = NULL; - sax->start_node = NULL; - sax->end_node = NULL; - sax->new_text = NULL; - sax->on_error = NULL; - sax->end_doc = NULL; - sax->all_event = NULL; - - return true; -} - -int DOMXMLDoc_doc_start(SAX_Data* sd) -{ - DOM_through_SAX* dom = (DOM_through_SAX*)sd->user; - - dom->current = NULL; - dom->error = PARSE_ERR_NONE; - dom->line_error = 0; - - return true; -} - -int DOMXMLDoc_node_start(const XMLNode* node, SAX_Data* sd) -{ - DOM_through_SAX* dom = (DOM_through_SAX*)sd->user; - XMLNode* new_node; - int i; - - if ((new_node = XMLNode_dup(node, true)) == NULL) goto node_start_err; /* No real need to put 'true' for 'XMLNode_dup', but cleaner */ - - if (dom->current == NULL) { - if ((i = _add_node(&dom->doc->nodes, &dom->doc->n_nodes, new_node)) < 0) goto node_start_err; - - if (dom->doc->i_root < 0 && (node->tag_type == TAG_FATHER || node->tag_type == TAG_SELF)) - dom->doc->i_root = i; - } else { - if (_add_node(&dom->current->children, &dom->current->n_children, new_node) < 0) goto node_start_err; - } - - new_node->father = dom->current; - dom->current = new_node; - - return true; - -node_start_err: - dom->error = PARSE_ERR_MEMORY; - dom->line_error = sd->line_num; - (void)XMLNode_free(new_node); - __free(new_node); - - return false; -} - -int DOMXMLDoc_node_end(const XMLNode* node, SAX_Data* sd) -{ - DOM_through_SAX* dom = (DOM_through_SAX*)sd->user; - - if (dom->current == NULL || sx_strcmp(dom->current->tag, node->tag)) { - sx_fprintf(stderr, C2SX("%s:%d: ERROR - End tag was unexpected"), sd->name, sd->line_num, node->tag); - if (dom->current != NULL) - sx_fprintf(stderr, C2SX(" ( was expected)\n"), dom->current->tag); - else - sx_fprintf(stderr, C2SX(" (no node to end)\n")); - - dom->error = PARSE_ERR_UNEXPECTED_NODE_END; - dom->line_error = sd->line_num; - - return false; - } - - dom->current = dom->current->father; - - return true; -} - -int DOMXMLDoc_node_text(SXML_CHAR* text, SAX_Data* sd) -{ - SXML_CHAR* p = text; - DOM_through_SAX* dom = (DOM_through_SAX*)sd->user; - - /* Keep text, even if it is only spaces */ -#if 0 - while(*p != NULC && sx_isspace(*p++)) ; - if (*p == NULC) return true; /* Only spaces */ -#endif - - /* If there is no current node to add text to, raise an error, except if text is only spaces, in which case it is probably just formatting */ - if (dom->current == NULL) { - while(*p != NULC && sx_isspace(*p++)) ; - if (*p == NULC) /* Only spaces => probably pretty-printing */ - return true; - dom->error = PARSE_ERR_TEXT_OUTSIDE_NODE; - dom->line_error = sd->line_num; - return false; /* There is some "real" text => raise an error */ - } - - if (dom->text_as_nodes) { - XMLNode* new_node = XMLNode_allocN(1); - if (new_node == NULL || (new_node->text = sx_strdup(text)) == NULL - || _add_node(&dom->current->children, &dom->current->n_children, new_node) < 0) { - dom->error = PARSE_ERR_MEMORY; - dom->line_error = sd->line_num; - (void)XMLNode_free(new_node); - __free(new_node); - return false; - } - new_node->tag_type = TAG_TEXT; - new_node->father = dom->current; - /*dom->current->tag_type = TAG_FATHER; // OS: should parent field be forced to be TAG_FATHER? now it has at least one TAG_TEXT child. I decided not to enforce this for backward-compatibility related to tag_types*/ - return true; - } else { /* Old behaviour: concatenate text to the previous one */ - /* 'p' will point at the new text */ - if (dom->current->text == NULL) { - p = sx_strdup(text); - } else { - p = __realloc(dom->current->text, (sx_strlen(dom->current->text) + sx_strlen(text) + 1)*sizeof(SXML_CHAR)); - if (p != NULL) - sx_strcat(p, text); - } - if (p == NULL) { - dom->error = PARSE_ERR_MEMORY; - dom->line_error = sd->line_num; - return false; - } - - dom->current->text = p; - } - - return true; -} - -int DOMXMLDoc_parse_error(ParseError error_num, int line_number, SAX_Data* sd) -{ - DOM_through_SAX* dom = (DOM_through_SAX*)sd->user; - - dom->error = error_num; - dom->line_error = line_number; - - /* Complete error message will be displayed in 'DOMXMLDoc_doc_end' callback */ - - return false; /* Stop on error */ -} - -int DOMXMLDoc_doc_end(SAX_Data* sd) -{ - DOM_through_SAX* dom = (DOM_through_SAX*)sd->user; - - if (dom->error != PARSE_ERR_NONE) { - SXML_CHAR* msg; - - switch (dom->error) { - case PARSE_ERR_MEMORY: msg = C2SX("MEMORY"); break; - case PARSE_ERR_UNEXPECTED_TAG_END: msg = C2SX("UNEXPECTED_TAG_END"); break; - case PARSE_ERR_SYNTAX: msg = C2SX("SYNTAX"); break; - case PARSE_ERR_EOF: msg = C2SX("UNEXPECTED_END_OF_FILE"); break; - case PARSE_ERR_TEXT_OUTSIDE_NODE: msg = C2SX("TEXT_OUTSIDE_NODE"); break; - case PARSE_ERR_UNEXPECTED_NODE_END: msg = C2SX("UNEXPECTED_NODE_END"); break; - default: msg = C2SX("UNKNOWN"); break; - } - sx_fprintf(stderr, C2SX("%s:%d: An error was found (%s(%d)), loading aborted...\n"), sd->name, dom->line_error, msg, dom->error); - dom->current = NULL; - (void)XMLDoc_free(dom->doc); - dom->doc = NULL; - } - - return true; -} - -int SAX_Callbacks_init_DOM(SAX_Callbacks* sax) -{ - if (sax == NULL) - return false; - - sax->start_doc = DOMXMLDoc_doc_start; - sax->start_node = DOMXMLDoc_node_start; - sax->end_node = DOMXMLDoc_node_end; - sax->new_text = DOMXMLDoc_node_text; - sax->on_error = DOMXMLDoc_parse_error; - sax->end_doc = DOMXMLDoc_doc_end; - sax->all_event = NULL; - - return true; -} - -int XMLDoc_parse_file_SAX(const SXML_CHAR* filename, const SAX_Callbacks* sax, void* user) -{ - FILE* f; - int ret; - SAX_Data sd; - SXML_CHAR* fmode = -#ifndef SXMLC_UNICODE - C2SX("rt"); -#else - C2SX("rb"); /* In Unicode, open the file as binary so that further 'fgetwc' read all bytes */ - BOM_TYPE bom; -#endif - - - if (sax == NULL || filename == NULL || filename[0] == NULC) - return false; - - f = sx_fopen(filename, fmode); - if (f == NULL) - return false; - /* Microsoft's 'ftell' returns invalid position for Unicode text files - (see http://connect.microsoft.com/VisualStudio/feedback/details/369265/ftell-ftell-nolock-incorrectly-handling-unicode-text-translation) - However, we're opening the file as binary in Unicode so we don't fall into that case... - */ - #if defined(SXMLC_UNICODE) && (defined(WIN32) || defined(WIN64)) - /*setvbuf(f, NULL, _IONBF, 0);*/ - #endif - - sd.name = (SXML_CHAR*)filename; - sd.user = user; -#ifdef SXMLC_UNICODE - bom = freadBOM(f, NULL, NULL); /* Skip BOM, if any */ - /* In Unicode, re-open the file in text-mode if there is no BOM (or UTF-8) as we assume that - the file is "plain" text (i.e. 1 byte = 1 character). If opened in binary mode, 'fgetwc' - would read 2 bytes for 1 character, which would not work on "plain" files. */ - if (bom == BOM_NONE || bom == BOM_UTF_8) { - sx_fclose(f); - f = sx_fopen(filename, C2SX("rt")); - if (f == NULL) - return false; - if (bom == BOM_UTF_8) - freadBOM(f, NULL, NULL); /* Skip the UTF-8 BOM that was found */ - } -#endif - ret = _parse_data_SAX((void*)f, DATA_SOURCE_FILE, sax, &sd); - (void)sx_fclose(f); - - return ret; -} - -int XMLDoc_parse_buffer_SAX_len(const SXML_CHAR* buffer, int buffer_len, const SXML_CHAR* name, const SAX_Callbacks* sax, void* user) -{ - DataSourceBuffer dsb = { buffer, buffer_len, 0 }; - SAX_Data sd; - - if (sax == NULL || buffer == NULL) - return false; - - sd.name = name; - sd.user = user; - return _parse_data_SAX((void*)&dsb, DATA_SOURCE_BUFFER, sax, &sd); -} - -int XMLDoc_parse_file_DOM_text_as_nodes(const SXML_CHAR* filename, XMLDoc* doc, int text_as_nodes) -{ - DOM_through_SAX dom; - SAX_Callbacks sax; - int ret; - - if (doc == NULL || filename == NULL || filename[0] == NULC || doc->init_value != XML_INIT_DONE) - return false; - - sx_strncpy(doc->filename, filename, SXMLC_MAX_PATH - 1); - doc->filename[SXMLC_MAX_PATH - 1] = NULC; - - /* Read potential BOM on file, only when unicode is defined */ -#ifdef SXMLC_UNICODE - { - /* In Unicode, open the file as binary so that further 'fgetwc' read all bytes */ - FILE* f = sx_fopen(filename, C2SX("rb")); - if (f != NULL) { - #if defined(SXMLC_UNICODE) && (defined(WIN32) || defined(WIN64)) - /*setvbuf(f, NULL, _IONBF, 0);*/ - #endif - doc->bom_type = freadBOM(f, doc->bom, &doc->sz_bom); - sx_fclose(f); - } - } -#endif - - dom.doc = doc; - dom.current = NULL; - dom.text_as_nodes = text_as_nodes; - SAX_Callbacks_init_DOM(&sax); - - ret = XMLDoc_parse_file_SAX(filename, &sax, &dom); - if (!ret) { - (void)XMLDoc_free(doc); - dom.doc = NULL; - return ret; - } - - /* TODO: Check there is no unfinished root nodes */ - return ret; -} - -int XMLDoc_parse_buffer_DOM_text_as_nodes(const SXML_CHAR* buffer, const SXML_CHAR* name, XMLDoc* doc, int text_as_nodes) -{ - DOM_through_SAX dom; - SAX_Callbacks sax; - int ret; - - if (doc == NULL ) - { - debugNetPrintf(3,"[SXMLC] %s doc is null\n",__FUNCTION__); - return false; - } - if(buffer == NULL) - { - debugNetPrintf(3,"[SXMLC] buffer is null\n",__FUNCTION__); - return false; - } - if(doc->init_value != XML_INIT_DONE) - { - debugNetPrintf(3,"[SXMLC] %s init_value is %s\n",__FUNCTION__,doc->init_value); - return false; - } - - dom.doc = doc; - dom.current = NULL; - dom.text_as_nodes = text_as_nodes; - SAX_Callbacks_init_DOM(&sax); - - ret = XMLDoc_parse_buffer_SAX(buffer, name, &sax, &dom); - if (!ret) { - debugNetPrintf(3,"[SXMLC] %s error is %d\n",__FUNCTION__,ret); - - XMLDoc_free(doc); - return ret; - } - debugNetPrintf(3,"[SXMLC] %s return is %d\n",__FUNCTION__,ret); - - /* TODO: Check there is no unfinished root nodes */ - return ret; -} - - - -/* --- Utility functions (ex sxmlutils.c) --- */ - -#ifdef DBG_MEM -static int nb_alloc = 0, nb_free = 0; - -void* __malloc(size_t sz) -{ - void* p = malloc(sz); - if (p != NULL) - nb_alloc++; - printf("0x%x: MALLOC (%d) - NA %d - NF %d = %d\n", p, sz, nb_alloc, nb_free, nb_alloc - nb_free); - return p; -} - -void* __calloc(size_t count, size_t sz) -{ - void* p = calloc(count, sz); - if (p != NULL) - nb_alloc++; - printf("0x%x: CALLOC (%d, %d) - NA %d - NF %d = %d\n", p, count, sz, nb_alloc, nb_free, nb_alloc - nb_free); - return p; -} - -void* __realloc(void* mem, size_t sz) -{ - void* p = realloc(mem, sz); - if (mem == NULL && p != NULL) - nb_alloc++; - else if (mem != NULL && sz == 0) - nb_free++; - printf("0x%x: REALLOC 0x%x (%d)", p, mem, sz); - if (mem == NULL) - printf(" - NA %d - NF %d = %d", nb_alloc, nb_free, nb_alloc - nb_free); - printf("\n"); - return p; -} - -void __free(void* mem) -{ - nb_free++; - printf("0x%x: FREE - NA %d - NF %d = %d\n", mem, nb_alloc, nb_free, nb_alloc - nb_free); - free(mem); -} - -char* __sx_strdup(const char* s) -{ -/* Mimic the behavior of sx_strdup(), as we can't use it directly here: DBG_MEM is defined - and sx_strdup is this function! (bug #5) */ -#ifdef SXMLC_UNICODE - char* p = wcsdup(s); -#else - char* p = strdup(s); -#endif - if (p != NULL) - nb_alloc++; - printf("0x%x: STRDUP (%d) - NA %d - NF %d = %d\n", p, sx_strlen(s), nb_alloc, nb_free, nb_alloc - nb_free); - return p; -} -#endif - -/* Dictionary of special characters and their HTML equivalent */ -static struct _html_special_dict { - SXML_CHAR chr; /* Original character */ - SXML_CHAR* html; /* Equivalent HTML string */ - int html_len; /* 'sx_strlen(html)' */ -} HTML_SPECIAL_DICT[] = { - { C2SX('<'), C2SX("<"), 4 }, - { C2SX('>'), C2SX(">"), 4 }, - { C2SX('"'), C2SX("""), 6 }, - { C2SX('\''), C2SX("'"), 6 }, - { C2SX('&'), C2SX("&"), 5 }, - { NULC, NULL, 0 }, /* Terminator */ -}; - -int _beob(DataSourceBuffer* ds) -{ - if (ds == NULL || ds->buf[ds->cur_pos] == NULC || ds->cur_pos >= ds->buf_len) - return true; - - return false; -} - -int _bgetc(DataSourceBuffer* ds) -{ - if (_beob(ds)) - return EOF; - - return (int)(ds->buf[ds->cur_pos++]); -} - -/* - * \brief Read a "line" from data source, eventually (re-)allocating a given buffer. A "line" is defined - * as a portion starting with character `from` (usually `<`) ending at character `to` (usually `>`). - * - * Characters read will be stored in `line` starting at `i0` (this allows multiple calls to - * `read_line_alloc()` on the same `line` buffer without overwriting it at each call). - * Searches for character `from` until character `to`. If `from` is 0, starts from - * current position in the data source. If `to` is 0, it is replaced by `\n`. - * - * \param in The data source (either `FILE*` if `in_type` is `DATA_SOURCE_FILE` or `SXML_CHAR*` - * if `in_type` is `DATA_SOURCE_BUFFER`). - * \param in_type specifies the type of data source to be read. - * \param line can be `NULL`, in which case it will be allocated to `*sz_line` bytes. After the function - * returns, `*sz_line` is the actual buffer size. This allows multiple calls to this function using - * the same buffer (without re-allocating/freeing). - * \param sz_line is the size of the buffer `line` if previously allocated (in `SXML_CHAR`, not byte!). - * If `NULL` or 0, an internal value of `MEM_INCR_RLA` is used. - * \param i0 The position where read characters are stored in `line`. - * \param from The character indicating a start of line. - * \param to The character indicating an end of line. - * \param keep_fromto if 0, removes characters `from` and `to` from the line (stripping). - * \param interest is a special character of interest, usually `'\n'` so we can count line numbers in the - * data source (valid only if `interest_count` is not `NULL`). - * \param interest_count if not `NULL`, will receive the count of `interest` characters while searching. - * \returns the number of characters in the line or 0 if an error occurred. - */ -int read_line_alloc(void* in, DataSourceType in_type, SXML_CHAR** line, int* sz_line, int i0, SXML_CHAR from, SXML_CHAR to, int keep_fromto, SXML_CHAR interest, int* interest_count) -{ - int init_sz = 0; - SXML_CHAR ch, *pt; - int c; - int n, ret; - int (*mgetc)(void* ds) = (in_type == DATA_SOURCE_BUFFER ? (int(*)(void*))_bgetc : (int(*)(void*))sx_fgetc); - int (*meos)(void* ds) = (in_type == DATA_SOURCE_BUFFER ? (int(*)(void*))_beob : (int(*)(void*))sx_feof); - - if (in == NULL || line == NULL) - return 0; - - if (to == NULC) - to = C2SX('\n'); - /* Search for character 'from' */ - if (interest_count != NULL) - *interest_count = 0; - while (true) { - /* Reaching EOF before 'to' char is not an error but should trigger 'line' alloc and init to '' */ - c = mgetc(in); - ch = (SXML_CHAR)c; - if (c == EOF) - break; - if (interest_count != NULL && ch == interest) - (*interest_count)++; - /* If 'from' is '\0', we stop here */ - if (ch == from || from == NULC) - break; - } - - if (sz_line == NULL) - sz_line = &init_sz; - - if (*line == NULL || *sz_line == 0) { - if (*sz_line == 0) *sz_line = MEM_INCR_RLA; - *line = __malloc(*sz_line*sizeof(SXML_CHAR)); - if (*line == NULL) - return 0; - } - if (i0 < 0) - i0 = 0; - if (i0 >= *sz_line) - return 0; - - n = i0; - if (c == CEOF) { /* EOF reached before 'to' char => return the empty string */ - (*line)[n] = NULC; - return meos(in) ? n : 0; /* Error if not EOF */ - } - if (ch != from || keep_fromto) { - (*line)[n++] = ch; - if (n >= *sz_line) { - *sz_line += MEM_INCR_RLA; - pt = __realloc(*line, *sz_line*sizeof(SXML_CHAR)); - if (pt == NULL) { - return 0; - } else - *line = pt; - } - } - (*line)[n] = NULC; - ret = 0; - while (true) { - if ((c = mgetc(in)) == CEOF) { /* EOF or error */ - (*line)[n] = NULC; - ret = meos(in) ? n : 0; - break; - } - ch = (SXML_CHAR)c; - if (interest_count != NULL && ch == interest) - (*interest_count)++; - (*line)[n] = ch; - if (ch != to || (keep_fromto && to != NULC && ch == to)) /* If we reached the 'to' character and we keep it, we still need to add the extra '\0' */ - n++; - if (n >= *sz_line) { /* Too many characters for our line => realloc some more */ - *sz_line += MEM_INCR_RLA; - pt = __realloc(*line, *sz_line*sizeof(SXML_CHAR)); - if (pt == NULL) { - ret = 0; - break; - } else - *line = pt; - } - (*line)[n] = NULC; /* If we reached the 'to' character and we want to strip it, 'n' hasn't changed and 'line[n]' (which is 'to') will be replaced by '\0' */ - if (ch == to) { - ret = n; - break; - } - } - -#if 0 /* Automatic buffer resize is deactivated */ - /* Resize line to the exact size */ - pt = __realloc(*line, (n+1)*sizeof(SXML_CHAR)); - if (pt != NULL) - *line = pt; -#endif - - return ret; -} - -/* --- */ - -SXML_CHAR* strcat_alloc(SXML_CHAR** src1, const SXML_CHAR* src2) -{ - SXML_CHAR* cat; - int n; - - /* Do not concatenate '*src1' with itself */ - if (src1 == NULL || *src1 == src2) - return NULL; - - /* Concatenate a NULL or empty string */ - if (src2 == NULL || *src2 == NULC) - return *src1; - - n = (*src1 == NULL ? 0 : sx_strlen(*src1)) + sx_strlen(src2) + 1; - cat = __realloc(*src1, n*sizeof(SXML_CHAR)); - if (cat == NULL) - return NULL; - if (*src1 == NULL) - *cat = NULC; - *src1 = cat; - sx_strcat(*src1, src2); - - return *src1; -} - -SXML_CHAR* strip_spaces(SXML_CHAR* str, SXML_CHAR repl_sq) -{ - SXML_CHAR* p; - int i, len; - - /* 'p' to the first non-space */ - for (p = str; *p != NULC && sx_isspace(*p); p++) ; /* No need to search for 'protect' as it is not a space */ - len = sx_strlen(str); - for (i = len-1; i >= 0 && sx_isspace(str[i]); i--) ; - if (i >= 0 && str[i] == C2SX('\\')) /* If last non-space is the protection, keep the last space */ - i++; - str[i+1] = NULC; /* New end of string to last non-space */ - - if (repl_sq == NULC) { - if (p == str && i == len) - return str; /* Nothing to do */ - for (i = 0; (str[i] = *p) != NULC; i++, p++) ; /* Copy 'p' to 'str' */ - return str; - } - - /* Squeeze all spaces with 'repl_sq' */ - i = 0; - while (*p != NULC) { - if (sx_isspace(*p)) { - str[i++] = repl_sq; - while (sx_isspace(*++p)) ; /* Skips all next spaces */ - } else { - if (*p == C2SX('\\')) - p++; - str[i++] = *p++; - } - } - str[i] = NULC; - - return str; -} - -SXML_CHAR* str_unescape(SXML_CHAR* str) -{ - int i, j; - - if (str == NULL) - return NULL; - - for (i = j = 0; str[j]; j++) { - if (str[j] == C2SX('\\')) - j++; - str[i++] = str[j]; - } - - return str; -} - -int split_left_right(SXML_CHAR* str, SXML_CHAR sep, int* l0, int* l1, int* i_sep, int* r0, int* r1, int ignore_spaces, int ignore_quotes) -{ - int n0, n1, is; - SXML_CHAR quote = '\0'; - - if (str == NULL) - return false; - - if (i_sep != NULL) - *i_sep = -1; - - if (!ignore_spaces) /* No sense of ignore quotes if spaces are to be kept */ - ignore_quotes = false; - - /* Parse left part */ - - if (ignore_spaces) { - for (n0 = 0; str[n0] != NULC && sx_isspace(str[n0]); n0++) ; /* Skip head spaces, n0 points to first non-space */ - if (ignore_quotes && isquote(str[n0])) { /* If quote is found, look for next one */ - quote = str[n0++]; /* Quote can be '\'' or '"' */ - for (n1 = n0; str[n1] != NULC && str[n1] != quote; n1++) { - if (str[n1] == C2SX('\\') && str[++n1] == NULC) - break; /* Escape character (can be the last) */ - } - for (is = n1 + 1; str[is] != NULC && sx_isspace(str[is]); is++) ; /* '--' not to take quote into account */ - } else { - for (n1 = n0; str[n1] != NULC && str[n1] != sep && !sx_isspace(str[n1]); n1++) ; /* Search for separator or a space */ - for (is = n1; str[is] != NULC && sx_isspace(str[is]); is++) ; - } - } else { - n0 = 0; - for (n1 = 0; str[n1] != NULC && str[n1] != sep; n1++) ; /* Search for separator only */ - is = n1; - } - - /* Here 'n0' is the start of left member, 'n1' is the character after the end of left member */ - - if (l0 != NULL) - *l0 = n0; - if (l1 != NULL) - *l1 = n1 - 1; - if (i_sep != NULL) - *i_sep = is; - if (str[is] == NULC || str[is+1] == NULC) { /* No separator => empty right member */ - if (r0 != NULL) - *r0 = is; - if (r1 != NULL) - *r1 = is-1; - if (i_sep != NULL) - *i_sep = (str[is] == NULC ? -1 : is); - return true; - } - - /* Parse right part */ - - n0 = is + 1; - if (ignore_spaces) { - for (; str[n0] != NULC && sx_isspace(str[n0]); n0++) ; - if (ignore_quotes && isquote(str[n0])) - quote = str[n0]; - } - - for (n1 = ++n0; str[n1]; n1++) { - if (ignore_quotes && str[n1] == quote) /* Quote was reached */ - break; - if (str[n1] == C2SX('\\') && str[++n1] == NULC) /* Escape character (can be the last) */ - break; - } - if (ignore_quotes && str[n1--] != quote) /* Quote is not the same than earlier, '--' is not to take it into account */ - return false; - if (!ignore_spaces) - while (str[++n1]) ; /* Jump down the end of the string */ - - if (r0 != NULL) - *r0 = n0; - if (r1 != NULL) - *r1 = n1; - - return true; -} - -#ifdef SXMLC_UNICODE -BOM_TYPE freadBOM(FILE* f, unsigned char* bom, int* sz_bom) -{ - unsigned char c1, c2; - long pos; - - if (f == NULL) - return BOM_NONE; - - /* Save position and try to read and skip BOM if found. If not, go back to save position. */ - pos = ftell(f); - if (pos < 0) - return BOM_NONE; - if (fread(&c1, sizeof(char), 1, f) != 1 || fread(&c2, sizeof(char), 1, f) != 1) { - fseek(f, pos, SEEK_SET); - return BOM_NONE; - } - if (bom != NULL) { - bom[0] = c1; - bom[1] = c2; - bom[2] = '\0'; - if (sz_bom != NULL) - *sz_bom = 2; - } - switch ((unsigned short)(c1 << 8) | c2) { - case (unsigned short)0xfeff: - return BOM_UTF_16BE; - - case (unsigned short)0xfffe: - pos = ftell(f); /* Save current position to get it back if BOM is not UTF-32LE */ - if (pos < 0) - return BOM_UTF_16LE; - if (fread(&c1, sizeof(char), 1, f) != 1 || fread(&c2, sizeof(char), 1, f) != 1) { - fseek(f, pos, SEEK_SET); - return BOM_UTF_16LE; - } - if (c1 == 0x00 && c2 == 0x00) { - if (bom != NULL) - bom[2] = bom[3] = bom[4] = '\0'; - if (sz_bom != NULL) - *sz_bom = 4; - return BOM_UTF_32LE; - } - fseek(f, pos, SEEK_SET); /* fseek(f, -2, SEEK_CUR) is not garanteed on Windows (and actually fail in Unicode...) */ - return BOM_UTF_16LE; - - case (unsigned short)0x0000: - if (fread(&c1, sizeof(char), 1, f) == 1 && fread(&c2, sizeof(char), 1, f) == 1 - && c1 == 0xfe && c2 == 0xff) { - bom[2] = c1; - bom[3] = c2; - bom[4] = '\0'; - if (sz_bom != NULL) - *sz_bom = 4; - return BOM_UTF_32BE; - } - fseek(f, pos, SEEK_SET); - return BOM_NONE; - - case (unsigned short)0xefbb: /* UTF-8? */ - if (fread(&c1, sizeof(char), 1, f) != 1 || c1 != 0xbf) { /* Not UTF-8 */ - fseek(f, pos, SEEK_SET); - if (bom != NULL) - bom[0] = '\0'; - if (sz_bom != NULL) - *sz_bom = 0; - return BOM_NONE; - } - if (bom != NULL) { - bom[2] = c1; - bom[3] = '\0'; - } - if (sz_bom != NULL) - *sz_bom = 3; - return BOM_UTF_8; - - default: /* No BOM, go back */ - fseek(f, pos, SEEK_SET); - if (bom != NULL) - bom[0] = '\0'; - if (sz_bom != NULL) - *sz_bom = 0; - return BOM_NONE; - } -} -#endif - -/* --- */ - -SXML_CHAR* html2str(SXML_CHAR* html, SXML_CHAR* str) -{ - SXML_CHAR *ps, *pd; - int i; - - if (html == NULL) - return NULL; - - if (str == NULL) - str = html; - - /* Look for '&' and matches it to any of the recognized HTML pattern. */ - /* If found, replaces the '&' by the corresponding char. */ - /* 'p2' is the char to analyze, 'p1' is where to insert it */ - for (pd = str, ps = html; *ps; ps++, pd++) { - if (*ps != C2SX('&')) { - if (pd != ps) - *pd = *ps; - continue; - } - - for (i = 0; HTML_SPECIAL_DICT[i].chr; i++) { - if (sx_strncmp(ps, HTML_SPECIAL_DICT[i].html, HTML_SPECIAL_DICT[i].html_len)) - continue; - - *pd = HTML_SPECIAL_DICT[i].chr; - ps += HTML_SPECIAL_DICT[i].html_len-1; - break; - } - /* If no string was found, simply copy the character */ - if (HTML_SPECIAL_DICT[i].chr == NULC && pd != ps) - *pd = *ps; - } - *pd = NULC; - - return str; -} - -/* TODO: Allocate 'html'? */ -SXML_CHAR* str2html(SXML_CHAR* str, SXML_CHAR* html) -{ - SXML_CHAR *ps, *pd; - int i; - - if (str == NULL) - return NULL; - - if (html == str) /* Not handled (yet) */ - return NULL; - - if (html == NULL) { /* Allocate 'html' to the correct size */ - html = __malloc(strlen_html(str) * sizeof(SXML_CHAR)); - if (html == NULL) - return NULL; - } - - for (ps = str, pd = html; *ps; ps++, pd++) { - for (i = 0; HTML_SPECIAL_DICT[i].chr; i++) { - if (*ps == HTML_SPECIAL_DICT[i].chr) { - sx_strcpy(pd, HTML_SPECIAL_DICT[i].html); - pd += HTML_SPECIAL_DICT[i].html_len - 1; - break; - } - } - if (HTML_SPECIAL_DICT[i].chr == NULC && pd != ps) - *pd = *ps; - } - *pd = NULC; - - return html; -} - -int strlen_html(SXML_CHAR* str) -{ - int i, j, n; - - if (str == NULL) - return 0; - - n = 0; - for (i = 0; str[i] != NULC; i++) { - for (j = 0; HTML_SPECIAL_DICT[j].chr; j++) { - if (str[i] == HTML_SPECIAL_DICT[j].chr) { - n += HTML_SPECIAL_DICT[j].html_len; - break; - } - } - if (HTML_SPECIAL_DICT[j].chr == NULC) - n++; - } - - return n; -} - -int fprintHTML(FILE* f, SXML_CHAR* str) -{ - SXML_CHAR* p; - int i, n; - - for (p = str, n = 0; *p != NULC; p++) { - for (i = 0; HTML_SPECIAL_DICT[i].chr; i++) { - if (*p != HTML_SPECIAL_DICT[i].chr) - continue; - if (f != NULL) - sx_fputs(HTML_SPECIAL_DICT[i].html, f); - n += HTML_SPECIAL_DICT[i].html_len; - break; - } - if (HTML_SPECIAL_DICT[i].chr == NULC) { - if (f != NULL) - (void)sx_fputc(*p, f); - n++; - } - } - - return n; -} - -int regstrcmp(SXML_CHAR* str, SXML_CHAR* pattern) -{ - SXML_CHAR *p, *s; - - if (str == NULL && pattern == NULL) - return true; - - if (str == NULL || pattern == NULL) - return false; - - p = pattern; - s = str; - while (true) { - switch (*p) { - /* Any character matches, go to next one */ - case C2SX('?'): - p++; - s++; - break; - - /* Go to next character in pattern and wait until it is found in 'str' */ - case C2SX('*'): - for (; *p != NULC; p++) { /* Squeeze '**?*??**' to '*' */ - if (*p != C2SX('*') && *p != C2SX('?')) - break; - } - for (; *s != NULC; s++) { - if (*s == *p) - break; - } - break; - - /* NULL character on pattern has to be matched by 'str' */ - case 0: - return *s ? false : true; - - default: - if (*p == C2SX('\\')) /* Escape character */ - p++; - if (*p++ != *s++) /* Characters do not match */ - return false; - break; - } - } - - return false; -} diff --git a/source/libsxmlc/sxmlsearch.c b/source/libsxmlc/sxmlsearch.c deleted file mode 100755 index c03b12a..0000000 --- a/source/libsxmlc/sxmlsearch.c +++ /dev/null @@ -1,639 +0,0 @@ -/* - Copyright (c) 2010, Matthieu Labas - All rights reserved. - - Redistribution and use in source and binary forms, with or without modification, - are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY - OF SUCH DAMAGE. - - The views and conclusions contained in the software and documentation are those of the - authors and should not be interpreted as representing official policies, either expressed - or implied, of the FreeBSD Project. -*/ -#if defined(WIN32) || defined(WIN64) -#pragma warning(disable : 4996) -#endif - -#include -#include -#include "sxmlc.h" -#include "sxmlsearch.h" - -#define INVALID_XMLNODE_POINTER ((XMLNode*)-1) - -/* The function used to compare a string to a pattern */ -static REGEXPR_COMPARE regstrcmp_search = regstrcmp; - -REGEXPR_COMPARE XMLSearch_set_regexpr_compare(REGEXPR_COMPARE fct) -{ - REGEXPR_COMPARE previous = regstrcmp_search; - - regstrcmp_search = fct; - - return previous; -} - -int XMLSearch_init(XMLSearch* search) -{ - if (search == NULL) - return false; - - if (search->init_value == XML_INIT_DONE) - XMLSearch_free(search, true); - - search->tag = NULL; - search->text = NULL; - search->attributes = NULL; - search->n_attributes = 0; - search->next = NULL; - search->prev = NULL; - search->stop_at = INVALID_XMLNODE_POINTER; /* Because 'NULL' can be a valid value */ - search->init_value = XML_INIT_DONE; - - return true; -} - -int XMLSearch_free(XMLSearch* search, int free_next) -{ - int i; - - if (search == NULL || search->init_value != XML_INIT_DONE) - return false; - - if (search->tag != NULL) { - __free(search->tag); - search->tag = NULL; - } - - if (search->attributes != NULL) { - for (i = 0; i < search->n_attributes; i++) { - if (search->attributes[i].name != NULL) - __free(search->attributes[i].name); - if (search->attributes[i].value != NULL) - __free(search->attributes[i].value); - } - __free(search->attributes); - search->n_attributes = 0; - search->attributes = NULL; - } - - if (free_next && search->next != NULL) { - (void)XMLSearch_free(search->next, true); - __free(search->next); - search->next = NULL; - } - search->init_value = 0; /* Something not XML_INIT_DONE, otherwise we'll go into 'XMLSearch_free' again */ - (void)XMLSearch_init(search); - - return true; -} - -int XMLSearch_search_set_tag(XMLSearch* search, const SXML_CHAR* tag) -{ - if (search == NULL) - return false; - - if (tag == NULL) { - if (search->tag != NULL) { - __free(search->tag); - search->tag = NULL; - } - return true; - } - - search->tag = sx_strdup(tag); - return (search->tag != NULL); -} - -int XMLSearch_search_set_text(XMLSearch* search, const SXML_CHAR* text) -{ - if (search == NULL) - return false; - - if (text == NULL) { - if (search->text != NULL) { - __free(search->text); - search->text = NULL; - } - return true; - } - - search->text = sx_strdup(text); - return (search->text != NULL); -} - -int XMLSearch_search_add_attribute(XMLSearch* search, const SXML_CHAR* attr_name, const SXML_CHAR* attr_value, int value_equal) -{ - int i; - XMLAttribute* pt; - SXML_CHAR* name; - SXML_CHAR* value; - - if (search == NULL) - return -1; - - if (attr_name == NULL || attr_name[0] == NULC) - return -1; - - name = sx_strdup(attr_name); - value = (attr_value == NULL ? NULL : sx_strdup(attr_value)); - if (name == NULL || (attr_value && value == NULL)) { - if (value != NULL) - __free(value); - if (name != NULL) - __free(name); - } - - i = search->n_attributes; - pt = (XMLAttribute*)__realloc(search->attributes, (i + 1) * sizeof(XMLAttribute)); - if (pt == NULL) { - if (value) - __free(value); - __free(name); - return -1; - } - - pt[i].name = name; - pt[i].value = value; - pt[i].active = value_equal; - - search->n_attributes = i+1; - search->attributes = pt; - - return i; -} - -int XMLSearch_search_get_attribute_index(const XMLSearch* search, const SXML_CHAR* attr_name) -{ - int i; - - if (search == NULL || attr_name == NULL || attr_name[0] == NULC) - return -1; - - for (i = 0; i < search->n_attributes; i++) { - if (!sx_strcmp(search->attributes[i].name, attr_name)) - return i; - } - - return -1; -} - -int XMLSearch_search_remove_attribute(XMLSearch* search, int i_attr) -{ - XMLAttribute* pt; - - if (search == NULL || i_attr < 0 || i_attr >= search->n_attributes) - return -1; - - /* Free attribute fields first */ - if (search->n_attributes == 1) - pt = NULL; - else { - pt = (XMLAttribute*)__malloc((search->n_attributes - 1) * sizeof(XMLAttribute)); - if (pt == NULL) - return -1; - } - if (search->attributes[i_attr].name != NULL) - __free(search->attributes[i_attr].name); - if (search->attributes[i_attr].value != NULL) - __free(search->attributes[i_attr].value); - - if (pt != NULL) { - memcpy(pt, search->attributes, i_attr * sizeof(XMLAttribute)); - memcpy(&pt[i_attr], &search->attributes[i_attr + 1], (search->n_attributes - i_attr - 1) * sizeof(XMLAttribute)); - } - if (search->attributes) - __free(search->attributes); - search->attributes = pt; - search->n_attributes--; - - return search->n_attributes; -} - -int XMLSearch_search_set_children_search(XMLSearch* search, XMLSearch* children_search) -{ - if (search == NULL) - return false; - - if (search->next != NULL) - XMLSearch_free(search->next, true); - - search->next = children_search; - children_search->prev = search; - - return true; -} - -SXML_CHAR* XMLSearch_get_XPath_string(const XMLSearch* search, SXML_CHAR** xpath, SXML_CHAR quote) -{ - const XMLSearch* s; - SXML_CHAR squote[] = C2SX("'"); - int i, fill; - - if (xpath == NULL) - return NULL; - - /* NULL 'search' is an empty string */ - if (search == NULL) { - *xpath = sx_strdup(C2SX("")); - if (*xpath == NULL) - return NULL; - - return *xpath; - } - - squote[0] = (quote == NULC ? XML_DEFAULT_QUOTE : quote); - - for (s = search; s != NULL; s = s->next) { - if (s != search && strcat_alloc(xpath, C2SX("/")) == NULL) goto err; /* No "/" prefix for the first criteria */ - if (strcat_alloc(xpath, s->tag == NULL || s->tag[0] == NULC ? C2SX("*"): s->tag) == NULL) goto err; - - if (s->n_attributes > 0 || (s->text != NULL && s->text[0] != NULC)) - if (strcat_alloc(xpath, C2SX("[")) == NULL) goto err; - - fill = false; /* '[' has not been filled with text yet, no ", " separator should be added */ - if (s->text != NULL && s->text[0] != NULC) { - if (strcat_alloc(xpath, C2SX(".=")) == NULL) goto err; - if (strcat_alloc(xpath, squote) == NULL) goto err; - if (strcat_alloc(xpath, s->text) == NULL) goto err; - if (strcat_alloc(xpath, squote) == NULL) goto err; - fill = true; - } - - for (i = 0; i < s->n_attributes; i++) { - if (fill) { - if (strcat_alloc(xpath, C2SX(", ")) == NULL) goto err; - } else - fill = true; /* filling is being performed */ - if (strcat_alloc(xpath, C2SX("@")) == NULL) goto err; - if (strcat_alloc(xpath, s->attributes[i].name) == NULL) goto err; - if (s->attributes[i].value == NULL) continue; - - if (strcat_alloc(xpath, s->attributes[i].active ? C2SX("=") : C2SX("!=")) == NULL) goto err; - if (strcat_alloc(xpath, squote) == NULL) goto err; - if (strcat_alloc(xpath, s->attributes[i].value) == NULL) goto err; - if (strcat_alloc(xpath, squote) == NULL) goto err; - } - if ((s->text != NULL && s->text[0] != NULC) || s->n_attributes > 0) { - if (strcat_alloc(xpath, C2SX("]")) == NULL) goto err; - } - } - - return *xpath; - -err: - __free(*xpath); - *xpath = NULL; - - return NULL; -} - -/* - Extract search information from 'xpath', where 'xpath' represents a single node - (i.e. no '/' inside, except escaped ones), stripped from lead and tail '/'. - tag[.=text, @attrib="value"] with potential spaces around '=' and ','. - Return 'false' if parsing failed, 'true' for success. - This is an internal function so we assume that arguments are valid (non-NULL). - */ -static int _init_search_from_1XPath(SXML_CHAR* xpath, XMLSearch* search) -{ - SXML_CHAR *p, *q; - SXML_CHAR c, c1, cc; - int l0, l1, is, r0, r1; - int ret; - - XMLSearch_init(search); - - /* Look for tag name */ - for (p = xpath; *p != NULC && *p != C2SX('['); p++) ; - c = *p; /* Either '[' or '\0' */ - *p = NULC; - ret = XMLSearch_search_set_tag(search, xpath); - *p = c; - if (!ret) - return false; - - if (*p == NULC) - return true; - - /* Here, '*p' is '[', we have to parse either text or attribute names/values until ']' */ - for (p++; *p && *p != C2SX(']'); p++) { - for (q = p; *q && *q != C2SX(',') && *q != C2SX(']'); q++) ; /* Look for potential ',' separator to null it */ - cc = *q; - if (*q == C2SX(',') || *q == C2SX(']')) - *q = NULC; - ret = true; - switch (*p) { - case C2SX('.'): /* '.[ ]=[ ]["']...["']' to search for text */ - if (!split_left_right(p, C2SX('='), &l0, &l1, &is, &r0, &r1, true, true)) - return false; - c = p[r1+1]; - p[r1+1] = NULC; - ret = XMLSearch_search_set_text(search, &p[r0]); - p[r1+1] = c; - p += r1+1; - break; - - /* Attribute name, possibly '@attrib[[ ]=[ ]"value"]' */ - case C2SX('@'): - if (!split_left_right(++p, '=', &l0, &l1, &is, &r0, &r1, true, true)) - return false; - c = p[l1+1]; - c1 = p[r1+1]; - p[l1+1] = NULC; - p[r1+1] = NULC; - ret = (XMLSearch_search_add_attribute(search, &p[l0], (is < 0 ? NULL : &p[r0]), true) < 0 ? false : true); /* 'is' < 0 when there is no '=' (i.e. check for attribute presence only */ - p[l1+1] = c; - p[r1+1] = c1; - p += r1-1; /* Jump to next value */ - break; - - default: /* Not implemented */ - break; - } - *q = cc; /* Restore ',' separator if any */ - if (!ret) - return false; - } - - return true; -} - -int XMLSearch_init_from_XPath(const SXML_CHAR* xpath, XMLSearch* search) -{ - XMLSearch *search1, *search2; - SXML_CHAR *p, *tag, *tag0; - SXML_CHAR c; - - if (!XMLSearch_init(search)) - return false; - - /* NULL or empty xpath is an empty (initialized only) search */ - if (xpath == NULL || *xpath == NULC) - return true; - - search1 = NULL; /* Search struct to add the xpath portion to */ - search2 = search; /* Search struct to be filled from xpath portion */ - - tag = tag0 = sx_strdup(xpath); /* Create a copy of 'xpath' to be able to patch it (or segfault if 'xpath' is const, cnacu6o Sergey@sourceforge!) */ - while (*tag != NULC) { - if (search2 != search) { /* Allocate a new search when the original one (i.e. 'search') has already been filled */ - search2 = (XMLSearch*)__calloc(1, sizeof(XMLSearch)); - if (search2 == NULL) { - __free(tag0); - (void)XMLSearch_free(search, true); - return false; - } - } - /* Skip all first '/' */ - for (; *tag != NULC && *tag == C2SX('/'); tag++) ; - if (*tag == NULC) { - __free(tag0); - return false; - } - - /* Look for the end of tag name: after '/' (to get another tag) or end of string */ - for (p = &tag[1]; *p != NULC && *p != C2SX('/'); p++) { - if (*p == C2SX('\\') && *++p == NULC) - break; /* Escape character, '\' could be the last character... */ - } - c = *p; /* Backup character before nulling it */ - *p = NULC; - if (!_init_search_from_1XPath(tag, search2)) { - __free(tag0); - (void)XMLSearch_free(search, true); - return false; - } - *p = c; - - /* 'search2' is the newly parsed tag, 'search1' is the previous tag (or NULL if 'search2' is the first tag to parse (i.e. 'search2' == 'search') */ - - if (search1 != NULL) search1->next = search2; - if (search2 != search) search2->prev = search1; - search1 = search2; - search2 = NULL; /* Will force allocation during next loop */ - tag = p; - } - - __free(tag0); - return true; -} - -static int _attribute_matches(XMLAttribute* to_test, XMLAttribute* pattern) -{ - if (to_test == NULL && pattern == NULL) - return true; - - if (to_test == NULL || pattern == NULL) - return false; - - /* No test on name => match */ - if (pattern->name == NULL || pattern->name[0] == NULC) - return true; - - /* Test on name fails => no match */ - if (!regstrcmp_search(to_test->name, pattern->name)) - return false; - - /* No test on value => match */ - if (pattern->value == NULL) - return true; - - /* Test on value according to pattern "equal" attribute */ - return regstrcmp_search(to_test->value, pattern->value) == pattern->active ? true : false; -} - -int XMLSearch_node_matches(const XMLNode* node, const XMLSearch* search) -{ - int i, j; - - if (node == NULL) - return false; - - if (search == NULL) - return true; - - /* No comments, prolog, or such type of nodes are tested */ - if (node->tag_type != TAG_FATHER && node->tag_type != TAG_SELF) - return false; - - /* Check tag */ - if (search->tag != NULL && !regstrcmp_search(node->tag, search->tag)) - return false; - - /* Check text */ - if (search->text != NULL && !regstrcmp_search(node->text, search->text)) - return false; - - /* Check attributes */ - if (search->attributes != NULL) { - for (i = 0; i < search->n_attributes; i++) { - for (j = 0; j < node->n_attributes; j++) { - if (!node->attributes[j].active) - continue; - if (_attribute_matches(&node->attributes[j], &search->attributes[i])) - break; - } - if (j >= node->n_attributes) /* All attributes where scanned without a successful match */ - return false; - } - } - - /* 'node' matches 'search'. If there is a father search, its father must match it */ - if (search->prev != NULL) - return XMLSearch_node_matches(node->father, search->prev); - - /* TODO: Should a node match if search has no more 'prev' search and node father is still below the initial search ? - Depends if XPath started with "//" (=> yes) or "/" (=> no). - if (search->prev == NULL && node->father != search->from) return false; ? */ - - return true; -} - -XMLNode* XMLSearch_next(const XMLNode* from, XMLSearch* search) -{ - XMLNode* node; - - if (search == NULL || from == NULL) - return NULL; - - /* Go down the last child search as fathers will be tested recursively by the 'XMLSearch_node_matches' function */ - for (; search->next != NULL; search = search->next) ; - - /* Initialize the 'stop_at' node on first search, to remember where to stop as there will be multiple calls */ - /* 'stop_at' can be NULL when 'from' is a root node, that is why it should be initialized with something else than NULL */ - if (search->stop_at == INVALID_XMLNODE_POINTER) - search->stop_at = XMLNode_next_sibling(from); - - for (node = XMLNode_next(from); node != search->stop_at; node = XMLNode_next(node)) { /* && node != NULL */ - if (!XMLSearch_node_matches(node, search)) - continue; - - /* 'node' is a matching node */ - - /* No search to perform on 'node' children => 'node' is returned */ - if (search->next == NULL) - return node; - - /* Run the search on 'node' children */ - return XMLSearch_next(node, search->next); - } - - return NULL; -} - -static SXML_CHAR* _get_XPath(const XMLNode* node, SXML_CHAR** xpath) -{ - int i, n, brackets, sz_xpath; - SXML_CHAR* p; - - brackets = 0; - sz_xpath = sx_strlen(node->tag); - if (node->text != NULL) { - sz_xpath += strlen_html(node->text) + 4; /* 4 = '.=""' */ - brackets = 2; /* Text has to be displayed => add '[]' */ - } - for (i = 0; i < node->n_attributes; i++) { - if (!node->attributes[i].active) - continue; - brackets = 2; /* At least one attribute has to be displayed => add '[]' */ - sz_xpath += strlen_html(node->attributes[i].name) + strlen_html(node->attributes[i].value) + 6; /* 6 = ', @=""' */ - } - sz_xpath += brackets + 1; - *xpath = (SXML_CHAR*)__malloc(sz_xpath*sizeof(SXML_CHAR)); - - if (*xpath == NULL) - return NULL; - - sx_strcpy(*xpath, node->tag); - if (node->text != NULL) { - sx_strcat(*xpath, C2SX("[.=\"")); - (void)str2html(node->text, &(*xpath[sx_strlen(*xpath)])); - sx_strcat(*xpath, C2SX("\"")); - n = 1; /* Indicates '[' has been put */ - } else - n = 0; - - for (i = 0; i < node->n_attributes; i++) { - if (!node->attributes[i].active) - continue; - - if (n == 0) { - sx_strcat(*xpath, C2SX("[")); - n = 1; - } else - sx_strcat(*xpath, C2SX(", ")); - p = &(*xpath)[sx_strlen(*xpath)]; - - /* Standard and Unicode versions of 'sprintf' do not have the same signature! :( */ - sx_sprintf(p, -#ifdef SXMLC_UNICODE - sz_xpath, -#endif - C2SX("@%s=%c"), node->attributes[i].name, XML_DEFAULT_QUOTE); - - (void)str2html(node->attributes[i].value, p); - sx_strcat(*xpath, C2SX("\"")); - } - if (n > 0) - sx_strcat(*xpath, C2SX("]")); - - return *xpath; -} - -SXML_CHAR* XMLNode_get_XPath(XMLNode* node, SXML_CHAR** xpath, int incl_parents) -{ - SXML_CHAR* xp = NULL; - SXML_CHAR* xparent; - XMLNode* parent; - - if (node == NULL || node->init_value != XML_INIT_DONE || xpath == NULL) - return NULL; - - if (!incl_parents) { - if (_get_XPath(node, &xp) == NULL) { - *xpath = NULL; - return NULL; - } - return *xpath = xp; - } - - /* Go up to root node */ - parent = node; - do { - xparent = NULL; - if (_get_XPath(parent, &xparent) == NULL) goto xp_err; - if (xp != NULL) { - if (strcat_alloc(&xparent, C2SX("/")) == NULL) goto xp_err; - if (strcat_alloc(&xparent, xp) == NULL) goto xp_err; - } - xp = xparent; - parent = parent->father; - } while (parent != NULL); - if ((*xpath = sx_strdup(C2SX("/"))) == NULL || strcat_alloc(xpath, xp) == NULL) goto xp_err; - - return *xpath; - -xp_err: - if (xp != NULL) __free(xp); - *xpath = NULL; - - return NULL; -} diff --git a/source/libz/LICENSE b/source/libz/LICENSE deleted file mode 100644 index 7e985c6..0000000 --- a/source/libz/LICENSE +++ /dev/null @@ -1,40 +0,0 @@ -(Extracted from zlib README.) - -Acknowledgments: - - The deflate format used by zlib was defined by Phil Katz. The deflate and - zlib specifications were written by L. Peter Deutsch. Thanks to all the - people who reported problems and suggested various improvements in zlib; they - are too numerous to cite here. - -Copyright notice: - - (C) 1995-2012 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 - -If you use the zlib library in a product, we would appreciate *not* receiving -lengthy legal documents to sign. The sources are provided for free but without -warranty of any kind. The library has been entirely written by Jean-loup -Gailly and Mark Adler; it does not include third-party code. - -If you redistribute modified sources, we would appreciate that you include in -the file ChangeLog history information documenting your changes. Please read -the FAQ for more information on the distribution of modified source versions. \ No newline at end of file diff --git a/source/libz/adler32.c b/source/libz/adler32.c deleted file mode 100644 index 507c935..0000000 --- a/source/libz/adler32.c +++ /dev/null @@ -1,157 +0,0 @@ -/* adler32.c -- compute the Adler-32 checksum of a data stream - * Copyright (C) 1995-2007 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#include "zutil.h" - -#define local static - -local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); - -#define BASE 65521UL /* largest prime smaller than 65536 */ -#define NMAX 5552 -/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ - -#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} -#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); -#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); -#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); -#define DO16(buf) DO8(buf,0); DO8(buf,8); - -/* use NO_DIVIDE if your processor does not do division in hardware */ -#ifdef NO_DIVIDE -# define MOD(a) \ - do { \ - if (a >= (BASE << 16)) a -= (BASE << 16); \ - if (a >= (BASE << 15)) a -= (BASE << 15); \ - if (a >= (BASE << 14)) a -= (BASE << 14); \ - if (a >= (BASE << 13)) a -= (BASE << 13); \ - if (a >= (BASE << 12)) a -= (BASE << 12); \ - if (a >= (BASE << 11)) a -= (BASE << 11); \ - if (a >= (BASE << 10)) a -= (BASE << 10); \ - if (a >= (BASE << 9)) a -= (BASE << 9); \ - if (a >= (BASE << 8)) a -= (BASE << 8); \ - if (a >= (BASE << 7)) a -= (BASE << 7); \ - if (a >= (BASE << 6)) a -= (BASE << 6); \ - if (a >= (BASE << 5)) a -= (BASE << 5); \ - if (a >= (BASE << 4)) a -= (BASE << 4); \ - if (a >= (BASE << 3)) a -= (BASE << 3); \ - if (a >= (BASE << 2)) a -= (BASE << 2); \ - if (a >= (BASE << 1)) a -= (BASE << 1); \ - if (a >= BASE) a -= BASE; \ - } while (0) -# define MOD4(a) \ - do { \ - if (a >= (BASE << 4)) a -= (BASE << 4); \ - if (a >= (BASE << 3)) a -= (BASE << 3); \ - if (a >= (BASE << 2)) a -= (BASE << 2); \ - if (a >= (BASE << 1)) a -= (BASE << 1); \ - if (a >= BASE) a -= BASE; \ - } while (0) -#else -# define MOD(a) a %= BASE -# define MOD4(a) a %= BASE -#endif - -/* ========================================================================= */ -uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len) -{ - unsigned long sum2; - unsigned n; - - /* split Adler-32 into component sums */ - sum2 = (adler >> 16) & 0xffff; - adler &= 0xffff; - - /* in case user likes doing a byte at a time, keep it fast */ - if (len == 1) { - adler += buf[0]; - if (adler >= BASE) - adler -= BASE; - sum2 += adler; - if (sum2 >= BASE) - sum2 -= BASE; - return adler | (sum2 << 16); - } - - /* initial Adler-32 value (deferred check for len == 1 speed) */ - if (buf == Z_NULL) - return 1L; - - /* in case short lengths are provided, keep it somewhat fast */ - if (len < 16) { - while (len--) { - adler += *buf++; - sum2 += adler; - } - if (adler >= BASE) - adler -= BASE; - MOD4(sum2); /* only added so many BASE's */ - return adler | (sum2 << 16); - } - - /* do length NMAX blocks -- requires just one modulo operation */ - while (len >= NMAX) { - len -= NMAX; - n = NMAX / 16; /* NMAX is divisible by 16 */ - do { - DO16(buf); /* 16 sums unrolled */ - buf += 16; - } while (--n); - MOD(adler); - MOD(sum2); - } - - /* do remaining bytes (less than NMAX, still just one modulo) */ - if (len) { /* avoid modulos if none remaining */ - while (len >= 16) { - len -= 16; - DO16(buf); - buf += 16; - } - while (len--) { - adler += *buf++; - sum2 += adler; - } - MOD(adler); - MOD(sum2); - } - - /* return recombined sums */ - return adler | (sum2 << 16); -} - -/* ========================================================================= */ -local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) -{ - unsigned long sum1; - unsigned long sum2; - unsigned rem; - - /* the derivation of this formula is left as an exercise for the reader */ - rem = (unsigned)(len2 % BASE); - sum1 = adler1 & 0xffff; - sum2 = rem * sum1; - MOD(sum2); - sum1 += (adler2 & 0xffff) + BASE - 1; - sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; - if (sum1 >= BASE) sum1 -= BASE; - if (sum1 >= BASE) sum1 -= BASE; - if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); - if (sum2 >= BASE) sum2 -= BASE; - return sum1 | (sum2 << 16); -} - -/* ========================================================================= */ -uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2) -{ - return adler32_combine_(adler1, adler2, len2); -} - -uLong ZEXPORT adler32_combine64(uLong adler1, uLong adler2, z_off64_t len2) -{ - return adler32_combine_(adler1, adler2, len2); -} diff --git a/source/libz/compress.c b/source/libz/compress.c deleted file mode 100644 index bfed002..0000000 --- a/source/libz/compress.c +++ /dev/null @@ -1,70 +0,0 @@ -/* compress.c -- compress a memory buffer - * Copyright (C) 1995-2005 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#define ZLIB_INTERNAL -#include "zlib.h" - -/* =========================================================================== - 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 0.1% larger than sourceLen plus - 12 bytes. 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. -*/ -int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) -{ - z_stream stream; - int err; - - stream.next_in = (Bytef*)source; - stream.avail_in = (uInt)sourceLen; -#ifdef MAXSEG_64K - /* Check for source > 64K on 16-bit machine: */ - if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; -#endif - stream.next_out = dest; - stream.avail_out = (uInt)*destLen; - if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; - - stream.zalloc = (alloc_func)0; - stream.zfree = (free_func)0; - stream.opaque = (voidpf)0; - - err = deflateInit(&stream, level); - if (err != Z_OK) return err; - - err = deflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { - deflateEnd(&stream); - return err == Z_OK ? Z_BUF_ERROR : err; - } - *destLen = stream.total_out; - - err = deflateEnd(&stream); - return err; -} - -/* =========================================================================== - */ -int ZEXPORT compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen) -{ - return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); -} - -/* =========================================================================== - If the default memLevel or windowBits for deflateInit() is changed, then - this function needs to be updated. - */ -uLong ZEXPORT compressBound (uLong sourceLen) -{ - return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + - (sourceLen >> 25) + 13; -} diff --git a/source/libz/crc32.c b/source/libz/crc32.c deleted file mode 100644 index 555443f..0000000 --- a/source/libz/crc32.c +++ /dev/null @@ -1,424 +0,0 @@ -/* crc32.c -- compute the CRC-32 of a data stream - * Copyright (C) 1995-2006, 2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - * - * Thanks to Rodney Brown for his contribution of faster - * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing - * tables for updating the shift register in one step with three exclusive-ors - * instead of four steps with four exclusive-ors. This results in about a - * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. - */ - -/* @(#) $Id$ */ - -/* - Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore - protection on the static variables used to control the first-use generation - of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should - first call get_crc_table() to initialize the tables before allowing more than - one thread to use crc32(). - */ - -#ifdef MAKECRCH -# include -# ifndef DYNAMIC_CRC_TABLE -# define DYNAMIC_CRC_TABLE -# endif /* !DYNAMIC_CRC_TABLE */ -#endif /* MAKECRCH */ - -#include "zutil.h" /* for STDC and FAR definitions */ - -#define local static - -/* Find a four-byte integer type for crc32_little() and crc32_big(). */ -#ifndef NOBYFOUR -# ifdef STDC /* need ANSI C limits.h to determine sizes */ -# include -# define BYFOUR -# if (UINT_MAX == 0xffffffffUL) - typedef unsigned int u4; -# else -# if (ULONG_MAX == 0xffffffffUL) - typedef unsigned long u4; -# else -# if (USHRT_MAX == 0xffffffffUL) - typedef unsigned short u4; -# else -# undef BYFOUR /* can't find a four-byte integer type! */ -# endif -# endif -# endif -# endif /* STDC */ -#endif /* !NOBYFOUR */ - -/* Definitions for doing the crc four data bytes at a time. */ -#ifdef BYFOUR -# define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ - (((w)&0xff00)<<8)+(((w)&0xff)<<24)) - local unsigned long crc32_little OF((unsigned long, - const unsigned char FAR *, unsigned)); - local unsigned long crc32_big OF((unsigned long, - const unsigned char FAR *, unsigned)); -# define TBLS 8 -#else -# define TBLS 1 -#endif /* BYFOUR */ - -/* Local functions for crc concatenation */ -local unsigned long gf2_matrix_times OF((unsigned long *mat, - unsigned long vec)); -local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); -local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2); - - -#ifdef DYNAMIC_CRC_TABLE - -local volatile int crc_table_empty = 1; -local unsigned long FAR crc_table[TBLS][256]; -local void make_crc_table OF((void)); -#ifdef MAKECRCH - local void write_table OF((FILE *, const unsigned long FAR *)); -#endif /* MAKECRCH */ -/* - Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: - 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. - - Polynomials over GF(2) are represented in binary, one bit per coefficient, - with the lowest powers in the most significant bit. Then adding polynomials - is just exclusive-or, and multiplying a polynomial by x is a right shift by - one. If we call the above polynomial p, and represent a byte as the - polynomial q, also with the lowest power in the most significant bit (so the - byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, - where a mod b means the remainder after dividing a by b. - - This calculation is done using the shift-register method of multiplying and - taking the remainder. The register is initialized to zero, and for each - incoming bit, x^32 is added mod p to the register if the bit is a one (where - x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by - x (which is shifting right by one and adding x^32 mod p if the bit shifted - out is a one). We start with the highest power (least significant bit) of - q and repeat for all eight bits of q. - - The first table is simply the CRC of all possible eight bit values. This is - all the information needed to generate CRCs on data a byte at a time for all - combinations of CRC register values and incoming bytes. The remaining tables - allow for word-at-a-time CRC calculation for both big-endian and little- - endian machines, where a word is four bytes. -*/ -local void make_crc_table() -{ - unsigned long c; - int n, k; - unsigned long poly; /* polynomial exclusive-or pattern */ - /* terms of polynomial defining this crc (except x^32): */ - static volatile int first = 1; /* flag to limit concurrent making */ - static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; - - /* See if another task is already doing this (not thread-safe, but better - than nothing -- significantly reduces duration of vulnerability in - case the advice about DYNAMIC_CRC_TABLE is ignored) */ - if (first) { - first = 0; - - /* make exclusive-or pattern from polynomial (0xedb88320UL) */ - poly = 0UL; - for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) - poly |= 1UL << (31 - p[n]); - - /* generate a crc for every 8-bit value */ - for (n = 0; n < 256; n++) { - c = (unsigned long)n; - for (k = 0; k < 8; k++) - c = c & 1 ? poly ^ (c >> 1) : c >> 1; - crc_table[0][n] = c; - } - -#ifdef BYFOUR - /* generate crc for each value followed by one, two, and three zeros, - and then the byte reversal of those as well as the first table */ - for (n = 0; n < 256; n++) { - c = crc_table[0][n]; - crc_table[4][n] = REV(c); - for (k = 1; k < 4; k++) { - c = crc_table[0][c & 0xff] ^ (c >> 8); - crc_table[k][n] = c; - crc_table[k + 4][n] = REV(c); - } - } -#endif /* BYFOUR */ - - crc_table_empty = 0; - } - else { /* not first */ - /* wait for the other guy to finish (not efficient, but rare) */ - while (crc_table_empty) - ; - } - -#ifdef MAKECRCH - /* write out CRC tables to crc32.h */ - { - FILE *out; - - out = fopen("crc32.h", "w"); - if (out == NULL) return; - fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); - fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); - fprintf(out, "local const unsigned long FAR "); - fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); - write_table(out, crc_table[0]); -# ifdef BYFOUR - fprintf(out, "#ifdef BYFOUR\n"); - for (k = 1; k < 8; k++) { - fprintf(out, " },\n {\n"); - write_table(out, crc_table[k]); - } - fprintf(out, "#endif\n"); -# endif /* BYFOUR */ - fprintf(out, " }\n};\n"); - fclose(out); - } -#endif /* MAKECRCH */ -} - -#ifdef MAKECRCH -local void write_table(FILE *out, const unsigned long FAR *table) -{ - int n; - - for (n = 0; n < 256; n++) - fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], - n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); -} -#endif /* MAKECRCH */ - -#else /* !DYNAMIC_CRC_TABLE */ -/* ======================================================================== - * Tables of CRC-32s of all single-byte values, made by make_crc_table(). - */ -#include "crc32.h" -#endif /* DYNAMIC_CRC_TABLE */ - -/* ========================================================================= - * This function can be used by asm versions of crc32() - */ -const unsigned long FAR * ZEXPORT get_crc_table() -{ -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ - return (const unsigned long FAR *)crc_table[0]; -} - -/* ========================================================================= */ -#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) -#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 - -/* ========================================================================= */ -unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, uInt len) -{ - if (buf == Z_NULL) - return 0UL; - - #ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); - #endif /* DYNAMIC_CRC_TABLE */ - - #ifdef BYFOUR - // The original code had a check for (sizeof(void*) == sizeof(ptrdiff_t)), - // but that's always true with any modern compiler and it was causing spurious - // compiler warnings related to it being a const conditional expression. - // static_assert((sizeof(void *) == sizeof(ptrdiff_t)); - { - u4 endian = 1; - - if (*((unsigned char *)(&endian))) - return crc32_little(crc, buf, len); - else - return crc32_big(crc, buf, len); - } - #else - crc = crc ^ 0xffffffffUL; - while (len >= 8) { - DO8; - len -= 8; - } - if (len) do { - DO1; - } while (--len); - return crc ^ 0xffffffffUL; - #endif -} - - -#ifdef BYFOUR - -/* ========================================================================= */ -#define DOLIT4 c ^= *buf4++; \ - c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ - crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] -#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 - -/* ========================================================================= */ -local unsigned long crc32_little(unsigned long crc, const unsigned char FAR *buf, unsigned len) -{ - register u4 c; - register const u4 FAR *buf4; - - c = (u4)crc; - c = ~c; - while (len && ((ptrdiff_t)buf & 3)) { - c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); - len--; - } - - buf4 = (const u4 FAR *)(const void FAR *)buf; - while (len >= 32) { - DOLIT32; - len -= 32; - } - while (len >= 4) { - DOLIT4; - len -= 4; - } - buf = (const unsigned char FAR *)buf4; - - if (len) do { - c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); - } while (--len); - c = ~c; - return (unsigned long)c; -} - -/* ========================================================================= */ -#define DOBIG4 c ^= *++buf4; \ - c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ - crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] -#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 - -/* ========================================================================= */ -local unsigned long crc32_big(unsigned long crc, const unsigned char FAR *buf, unsigned len) -{ - register u4 c; - register const u4 FAR *buf4; - - c = REV((u4)crc); - c = ~c; - while (len && ((ptrdiff_t)buf & 3)) { - c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); - len--; - } - - buf4 = (const u4 FAR *)(const void FAR *)buf; - buf4--; - while (len >= 32) { - DOBIG32; - len -= 32; - } - while (len >= 4) { - DOBIG4; - len -= 4; - } - buf4++; - buf = (const unsigned char FAR *)buf4; - - if (len) do { - c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); - } while (--len); - c = ~c; - return (unsigned long)(REV(c)); -} - -#endif /* BYFOUR */ - -#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ - -/* ========================================================================= */ -local unsigned long gf2_matrix_times(unsigned long *mat, unsigned long vec) -{ - unsigned long sum; - - sum = 0; - while (vec) { - if (vec & 1) - sum ^= *mat; - vec >>= 1; - mat++; - } - return sum; -} - -/* ========================================================================= */ -local void gf2_matrix_square(unsigned long *square, unsigned long *mat) -{ - int n; - - for (n = 0; n < GF2_DIM; n++) - square[n] = gf2_matrix_times(mat, mat[n]); -} - -/* ========================================================================= */ -local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2) -{ - int n; - unsigned long row; - unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ - unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ - - /* degenerate case (also disallow negative lengths) */ - if (len2 <= 0) - return crc1; - - /* put operator for one zero bit in odd */ - odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ - row = 1; - for (n = 1; n < GF2_DIM; n++) { - odd[n] = row; - row <<= 1; - } - - /* put operator for two zero bits in even */ - gf2_matrix_square(even, odd); - - /* put operator for four zero bits in odd */ - gf2_matrix_square(odd, even); - - /* apply len2 zeros to crc1 (first square will put the operator for one - zero byte, eight zero bits, in even) */ - do { - /* apply zeros operator for this bit of len2 */ - gf2_matrix_square(even, odd); - if (len2 & 1) - crc1 = gf2_matrix_times(even, crc1); - len2 >>= 1; - - /* if no more bits set, then done */ - if (len2 == 0) - break; - - /* another iteration of the loop with odd and even swapped */ - gf2_matrix_square(odd, even); - if (len2 & 1) - crc1 = gf2_matrix_times(odd, crc1); - len2 >>= 1; - - /* if no more bits set, then done */ - } while (len2 != 0); - - /* return combined crc */ - crc1 ^= crc2; - return crc1; -} - -/* ========================================================================= */ -uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) -{ - return crc32_combine_(crc1, crc2, len2); -} - -uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) -{ - return crc32_combine_(crc1, crc2, len2); -} diff --git a/source/libz/deflate.c b/source/libz/deflate.c deleted file mode 100644 index 97c1bc6..0000000 --- a/source/libz/deflate.c +++ /dev/null @@ -1,1785 +0,0 @@ -/* deflate.c -- compress data using the deflation algorithm - * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * ALGORITHM - * - * The "deflation" process depends on being able to identify portions - * of the input text which are identical to earlier input (within a - * sliding window trailing behind the input currently being processed). - * - * The most straightforward technique turns out to be the fastest for - * most input files: try all possible matches and select the longest. - * The key feature of this algorithm is that insertions into the string - * dictionary are very simple and thus fast, and deletions are avoided - * completely. Insertions are performed at each input character, whereas - * string matches are performed only when the previous match ends. So it - * is preferable to spend more time in matches to allow very fast string - * insertions and avoid deletions. The matching algorithm for small - * strings is inspired from that of Rabin & Karp. A brute force approach - * is used to find longer strings when a small match has been found. - * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze - * (by Leonid Broukhis). - * A previous version of this file used a more sophisticated algorithm - * (by Fiala and Greene) which is guaranteed to run in linear amortized - * time, but has a larger average cost, uses more memory and is patented. - * However the F&G algorithm may be faster for some highly redundant - * files if the parameter max_chain_length (described below) is too large. - * - * ACKNOWLEDGEMENTS - * - * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and - * I found it in 'freeze' written by Leonid Broukhis. - * Thanks to many people for bug reports and testing. - * - * REFERENCES - * - * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". - * Available in http://www.ietf.org/rfc/rfc1951.txt - * - * A description of the Rabin and Karp algorithm is given in the book - * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. - * - * Fiala,E.R., and Greene,D.H. - * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 - * - */ - -/* @(#) $Id$ */ - -#include "deflate.h" - -const char deflate_copyright[] = - " deflate 1.2.5.f-ea Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; -/* - If you use the zlib library in a product, an acknowledgment is welcome - in the documentation of your product. If for some reason you cannot - include such an acknowledgment, I would appreciate that you keep this - copyright string in the executable of your product. - */ - -/* =========================================================================== - * Function prototypes. - */ -typedef enum { - need_more, /* block not completed, need more input or more output */ - block_done, /* block flush performed */ - finish_started, /* finish started, need only more output at next deflate */ - finish_done /* finish done, accept no more input or output */ -} block_state; - -typedef block_state (*compress_func) OF((deflate_state *s, int flush)); -/* Compression function. Returns the block state after the call. */ - -local void fill_window OF((deflate_state *s)); -local block_state deflate_stored OF((deflate_state *s, int flush)); -local block_state deflate_fast OF((deflate_state *s, int flush)); -#ifndef FASTEST -local block_state deflate_slow OF((deflate_state *s, int flush)); -#endif -local block_state deflate_rle OF((deflate_state *s, int flush)); -local block_state deflate_huff OF((deflate_state *s, int flush)); -local void lm_init OF((deflate_state *s)); -local void putShortMSB OF((deflate_state *s, uInt b)); -local void flush_pending OF((z_streamp strm)); -local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); -#ifdef ASMV - void match_init OF((void)); /* asm code initialization */ - uInt longest_match OF((deflate_state *s, IPos cur_match)); -#else -local uInt longest_match OF((deflate_state *s, IPos cur_match)); -#endif - -#ifdef DEBUG -local void check_match OF((deflate_state *s, IPos start, IPos match, - int length)); -#endif - -/* =========================================================================== - * Local data - */ - -#define NIL 0 -/* Tail of hash chains */ - -#ifndef TOO_FAR -# define TOO_FAR 4096 -#endif -/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ - -/* Values for max_lazy_match, good_match and max_chain_length, depending on - * the desired pack level (0..9). The values given below have been tuned to - * exclude worst case performance for pathological files. Better values may be - * found for specific files. - */ -typedef struct config_s { - ush good_length; /* reduce lazy search above this match length */ - ush max_lazy; /* do not perform lazy search above this match length */ - ush nice_length; /* quit search above this match length */ - ush max_chain; - compress_func func; -} config; - -#ifdef FASTEST -local const config configuration_table[2] = { -/* good lazy nice chain */ -/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ -#else -local const config configuration_table[10] = { -/* good lazy nice chain */ -/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ -/* 2 */ {4, 5, 16, 8, deflate_fast}, -/* 3 */ {4, 6, 32, 32, deflate_fast}, - -/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ -/* 5 */ {8, 16, 32, 32, deflate_slow}, -/* 6 */ {8, 16, 128, 128, deflate_slow}, -/* 7 */ {8, 32, 128, 256, deflate_slow}, -/* 8 */ {32, 128, 258, 1024, deflate_slow}, -/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ -#endif - -/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 - * For deflate_fast() (levels <= 3) good is ignored and lazy has a different - * meaning. - */ - -#define EQUAL 0 -/* result of memcmp for equal strings */ - -#ifndef NO_DUMMY_DECL -struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ -#endif - -/* =========================================================================== - * Update a hash value with the given input byte - * IN assertion: all calls to to UPDATE_HASH are made with consecutive - * input characters, so that a running hash key can be computed from the - * previous key instead of complete recalculation each time. - */ -#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) - - -/* =========================================================================== - * Insert string str in the dictionary and set match_head to the previous head - * of the hash chain (the most recent string with same hash key). Return - * the previous length of the hash chain. - * If this file is compiled with -DFASTEST, the compression level is forced - * to 1, and no hash chains are maintained. - * IN assertion: all calls to to INSERT_STRING are made with consecutive - * input characters and the first MIN_MATCH bytes of str are valid - * (except for the last MIN_MATCH-1 bytes of the input file). - */ -#ifdef FASTEST -#define INSERT_STRING(s, str, match_head) \ - (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ - match_head = s->head[s->ins_h], \ - s->head[s->ins_h] = (Pos)(str)) -#else -#define INSERT_STRING(s, str, match_head) \ - (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ - match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ - s->head[s->ins_h] = (Pos)(str)) -#endif - -/* =========================================================================== - * Initialize the hash table (avoiding 64K overflow for 16 bit systems). - * prev[] will be initialized on the fly. - */ -#define CLEAR_HASH(s) \ - s->head[s->hash_size-1] = NIL; \ - zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); - -/* ========================================================================= */ -int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, int stream_size) -{ - return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, - Z_DEFAULT_STRATEGY, version, stream_size); - /* To do: ignore strm->next_in if we use it as window */ -} - -/* ========================================================================= */ -int ZEXPORT deflateInit2_( - z_streamp strm, - int level, - int method, - int windowBits, - int memLevel, - int strategy, - const char *version, - int stream_size) -{ - deflate_state *s; - int wrap = 1; - static const char my_version[] = ZLIB_VERSION; - - ushf *overlay; - /* We overlay pending_buf and d_buf+l_buf. This works since the average - * output size for (length,distance) codes is <= 24 bits. - */ - - if (version == Z_NULL || version[0] != my_version[0] || - stream_size != sizeof(z_stream)) { - return Z_VERSION_ERROR; - } - if (strm == Z_NULL) return Z_STREAM_ERROR; - - strm->msg = Z_NULL; - if (strm->zalloc == (alloc_func)0) { - strm->zalloc = zcalloc; - strm->opaque = (voidpf)0; - } - if (strm->zfree == (free_func)0) strm->zfree = zcfree; - -#ifdef FASTEST - if (level != 0) level = 1; -#else - if (level == Z_DEFAULT_COMPRESSION) level = 6; -#endif - - if (windowBits < 0) { /* suppress zlib wrapper */ - wrap = 0; - windowBits = -windowBits; - } -#ifdef GZIP - else if (windowBits > 15) { - wrap = 2; /* write gzip wrapper instead */ - windowBits -= 16; - } -#endif - if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || - windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || - strategy < 0 || strategy > Z_FIXED) { - return Z_STREAM_ERROR; - } - if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ - s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); - if (s == Z_NULL) return Z_MEM_ERROR; - strm->state = (struct internal_state FAR *)s; - s->strm = strm; - - s->wrap = wrap; - s->gzhead = Z_NULL; - s->w_bits = windowBits; - s->w_size = 1 << s->w_bits; - s->w_mask = s->w_size - 1; - - s->hash_bits = memLevel + 7; - s->hash_size = 1 << s->hash_bits; - s->hash_mask = s->hash_size - 1; - s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); - - s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); - s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); - s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); - - s->high_water = 0; /* nothing written to s->window yet */ - - s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ - - overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); - s->pending_buf = (uchf *) overlay; - s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); - - if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || - s->pending_buf == Z_NULL) { - s->status = FINISH_STATE; - strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); - deflateEnd (strm); - return Z_MEM_ERROR; - } - s->d_buf = overlay + s->lit_bufsize/sizeof(ush); - s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; - - s->level = level; - s->strategy = strategy; - s->method = (Byte)method; - - return deflateReset(strm); -} - -/* ========================================================================= */ -int ZEXPORT deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength) -{ - deflate_state *s; - uInt length = dictLength; - uInt n; - IPos hash_head = 0; - - if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || - strm->state->wrap == 2 || - (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) - return Z_STREAM_ERROR; - - s = strm->state; - if (s->wrap) - strm->adler = adler32(strm->adler, dictionary, dictLength); - - if (length < MIN_MATCH) return Z_OK; - if (length > s->w_size) { - length = s->w_size; - dictionary += dictLength - length; /* use the tail of the dictionary */ - } - zmemcpy(s->window, dictionary, length); - s->strstart = length; - s->block_start = (long)length; - - /* Insert all strings in the hash table (except for the last two bytes). - * s->lookahead stays null, so s->ins_h will be recomputed at the next - * call of fill_window. - */ - s->ins_h = s->window[0]; - UPDATE_HASH(s, s->ins_h, s->window[1]); - for (n = 0; n <= length - MIN_MATCH; n++) { - INSERT_STRING(s, n, hash_head); - } - if (hash_head) hash_head = 0; /* to make compiler happy */ - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflateReset (z_streamp strm) -{ - deflate_state *s; - - if (strm == Z_NULL || strm->state == Z_NULL || - strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { - return Z_STREAM_ERROR; - } - - strm->total_in = strm->total_out = 0; - strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ - strm->data_type = Z_UNKNOWN; - - s = (deflate_state *)strm->state; - s->pending = 0; - s->pending_out = s->pending_buf; - - if (s->wrap < 0) { - s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ - } - s->status = s->wrap ? INIT_STATE : BUSY_STATE; - strm->adler = -#ifdef GZIP - s->wrap == 2 ? crc32(0L, Z_NULL, 0) : -#endif - adler32(0L, Z_NULL, 0); - s->last_flush = Z_NO_FLUSH; - - _tr_init(s); - lm_init(s); - - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflateSetHeader (z_streamp strm, gz_headerp head) -{ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - if (strm->state->wrap != 2) return Z_STREAM_ERROR; - strm->state->gzhead = head; - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflatePrime (z_streamp strm, int bits, int value) -{ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - strm->state->bi_valid = bits; - strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) -{ - deflate_state *s; - compress_func func; - int err = Z_OK; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - s = strm->state; - -#ifdef FASTEST - if (level != 0) level = 1; -#else - if (level == Z_DEFAULT_COMPRESSION) level = 6; -#endif - if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { - return Z_STREAM_ERROR; - } - func = configuration_table[s->level].func; - - if ((strategy != s->strategy || func != configuration_table[level].func) && - strm->total_in != 0) { - /* Flush the last buffer: */ - err = deflate(strm, Z_BLOCK); - } - if (s->level != level) { - s->level = level; - s->max_lazy_match = configuration_table[level].max_lazy; - s->good_match = configuration_table[level].good_length; - s->nice_match = configuration_table[level].nice_length; - s->max_chain_length = configuration_table[level].max_chain; - } - s->strategy = strategy; - return err; -} - -/* ========================================================================= */ -int ZEXPORT deflateTune( - z_streamp strm, - int good_length, - int max_lazy, - int nice_length, - int max_chain) -{ - deflate_state *s; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - s = strm->state; - s->good_match = good_length; - s->max_lazy_match = max_lazy; - s->nice_match = nice_length; - s->max_chain_length = max_chain; - return Z_OK; -} - -/* ========================================================================= - * For the default windowBits of 15 and memLevel of 8, this function returns - * a close to exact, as well as small, upper bound on the compressed size. - * They are coded as constants here for a reason--if the #define's are - * changed, then this function needs to be changed as well. The return - * value for 15 and 8 only works for those exact settings. - * - * For any setting other than those defaults for windowBits and memLevel, - * the value returned is a conservative worst case for the maximum expansion - * resulting from using fixed blocks instead of stored blocks, which deflate - * can emit on compressed data for some combinations of the parameters. - * - * This function could be more sophisticated to provide closer upper bounds for - * every combination of windowBits and memLevel. But even the conservative - * upper bound of about 14% expansion does not seem onerous for output buffer - * allocation. - */ -uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen) -{ - deflate_state *s; - uLong complen, wraplen; - Bytef *str; - - /* conservative upper bound for compressed data */ - complen = sourceLen + - ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; - - /* if can't get parameters, return conservative bound plus zlib wrapper */ - if (strm == Z_NULL || strm->state == Z_NULL) - return complen + 6; - - /* compute wrapper length */ - s = strm->state; - switch (s->wrap) { - case 0: /* raw deflate */ - wraplen = 0; - break; - case 1: /* zlib wrapper */ - wraplen = 6 + (s->strstart ? 4 : 0); - break; - case 2: /* gzip wrapper */ - wraplen = 18; - if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ - if (s->gzhead->extra != Z_NULL) - wraplen += 2 + s->gzhead->extra_len; - str = s->gzhead->name; - if (str != Z_NULL) - do { - wraplen++; - } while (*str++); - str = s->gzhead->comment; - if (str != Z_NULL) - do { - wraplen++; - } while (*str++); - if (s->gzhead->hcrc) - wraplen += 2; - } - break; - default: /* for compiler happiness */ - wraplen = 6; - } - - /* if not default parameters, return conservative bound */ - if (s->w_bits != 15 || s->hash_bits != 8 + 7) - return complen + wraplen; - - /* default settings: return tight bound for that case */ - return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + - (sourceLen >> 25) + 13 - 6 + wraplen; -} - -/* ========================================================================= - * Put a short in the pending buffer. The 16-bit value is put in MSB order. - * IN assertion: the stream state is correct and there is enough room in - * pending_buf. - */ -local void putShortMSB (deflate_state *s, uInt b) -{ - put_byte(s, (Byte)(b >> 8)); - put_byte(s, (Byte)(b & 0xff)); -} - -/* ========================================================================= - * Flush as much pending output as possible. All deflate() output goes - * through this function so some applications may wish to modify it - * to avoid allocating a large strm->next_out buffer and copying into it. - * (See also read_buf()). - */ -local void flush_pending(z_streamp strm) -{ - unsigned len = strm->state->pending; - - if (len > strm->avail_out) len = strm->avail_out; - if (len == 0) return; - - zmemcpy(strm->next_out, strm->state->pending_out, len); - strm->next_out += len; - strm->state->pending_out += len; - strm->total_out += len; - strm->avail_out -= len; - strm->state->pending -= len; - if (strm->state->pending == 0) { - strm->state->pending_out = strm->state->pending_buf; - } -} - -/* ========================================================================= */ -int ZEXPORT deflate (z_streamp strm, int flush) -{ - int old_flush; /* value of flush param for previous deflate call */ - deflate_state *s; - - if (strm == Z_NULL || strm->state == Z_NULL || - flush > Z_BLOCK || flush < 0) { - return Z_STREAM_ERROR; - } - s = strm->state; - - if (strm->next_out == Z_NULL || - (strm->next_in == Z_NULL && strm->avail_in != 0) || - (s->status == FINISH_STATE && flush != Z_FINISH)) { - ERR_RETURN(strm, Z_STREAM_ERROR); - } - if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); - - s->strm = strm; /* just in case */ - old_flush = s->last_flush; - s->last_flush = flush; - - /* Write the header */ - if (s->status == INIT_STATE) { -#ifdef GZIP - if (s->wrap == 2) { - strm->adler = crc32(0L, Z_NULL, 0); - put_byte(s, 31); - put_byte(s, 139); - put_byte(s, 8); - if (s->gzhead == Z_NULL) { - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? - 4 : 0)); - put_byte(s, OS_CODE); - s->status = BUSY_STATE; - } - else { - put_byte(s, (s->gzhead->text ? 1 : 0) + - (s->gzhead->hcrc ? 2 : 0) + - (s->gzhead->extra == Z_NULL ? 0 : 4) + - (s->gzhead->name == Z_NULL ? 0 : 8) + - (s->gzhead->comment == Z_NULL ? 0 : 16) - ); - put_byte(s, (Byte)(s->gzhead->time & 0xff)); - put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); - put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); - put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); - put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? - 4 : 0)); - put_byte(s, s->gzhead->os & 0xff); - if (s->gzhead->extra != Z_NULL) { - put_byte(s, s->gzhead->extra_len & 0xff); - put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); - } - if (s->gzhead->hcrc) - strm->adler = crc32(strm->adler, s->pending_buf, - s->pending); - s->gzindex = 0; - s->status = EXTRA_STATE; - } - } - else -#endif - { - uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; - uInt level_flags; - - if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) - level_flags = 0; - else if (s->level < 6) - level_flags = 1; - else if (s->level == 6) - level_flags = 2; - else - level_flags = 3; - header |= (level_flags << 6); - if (s->strstart != 0) header |= PRESET_DICT; - header += 31 - (header % 31); - - s->status = BUSY_STATE; - putShortMSB(s, header); - - /* Save the adler32 of the preset dictionary: */ - if (s->strstart != 0) { - putShortMSB(s, (uInt)(strm->adler >> 16)); - putShortMSB(s, (uInt)(strm->adler & 0xffff)); - } - strm->adler = adler32(0L, Z_NULL, 0); - } - } -#ifdef GZIP - if (s->status == EXTRA_STATE) { - if (s->gzhead->extra != Z_NULL) { - uInt beg = s->pending; /* start of bytes to update crc */ - - while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { - if (s->pending == s->pending_buf_size) { - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - flush_pending(strm); - beg = s->pending; - if (s->pending == s->pending_buf_size) - break; - } - put_byte(s, s->gzhead->extra[s->gzindex]); - s->gzindex++; - } - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - if (s->gzindex == s->gzhead->extra_len) { - s->gzindex = 0; - s->status = NAME_STATE; - } - } - else - s->status = NAME_STATE; - } - if (s->status == NAME_STATE) { - if (s->gzhead->name != Z_NULL) { - uInt beg = s->pending; /* start of bytes to update crc */ - int val; - - do { - if (s->pending == s->pending_buf_size) { - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - flush_pending(strm); - beg = s->pending; - if (s->pending == s->pending_buf_size) { - val = 1; - break; - } - } - val = s->gzhead->name[s->gzindex++]; - put_byte(s, val); - } while (val != 0); - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - if (val == 0) { - s->gzindex = 0; - s->status = COMMENT_STATE; - } - } - else - s->status = COMMENT_STATE; - } - if (s->status == COMMENT_STATE) { - if (s->gzhead->comment != Z_NULL) { - uInt beg = s->pending; /* start of bytes to update crc */ - int val; - - do { - if (s->pending == s->pending_buf_size) { - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - flush_pending(strm); - beg = s->pending; - if (s->pending == s->pending_buf_size) { - val = 1; - break; - } - } - val = s->gzhead->comment[s->gzindex++]; - put_byte(s, val); - } while (val != 0); - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - if (val == 0) - s->status = HCRC_STATE; - } - else - s->status = HCRC_STATE; - } - if (s->status == HCRC_STATE) { - if (s->gzhead->hcrc) { - if (s->pending + 2 > s->pending_buf_size) - flush_pending(strm); - if (s->pending + 2 <= s->pending_buf_size) { - put_byte(s, (Byte)(strm->adler & 0xff)); - put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); - strm->adler = crc32(0L, Z_NULL, 0); - s->status = BUSY_STATE; - } - } - else - s->status = BUSY_STATE; - } -#endif - - /* Flush as much pending output as possible */ - if (s->pending != 0) { - flush_pending(strm); - if (strm->avail_out == 0) { - /* Since avail_out is 0, deflate will be called again with - * more output space, but possibly with both pending and - * avail_in equal to zero. There won't be anything to do, - * but this is not an error situation so make sure we - * return OK instead of BUF_ERROR at next call of deflate: - */ - s->last_flush = -1; - return Z_OK; - } - - /* Make sure there is something to do and avoid duplicate consecutive - * flushes. For repeated and useless calls with Z_FINISH, we keep - * returning Z_STREAM_END instead of Z_BUF_ERROR. - */ - } else if (strm->avail_in == 0 && flush <= old_flush && - flush != Z_FINISH) { - ERR_RETURN(strm, Z_BUF_ERROR); - } - - /* User must not provide more input after the first FINISH: */ - if (s->status == FINISH_STATE && strm->avail_in != 0) { - ERR_RETURN(strm, Z_BUF_ERROR); - } - - /* Start a new block or continue the current one. - */ - if (strm->avail_in != 0 || s->lookahead != 0 || - (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { - block_state bstate; - - bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : - (s->strategy == Z_RLE ? deflate_rle(s, flush) : - (*(configuration_table[s->level].func))(s, flush)); - - if (bstate == finish_started || bstate == finish_done) { - s->status = FINISH_STATE; - } - if (bstate == need_more || bstate == finish_started) { - if (strm->avail_out == 0) { - s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ - } - return Z_OK; - /* If flush != Z_NO_FLUSH && avail_out == 0, the next call - * of deflate should use the same flush parameter to make sure - * that the flush is complete. So we don't have to output an - * empty block here, this will be done at next call. This also - * ensures that for a very small output buffer, we emit at most - * one empty block. - */ - } - if (bstate == block_done) { - if (flush == Z_PARTIAL_FLUSH) { - _tr_align(s); - } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ - _tr_stored_block(s, (char*)0, 0L, 0); - /* For a full flush, this empty block will be recognized - * as a special marker by inflate_sync(). - */ - if (flush == Z_FULL_FLUSH) { - CLEAR_HASH(s); /* forget history */ - if (s->lookahead == 0) { - s->strstart = 0; - s->block_start = 0L; - } - } - } - flush_pending(strm); - if (strm->avail_out == 0) { - s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ - return Z_OK; - } - } - } - Assert(strm->avail_out > 0, "bug2"); - - if (flush != Z_FINISH) return Z_OK; - if (s->wrap <= 0) return Z_STREAM_END; - - /* Write the trailer */ -#ifdef GZIP - if (s->wrap == 2) { - put_byte(s, (Byte)(strm->adler & 0xff)); - put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); - put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); - put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); - put_byte(s, (Byte)(strm->total_in & 0xff)); - put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); - put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); - put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); - } - else -#endif - { - putShortMSB(s, (uInt)(strm->adler >> 16)); - putShortMSB(s, (uInt)(strm->adler & 0xffff)); - } - flush_pending(strm); - /* If avail_out is zero, the application will call deflate again - * to flush the rest. - */ - if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ - return s->pending != 0 ? Z_OK : Z_STREAM_END; -} - -/* ========================================================================= */ -int ZEXPORT deflateEnd (z_streamp strm) -{ - int status; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - - status = strm->state->status; - if (status != INIT_STATE && - status != EXTRA_STATE && - status != NAME_STATE && - status != COMMENT_STATE && - status != HCRC_STATE && - status != BUSY_STATE && - status != FINISH_STATE) { - return Z_STREAM_ERROR; - } - - /* Deallocate in reverse order of allocations: */ - TRY_FREE(strm, strm->state->pending_buf); - TRY_FREE(strm, strm->state->head); - TRY_FREE(strm, strm->state->prev); - TRY_FREE(strm, strm->state->window); - - ZFREE(strm, strm->state); - strm->state = Z_NULL; - - return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; -} - -/* ========================================================================= - * Copy the source state to the destination state. - * To simplify the source, this is not supported for 16-bit MSDOS (which - * doesn't have enough memory anyway to duplicate compression states). - */ -int ZEXPORT deflateCopy (z_streamp dest, z_streamp source) -{ -#ifdef MAXSEG_64K - return Z_STREAM_ERROR; -#else - deflate_state *ds; - deflate_state *ss; - ushf *overlay; - - - if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { - return Z_STREAM_ERROR; - } - - ss = source->state; - - zmemcpy(dest, source, sizeof(z_stream)); - - ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); - if (ds == Z_NULL) return Z_MEM_ERROR; - dest->state = (struct internal_state FAR *) ds; - zmemcpy(ds, ss, sizeof(deflate_state)); - ds->strm = dest; - - ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); - ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); - ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); - overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); - ds->pending_buf = (uchf *) overlay; - - if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || - ds->pending_buf == Z_NULL) { - deflateEnd (dest); - return Z_MEM_ERROR; - } - /* following zmemcpy do not work for 16-bit MSDOS */ - zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); - zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); - zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); - zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); - - ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); - ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); - ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; - - ds->l_desc.dyn_tree = ds->dyn_ltree; - ds->d_desc.dyn_tree = ds->dyn_dtree; - ds->bl_desc.dyn_tree = ds->bl_tree; - - return Z_OK; -#endif /* MAXSEG_64K */ -} - -/* =========================================================================== - * Read a new buffer from the current input stream, update the adler32 - * and total number of bytes read. All deflate() input goes through - * this function so some applications may wish to modify it to avoid - * allocating a large strm->next_in buffer and copying from it. - * (See also flush_pending()). - */ -local int read_buf(z_streamp strm, Bytef *buf, unsigned size) -{ - unsigned len = strm->avail_in; - - if (len > size) len = size; - if (len == 0) return 0; - - strm->avail_in -= len; - - if (strm->state->wrap == 1) { - strm->adler = adler32(strm->adler, strm->next_in, len); - } -#ifdef GZIP - else if (strm->state->wrap == 2) { - strm->adler = crc32(strm->adler, strm->next_in, len); - } -#endif - zmemcpy(buf, strm->next_in, len); - strm->next_in += len; - strm->total_in += len; - - return (int)len; -} - -/* =========================================================================== - * Initialize the "longest match" routines for a new zlib stream - */ -local void lm_init (deflate_state *s) -{ - s->window_size = (ulg)2L*s->w_size; - - CLEAR_HASH(s); - - /* Set the default configuration parameters: - */ - s->max_lazy_match = configuration_table[s->level].max_lazy; - s->good_match = configuration_table[s->level].good_length; - s->nice_match = configuration_table[s->level].nice_length; - s->max_chain_length = configuration_table[s->level].max_chain; - - s->strstart = 0; - s->block_start = 0L; - s->lookahead = 0; - s->match_length = s->prev_length = MIN_MATCH-1; - s->match_available = 0; - s->ins_h = 0; -#ifndef FASTEST -#ifdef ASMV - match_init(); /* initialize the asm code */ -#endif -#endif -} - -#ifndef FASTEST -/* =========================================================================== - * Set match_start to the longest match starting at the given string and - * return its length. Matches shorter or equal to prev_length are discarded, - * in which case the result is equal to prev_length and match_start is - * garbage. - * IN assertions: cur_match is the head of the hash chain for the current - * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 - * OUT assertion: the match length is not greater than s->lookahead. - */ -#ifndef ASMV -/* For 80x86 and 680x0, an optimized version will be provided in match.asm or - * match.S. The code will be functionally equivalent. - */ -local uInt longest_match(deflate_state *s, IPos cur_match) -{ - unsigned chain_length = s->max_chain_length;/* max hash chain length */ - register Bytef *scan = s->window + s->strstart; /* current string */ - register Bytef *match; /* matched string */ - register int len; /* length of current match */ - int best_len = s->prev_length; /* best match length so far */ - int nice_match = s->nice_match; /* stop if match long enough */ - IPos limit = s->strstart > (IPos)MAX_DIST(s) ? - s->strstart - (IPos)MAX_DIST(s) : NIL; - /* Stop when cur_match becomes <= limit. To simplify the code, - * we prevent matches with the string of window index 0. - */ - Posf *prev = s->prev; - uInt wmask = s->w_mask; - -#ifdef UNALIGNED_OK - /* Compare two bytes at a time. Note: this is not always beneficial. - * Try with and without -DUNALIGNED_OK to check. - */ - register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; - register ush scan_start = *(ushf*)scan; - register ush scan_end = *(ushf*)(scan+best_len-1); -#else - register Bytef *strend = s->window + s->strstart + MAX_MATCH; - register Byte scan_end1 = scan[best_len-1]; - register Byte scan_end = scan[best_len]; -#endif - - /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - * It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - /* Do not waste too much time if we already have a good match: */ - if (s->prev_length >= s->good_match) { - chain_length >>= 2; - } - /* Do not look for matches beyond the end of the input. This is necessary - * to make deflate deterministic. - */ - if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; - - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); - - do { - Assert(cur_match < s->strstart, "no future"); - match = s->window + cur_match; - - /* Skip to next match if the match length cannot increase - * or if the match length is less than 2. Note that the checks below - * for insufficient lookahead only occur occasionally for performance - * reasons. Therefore uninitialized memory will be accessed, and - * conditional jumps will be made that depend on those values. - * However the length of the match is limited to the lookahead, so - * the output of deflate is not affected by the uninitialized values. - */ -#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) - /* This code assumes sizeof(unsigned short) == 2. Do not use - * UNALIGNED_OK if your compiler uses a different size. - */ - if (*(ushf*)(match+best_len-1) != scan_end || - *(ushf*)match != scan_start) continue; - - /* It is not necessary to compare scan[2] and match[2] since they are - * always equal when the other bytes match, given that the hash keys - * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at - * strstart+3, +5, ... up to strstart+257. We check for insufficient - * lookahead only every 4th comparison; the 128th check will be made - * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is - * necessary to put more guard bytes at the end of the window, or - * to check more often for insufficient lookahead. - */ - Assert(scan[2] == match[2], "scan[2]?"); - scan++, match++; - do { - } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - scan < strend); - /* The funny "do {}" generates better code on most compilers */ - - /* Here, scan <= window+strstart+257 */ - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - if (*scan == *match) scan++; - - len = (MAX_MATCH - 1) - (int)(strend-scan); - scan = strend - (MAX_MATCH-1); - -#else /* UNALIGNED_OK */ - - if (match[best_len] != scan_end || - match[best_len-1] != scan_end1 || - *match != *scan || - *++match != scan[1]) continue; - - /* The check at best_len-1 can be removed because it will be made - * again later. (This heuristic is not always a win.) - * It is not necessary to compare scan[2] and match[2] since they - * are always equal when the other bytes match, given that - * the hash keys are equal and that HASH_BITS >= 8. - */ - scan += 2, match++; - Assert(*scan == *match, "match[2]?"); - - /* We check for insufficient lookahead only every 8th comparison; - * the 256th check will be made at strstart+258. - */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); - - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - - len = MAX_MATCH - (int)(strend - scan); - scan = strend - MAX_MATCH; - -#endif /* UNALIGNED_OK */ - - if (len > best_len) { - s->match_start = cur_match; - best_len = len; - if (len >= nice_match) break; -#ifdef UNALIGNED_OK - scan_end = *(ushf*)(scan+best_len-1); -#else - scan_end1 = scan[best_len-1]; - scan_end = scan[best_len]; -#endif - } - } while ((cur_match = prev[cur_match & wmask]) > limit - && --chain_length != 0); - - if ((uInt)best_len <= s->lookahead) return (uInt)best_len; - return s->lookahead; -} -#endif /* ASMV */ - -#else /* FASTEST */ - -/* --------------------------------------------------------------------------- - * Optimized version for FASTEST only - */ -local uInt longest_match(deflate_state *s, IPos cur_match) -{ - register Bytef *scan = s->window + s->strstart; /* current string */ - register Bytef *match; /* matched string */ - register int len; /* length of current match */ - register Bytef *strend = s->window + s->strstart + MAX_MATCH; - - /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - * It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); - - Assert(cur_match < s->strstart, "no future"); - - match = s->window + cur_match; - - /* Return failure if the match length is less than 2: - */ - if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; - - /* The check at best_len-1 can be removed because it will be made - * again later. (This heuristic is not always a win.) - * It is not necessary to compare scan[2] and match[2] since they - * are always equal when the other bytes match, given that - * the hash keys are equal and that HASH_BITS >= 8. - */ - scan += 2, match += 2; - Assert(*scan == *match, "match[2]?"); - - /* We check for insufficient lookahead only every 8th comparison; - * the 256th check will be made at strstart+258. - */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); - - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - - len = MAX_MATCH - (int)(strend - scan); - - if (len < MIN_MATCH) return MIN_MATCH - 1; - - s->match_start = cur_match; - return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; -} - -#endif /* FASTEST */ - -#ifdef DEBUG -/* =========================================================================== - * Check that the match at match_start is indeed a match. - */ -local void check_match(deflate_state *s, IPos start, IPos match, int length) -{ - /* check that the match is indeed a match */ - if (zmemcmp(s->window + match, - s->window + start, length) != EQUAL) { - fprintf(stderr, " start %u, match %u, length %d\n", - start, match, length); - do { - fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); - } while (--length != 0); - z_error("invalid match"); - } - if (z_verbose > 1) { - fprintf(stderr,"\\[%d,%d]", start-match, length); - do { putc(s->window[start++], stderr); } while (--length != 0); - } -} -#else -# define check_match(s, start, match, length) -#endif /* DEBUG */ - -/* =========================================================================== - * Fill the window when the lookahead becomes insufficient. - * Updates strstart and lookahead. - * - * IN assertion: lookahead < MIN_LOOKAHEAD - * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD - * At least one byte has been read, or avail_in == 0; reads are - * performed for at least two bytes (required for the zip translate_eol - * option -- not supported here). - */ -local void fill_window(deflate_state *s) -{ - register unsigned n, m; - register Posf *p; - unsigned more; /* Amount of free space at the end of the window. */ - uInt wsize = s->w_size; - - do { - more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); - - /* Deal with !@#$% 64K limit: */ - if (sizeof(int) <= 2) { - if (more == 0 && s->strstart == 0 && s->lookahead == 0) { - more = wsize; - - } else if (more == (unsigned)(-1)) { - /* Very unlikely, but possible on 16 bit machine if - * strstart == 0 && lookahead == 1 (input done a byte at time) - */ - more--; - } - } - - /* If the window is almost full and there is insufficient lookahead, - * move the upper half to the lower one to make room in the upper half. - */ - if (s->strstart >= wsize+MAX_DIST(s)) { - - zmemcpy(s->window, s->window+wsize, (unsigned)wsize); - s->match_start -= wsize; - s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ - s->block_start -= (long) wsize; - - /* Slide the hash table (could be avoided with 32 bit values - at the expense of memory usage). We slide even when level == 0 - to keep the hash table consistent if we switch back to level > 0 - later. (Using level 0 permanently is not an optimal usage of - zlib, so we don't care about this pathological case.) - */ - n = s->hash_size; - p = &s->head[n]; - do { - m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - } while (--n); - - n = wsize; -#ifndef FASTEST - p = &s->prev[n]; - do { - m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - /* If n is not on any hash chain, prev[n] is garbage but - * its value will never be used. - */ - } while (--n); -#endif - more += wsize; - } - if (s->strm->avail_in == 0) return; - - /* If there was no sliding: - * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - * more == window_size - lookahead - strstart - * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - * => more >= window_size - 2*WSIZE + 2 - * In the BIG_MEM or MMAP case (not yet supported), - * window_size == input_size + MIN_LOOKAHEAD && - * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - * Otherwise, window_size == 2*WSIZE so more >= 2. - * If there was sliding, more >= WSIZE. So in all cases, more >= 2. - */ - Assert(more >= 2, "more < 2"); - - n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); - s->lookahead += n; - - /* Initialize the hash value now that we have some input: */ - if (s->lookahead >= MIN_MATCH) { - s->ins_h = s->window[s->strstart]; - UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); -#if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times -#endif - } - /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, - * but this is not important since only literal bytes will be emitted. - */ - - } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); - - /* If the WIN_INIT bytes after the end of the current data have never been - * written, then zero those bytes in order to avoid memory check reports of - * the use of uninitialized (or uninitialised as Julian writes) bytes by - * the longest match routines. Update the high water mark for the next - * time through here. WIN_INIT is set to MAX_MATCH since the longest match - * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. - */ - if (s->high_water < s->window_size) { - ulg curr = s->strstart + (ulg)(s->lookahead); - ulg init; - - if (s->high_water < curr) { - /* Previous high water mark below current data -- zero WIN_INIT - * bytes or up to end of window, whichever is less. - */ - init = s->window_size - curr; - if (init > WIN_INIT) - init = WIN_INIT; - zmemzero(s->window + curr, (unsigned)init); - s->high_water = curr + init; - } - else if (s->high_water < (ulg)curr + WIN_INIT) { - /* High water mark at or above current data, but below current data - * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up - * to end of window, whichever is less. - */ - init = (ulg)curr + WIN_INIT - s->high_water; - if (init > s->window_size - s->high_water) - init = s->window_size - s->high_water; - zmemzero(s->window + s->high_water, (unsigned)init); - s->high_water += init; - } - } -} - -/* =========================================================================== - * Flush the current block, with given end-of-file flag. - * IN assertion: strstart is set to the end of the current match. - */ -#define FLUSH_BLOCK_ONLY(s, last) { \ - _tr_flush_block(s, (s->block_start >= 0L ? \ - (charf *)&s->window[(unsigned)s->block_start] : \ - (charf *)Z_NULL), \ - (ulg)((long)s->strstart - s->block_start), \ - (last)); \ - s->block_start = s->strstart; \ - flush_pending(s->strm); \ - Tracev((stderr,"[FLUSH]")); \ -} - -/* Same but force premature exit if necessary. */ -#define FLUSH_BLOCK(s, last) { \ - FLUSH_BLOCK_ONLY(s, last); \ - if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ -} - -/* =========================================================================== - * Copy without compression as much as possible from the input stream, return - * the current block state. - * This function does not insert new strings in the dictionary since - * uncompressible data is probably not useful. This function is used - * only for the level=0 compression option. - * NOTE: this function should be optimized to avoid extra copying from - * window to pending_buf. - */ -local block_state deflate_stored(deflate_state *s, int flush) -{ - /* Stored blocks are limited to 0xffff bytes, pending_buf is limited - * to pending_buf_size, and each stored block has a 5 byte header: - */ - ulg max_block_size = 0xffff; - ulg max_start; - - if (max_block_size > s->pending_buf_size - 5) { - max_block_size = s->pending_buf_size - 5; - } - - /* Copy as much as possible from input to output: */ - for (;;) { - /* Fill the window as much as possible: */ - if (s->lookahead <= 1) { - - Assert(s->strstart < s->w_size+MAX_DIST(s) || - s->block_start >= (long)s->w_size, "slide too late"); - - fill_window(s); - if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; - - if (s->lookahead == 0) break; /* flush the current block */ - } - Assert(s->block_start >= 0L, "block gone"); - - s->strstart += s->lookahead; - s->lookahead = 0; - - /* Emit a stored block if pending_buf will be full: */ - max_start = s->block_start + max_block_size; - if (s->strstart == 0 || (ulg)s->strstart >= max_start) { - /* strstart == 0 is possible when wraparound on 16-bit machine */ - s->lookahead = (uInt)(s->strstart - max_start); - s->strstart = (uInt)max_start; - FLUSH_BLOCK(s, 0); - } - /* Flush if we may have to slide, otherwise block_start may become - * negative and the data will be gone: - */ - if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { - FLUSH_BLOCK(s, 0); - } - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} - -/* =========================================================================== - * Compress as much as possible from the input stream, return the current - * block state. - * This function does not perform lazy evaluation of matches and inserts - * new strings in the dictionary only for unmatched strings or for short - * matches. It is used only for the fast compression options. - */ -local block_state deflate_fast(deflate_state *s, int flush) -{ - IPos hash_head; /* head of the hash chain */ - int bflush; /* set if current block must be flushed */ - - for (;;) { - /* Make sure that we always have enough lookahead, except - * at the end of the input file. We need MAX_MATCH bytes - * for the next match, plus MIN_MATCH bytes to insert the - * string following the next match. - */ - if (s->lookahead < MIN_LOOKAHEAD) { - fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { - return need_more; - } - if (s->lookahead == 0) break; /* flush the current block */ - } - - /* Insert the string window[strstart .. strstart+2] in the - * dictionary, and set hash_head to the head of the hash chain: - */ - hash_head = NIL; - if (s->lookahead >= MIN_MATCH) { - INSERT_STRING(s, s->strstart, hash_head); - } - - /* Find the longest match, discarding those <= prev_length. - * At this point we have always match_length < MIN_MATCH - */ - if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { - /* To simplify the code, we prevent matches with the string - * of window index 0 (in particular we have to avoid a match - * of the string with itself at the start of the input file). - */ - s->match_length = longest_match (s, hash_head); - /* longest_match() sets match_start */ - } - if (s->match_length >= MIN_MATCH) { - check_match(s, s->strstart, s->match_start, s->match_length); - - _tr_tally_dist(s, s->strstart - s->match_start, - s->match_length - MIN_MATCH, bflush); - - s->lookahead -= s->match_length; - - /* Insert new strings in the hash table only if the match length - * is not too large. This saves time but degrades compression. - */ -#ifndef FASTEST - if (s->match_length <= s->max_insert_length && - s->lookahead >= MIN_MATCH) { - s->match_length--; /* string at strstart already in table */ - do { - s->strstart++; - INSERT_STRING(s, s->strstart, hash_head); - /* strstart never exceeds WSIZE-MAX_MATCH, so there are - * always MIN_MATCH bytes ahead. - */ - } while (--s->match_length != 0); - s->strstart++; - } else -#endif - { - s->strstart += s->match_length; - s->match_length = 0; - s->ins_h = s->window[s->strstart]; - UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); -#if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times -#endif - /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not - * matter since it will be recomputed at next deflate call. - */ - } - } else { - /* No match, output a literal byte */ - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); - s->lookahead--; - s->strstart++; - } - if (bflush) FLUSH_BLOCK(s, 0); - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} - -#ifndef FASTEST -/* =========================================================================== - * Same as above, but achieves better compression. We use a lazy - * evaluation for matches: a match is finally adopted only if there is - * no better match at the next window position. - */ -local block_state deflate_slow(deflate_state *s, int flush) -{ - IPos hash_head; /* head of hash chain */ - int bflush; /* set if current block must be flushed */ - - /* Process the input block. */ - for (;;) { - /* Make sure that we always have enough lookahead, except - * at the end of the input file. We need MAX_MATCH bytes - * for the next match, plus MIN_MATCH bytes to insert the - * string following the next match. - */ - if (s->lookahead < MIN_LOOKAHEAD) { - fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { - return need_more; - } - if (s->lookahead == 0) break; /* flush the current block */ - } - - /* Insert the string window[strstart .. strstart+2] in the - * dictionary, and set hash_head to the head of the hash chain: - */ - hash_head = NIL; - if (s->lookahead >= MIN_MATCH) { - INSERT_STRING(s, s->strstart, hash_head); - } - - /* Find the longest match, discarding those <= prev_length. - */ - s->prev_length = s->match_length, s->prev_match = s->match_start; - s->match_length = MIN_MATCH-1; - - if (hash_head != NIL && s->prev_length < s->max_lazy_match && - s->strstart - hash_head <= MAX_DIST(s)) { - /* To simplify the code, we prevent matches with the string - * of window index 0 (in particular we have to avoid a match - * of the string with itself at the start of the input file). - */ - s->match_length = longest_match (s, hash_head); - /* longest_match() sets match_start */ - - if (s->match_length <= 5 && (s->strategy == Z_FILTERED -#if TOO_FAR <= 32767 - || (s->match_length == MIN_MATCH && - s->strstart - s->match_start > TOO_FAR) -#endif - )) { - - /* If prev_match is also MIN_MATCH, match_start is garbage - * but we will ignore the current match anyway. - */ - s->match_length = MIN_MATCH-1; - } - } - /* If there was a match at the previous step and the current - * match is not better, output the previous match: - */ - if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { - uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; - /* Do not insert strings in hash table beyond this. */ - - check_match(s, s->strstart-1, s->prev_match, s->prev_length); - - _tr_tally_dist(s, s->strstart -1 - s->prev_match, - s->prev_length - MIN_MATCH, bflush); - - /* Insert in hash table all strings up to the end of the match. - * strstart-1 and strstart are already inserted. If there is not - * enough lookahead, the last two strings are not inserted in - * the hash table. - */ - s->lookahead -= s->prev_length-1; - s->prev_length -= 2; - do { - if (++s->strstart <= max_insert) { - INSERT_STRING(s, s->strstart, hash_head); - } - } while (--s->prev_length != 0); - s->match_available = 0; - s->match_length = MIN_MATCH-1; - s->strstart++; - - if (bflush) FLUSH_BLOCK(s, 0); - - } else if (s->match_available) { - /* If there was no match at the previous position, output a - * single literal. If there was a match but the current match - * is longer, truncate the previous match to a single literal. - */ - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); - if (bflush) { - FLUSH_BLOCK_ONLY(s, 0); - } - s->strstart++; - s->lookahead--; - if (s->strm->avail_out == 0) return need_more; - } else { - /* There is no previous match to compare with, wait for - * the next step to decide. - */ - s->match_available = 1; - s->strstart++; - s->lookahead--; - } - } - Assert (flush != Z_NO_FLUSH, "no flush?"); - if (s->match_available) { - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); - s->match_available = 0; - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} -#endif /* FASTEST */ - -/* =========================================================================== - * For Z_RLE, simply look for runs of bytes, generate matches only of distance - * one. Do not maintain a hash table. (It will be regenerated if this run of - * deflate switches away from Z_RLE.) - */ -local block_state deflate_rle(deflate_state *s, int flush) -{ - int bflush; /* set if current block must be flushed */ - uInt prev; /* byte at distance one to match */ - Bytef *scan, *strend; /* scan goes up to strend for length of run */ - - for (;;) { - /* Make sure that we always have enough lookahead, except - * at the end of the input file. We need MAX_MATCH bytes - * for the longest encodable run. - */ - if (s->lookahead < MAX_MATCH) { - fill_window(s); - if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { - return need_more; - } - if (s->lookahead == 0) break; /* flush the current block */ - } - - /* See how many times the previous byte repeats */ - s->match_length = 0; - if (s->lookahead >= MIN_MATCH && s->strstart > 0) { - scan = s->window + s->strstart - 1; - prev = *scan; - if (prev == *++scan && prev == *++scan && prev == *++scan) { - strend = s->window + s->strstart + MAX_MATCH; - do { - } while (prev == *++scan && prev == *++scan && - prev == *++scan && prev == *++scan && - prev == *++scan && prev == *++scan && - prev == *++scan && prev == *++scan && - scan < strend); - s->match_length = MAX_MATCH - (int)(strend - scan); - if (s->match_length > s->lookahead) - s->match_length = s->lookahead; - } - } - - /* Emit match if have run of MIN_MATCH or longer, else emit literal */ - if (s->match_length >= MIN_MATCH) { - check_match(s, s->strstart, s->strstart - 1, s->match_length); - - _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); - - s->lookahead -= s->match_length; - s->strstart += s->match_length; - s->match_length = 0; - } else { - /* No match, output a literal byte */ - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); - s->lookahead--; - s->strstart++; - } - if (bflush) FLUSH_BLOCK(s, 0); - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} - -/* =========================================================================== - * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. - * (It will be regenerated if this run of deflate switches away from Huffman.) - */ -local block_state deflate_huff(deflate_state *s, int flush) -{ - int bflush; /* set if current block must be flushed */ - - for (;;) { - /* Make sure that we have a literal to write. */ - if (s->lookahead == 0) { - fill_window(s); - if (s->lookahead == 0) { - if (flush == Z_NO_FLUSH) - return need_more; - break; /* flush the current block */ - } - } - - /* Output a literal byte */ - s->match_length = 0; - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); - s->lookahead--; - s->strstart++; - if (bflush) FLUSH_BLOCK(s, 0); - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} diff --git a/source/libz/infback.c b/source/libz/infback.c deleted file mode 100644 index 5e57e78..0000000 --- a/source/libz/infback.c +++ /dev/null @@ -1,625 +0,0 @@ -/* infback.c -- inflate using a call-back interface - * Copyright (C) 1995-2009 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - This code is largely copied from inflate.c. Normally either infback.o or - inflate.o would be linked into an application--not both. The interface - with inffast.c is retained so that optimized assembler-coded versions of - inflate_fast() can be used with either inflate.c or infback.c. - */ - -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" -#include "inffast.h" - -/* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); - -/* - strm provides memory allocation functions in zalloc and zfree, or - Z_NULL to use the library memory allocation functions. - - windowBits is in the range 8..15, and window is a user-supplied - window and output buffer that is 2**windowBits bytes. - */ -int ZEXPORT inflateBackInit_( - z_streamp strm, - int windowBits, - unsigned char FAR *window, - const char *version, - int stream_size) -{ - struct inflate_state FAR *state; - - if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || - stream_size != (int)(sizeof(z_stream))) - return Z_VERSION_ERROR; - if (strm == Z_NULL || window == Z_NULL || - windowBits < 8 || windowBits > 15) - return Z_STREAM_ERROR; - strm->msg = Z_NULL; /* in case we return an error */ - if (strm->zalloc == (alloc_func)0) { - strm->zalloc = zcalloc; - strm->opaque = (voidpf)0; - } - if (strm->zfree == (free_func)0) strm->zfree = zcfree; - state = (struct inflate_state FAR *)ZALLOC(strm, 1, - sizeof(struct inflate_state)); - if (state == Z_NULL) return Z_MEM_ERROR; - Tracev((stderr, "inflate: allocated\n")); - strm->state = (struct internal_state FAR *)state; - state->dmax = 32768U; - state->wbits = windowBits; - state->wsize = 1U << windowBits; - state->window = window; - state->wnext = 0; - state->whave = 0; - return Z_OK; -} - -/* - Return state with length and distance decoding tables and index sizes set to - fixed code decoding. Normally this returns fixed tables from inffixed.h. - If BUILDFIXED is defined, then instead this routine builds the tables the - first time it's called, and returns those tables the first time and - thereafter. This reduces the size of the code by about 2K bytes, in - exchange for a little execution time. However, BUILDFIXED should not be - used for threaded applications, since the rewriting of the tables and virgin - may not be thread-safe. - */ -local void fixedtables(struct inflate_state FAR *state) -{ -#ifdef BUILDFIXED - static int virgin = 1; - static code *lenfix, *distfix; - static code fixed[544]; - - /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { - unsigned sym, bits; - static code *next; - - /* literal/length table */ - sym = 0; - while (sym < 144) state->lens[sym++] = 8; - while (sym < 256) state->lens[sym++] = 9; - while (sym < 280) state->lens[sym++] = 7; - while (sym < 288) state->lens[sym++] = 8; - next = fixed; - lenfix = next; - bits = 9; - inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); - - /* distance table */ - sym = 0; - while (sym < 32) state->lens[sym++] = 5; - distfix = next; - bits = 5; - inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); - - /* do this just once */ - virgin = 0; - } -#else /* !BUILDFIXED */ -# include "inffixed.h" -#endif /* BUILDFIXED */ - state->lencode = lenfix; - state->lenbits = 9; - state->distcode = distfix; - state->distbits = 5; -} - -/* Macros for inflateBack(): */ - -/* Load returned state from inflate_fast() */ -#define LOAD() \ - do { \ - put = strm->next_out; \ - left = strm->avail_out; \ - next = strm->next_in; \ - have = strm->avail_in; \ - hold = state->hold; \ - bits = state->bits; \ - } while (0) - -/* Set state from registers for inflate_fast() */ -#define RESTORE() \ - do { \ - strm->next_out = put; \ - strm->avail_out = left; \ - strm->next_in = next; \ - strm->avail_in = have; \ - state->hold = hold; \ - state->bits = bits; \ - } while (0) - -/* Clear the input bit accumulator */ -#define INITBITS() \ - do { \ - hold = 0; \ - bits = 0; \ - } while (0) - -/* Assure that some input is available. If input is requested, but denied, - then return a Z_BUF_ERROR from inflateBack(). */ -#define PULL() \ - do { \ - if (have == 0) { \ - have = in(in_desc, &next); \ - if (have == 0) { \ - next = Z_NULL; \ - ret = Z_BUF_ERROR; \ - goto inf_leave; \ - } \ - } \ - } while (0) - -/* Get a byte of input into the bit accumulator, or return from inflateBack() - with an error if there is no input available. */ -#define PULLBYTE() \ - do { \ - PULL(); \ - have--; \ - hold += (unsigned long)(*next++) << bits; \ - bits += 8; \ - } while (0) - -/* Assure that there are at least n bits in the bit accumulator. If there is - not enough available input to do that, then return from inflateBack() with - an error. */ -#define NEEDBITS(n) \ - do { \ - while (bits < (unsigned)(n)) \ - PULLBYTE(); \ - } while (0) - -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - ((unsigned)hold & ((1U << (n)) - 1)) - -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) - -/* Remove zero to seven bits as needed to go to a byte boundary */ -#define BYTEBITS() \ - do { \ - hold >>= bits & 7; \ - bits -= bits & 7; \ - } while (0) - -/* Assure that some output space is available, by writing out the window - if it's full. If the write fails, return from inflateBack() with a - Z_BUF_ERROR. */ -#define ROOM() \ - do { \ - if (left == 0) { \ - put = state->window; \ - left = state->wsize; \ - state->whave = left; \ - if (out(out_desc, put, left)) { \ - ret = Z_BUF_ERROR; \ - goto inf_leave; \ - } \ - } \ - } while (0) - -/* - strm provides the memory allocation functions and window buffer on input, - and provides information on the unused input on return. For Z_DATA_ERROR - returns, strm will also provide an error message. - - in() and out() are the call-back input and output functions. When - inflateBack() needs more input, it calls in(). When inflateBack() has - filled the window with output, or when it completes with data in the - window, it calls out() to write out the data. The application must not - change the provided input until in() is called again or inflateBack() - returns. The application must not change the window/output buffer until - inflateBack() returns. - - in() and out() are called with a descriptor parameter provided in the - inflateBack() call. This parameter can be a structure that provides the - information required to do the read or write, as well as accumulated - information on the input and output such as totals and check values. - - in() should return zero on failure. out() should return non-zero on - failure. If either in() or out() fails, than inflateBack() returns a - Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it - was in() or out() that caused in the error. Otherwise, inflateBack() - returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format - error, or Z_MEM_ERROR if it could not allocate memory for the state. - inflateBack() can also return Z_STREAM_ERROR if the input parameters - are not correct, i.e. strm is Z_NULL or the state was not initialized. - */ -int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc) -{ - struct inflate_state FAR *state; - unsigned char FAR *next; /* next input */ - unsigned char FAR *put; /* next output */ - unsigned have, left; /* available input and output */ - unsigned long hold; /* bit buffer */ - unsigned bits; /* bits in bit buffer */ - unsigned copy; /* number of stored or match bytes to copy */ - unsigned char FAR *from; /* where to copy match bytes from */ - code here; /* current decoding table entry */ - code last; /* parent table entry */ - unsigned len; /* length to copy for repeats, bits to drop */ - int ret; /* return code */ - static const unsigned short order[19] = /* permutation of code lengths */ - {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; - - /* Check that the strm exists and that the state was initialized */ - if (strm == Z_NULL || strm->state == Z_NULL) - return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - - /* Reset the state */ - strm->msg = Z_NULL; - state->mode = TYPE; - state->last = 0; - state->whave = 0; - next = strm->next_in; - have = next != Z_NULL ? strm->avail_in : 0; - hold = 0; - bits = 0; - put = state->window; - left = state->wsize; - - /* Inflate until end of block marked as last */ - for (;;) - switch (state->mode) { - case TYPE: - /* determine and dispatch block type */ - if (state->last) { - BYTEBITS(); - state->mode = DONE; - break; - } - NEEDBITS(3); - state->last = BITS(1); - DROPBITS(1); - switch (BITS(2)) { - case 0: /* stored block */ - Tracev((stderr, "inflate: stored block%s\n", - state->last ? " (last)" : "")); - state->mode = STORED; - break; - case 1: /* fixed block */ - fixedtables(state); - Tracev((stderr, "inflate: fixed codes block%s\n", - state->last ? " (last)" : "")); - state->mode = LEN; /* decode codes */ - break; - case 2: /* dynamic block */ - Tracev((stderr, "inflate: dynamic codes block%s\n", - state->last ? " (last)" : "")); - state->mode = TABLE; - break; - case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; - } - DROPBITS(2); - break; - - case STORED: - /* get and verify stored block length */ - BYTEBITS(); /* go to byte boundary */ - NEEDBITS(32); - if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; - break; - } - state->length = (unsigned)hold & 0xffff; - Tracev((stderr, "inflate: stored length %u\n", - state->length)); - INITBITS(); - - /* copy stored block from input to output */ - while (state->length != 0) { - copy = state->length; - PULL(); - ROOM(); - if (copy > have) copy = have; - if (copy > left) copy = left; - zmemcpy(put, next, copy); - have -= copy; - next += copy; - left -= copy; - put += copy; - state->length -= copy; - } - Tracev((stderr, "inflate: stored end\n")); - state->mode = TYPE; - break; - - case TABLE: - /* get dynamic table entries descriptor */ - NEEDBITS(14); - state->nlen = BITS(5) + 257; - DROPBITS(5); - state->ndist = BITS(5) + 1; - DROPBITS(5); - state->ncode = BITS(4) + 4; - DROPBITS(4); -#ifndef PKZIP_BUG_WORKAROUND - if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; - break; - } -#endif - Tracev((stderr, "inflate: table sizes ok\n")); - - /* get code length code lengths (not a typo) */ - state->have = 0; - while (state->have < state->ncode) { - NEEDBITS(3); - state->lens[order[state->have++]] = (unsigned short)BITS(3); - DROPBITS(3); - } - while (state->have < 19) - state->lens[order[state->have++]] = 0; - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: code lengths ok\n")); - - /* get length and distance code code lengths */ - state->have = 0; - while (state->have < state->nlen + state->ndist) { - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if (here.val < 16) { - NEEDBITS(here.bits); - DROPBITS(here.bits); - state->lens[state->have++] = here.val; - } - else { - if (here.val == 16) { - NEEDBITS(here.bits + 2); - DROPBITS(here.bits); - if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - len = (unsigned)(state->lens[state->have - 1]); - copy = 3 + BITS(2); - DROPBITS(2); - } - else if (here.val == 17) { - NEEDBITS(here.bits + 3); - DROPBITS(here.bits); - len = 0; - copy = 3 + BITS(3); - DROPBITS(3); - } - else { - NEEDBITS(here.bits + 7); - DROPBITS(here.bits); - len = 0; - copy = 11 + BITS(7); - DROPBITS(7); - } - if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - while (copy--) - state->lens[state->have++] = (unsigned short)len; - } - } - - /* handle error breaks in while */ - if (state->mode == BAD) break; - - /* check for end-of-block code (better have one) */ - if (state->lens[256] == 0) { - strm->msg = (char *)"invalid code -- missing end-of-block"; - state->mode = BAD; - break; - } - - /* build code tables -- note: do not change the lenbits or distbits - values here (9 and 6) without reading the comments in inftrees.h - concerning the ENOUGH constants, which depend on those values */ - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; - break; - } - state->distcode = (code const FAR *)(state->next); - state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, - &(state->next), &(state->distbits), state->work); - if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: codes ok\n")); - state->mode = LEN; - - case LEN: - /* use inflate_fast() if we have enough input and output */ - if (have >= 6 && left >= 258) { - RESTORE(); - if (state->whave < state->wsize) - state->whave = state->wsize - left; - inflate_fast(strm, state->wsize); - LOAD(); - break; - } - - /* get a literal, length, or end-of-block code */ - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if (here.op && (here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - } - DROPBITS(here.bits); - state->length = (unsigned)here.val; - - /* process literal */ - if (here.op == 0) { - Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", here.val)); - ROOM(); - *put++ = (unsigned char)(state->length); - left--; - state->mode = LEN; - break; - } - - /* process end of block */ - if (here.op & 32) { - Tracevv((stderr, "inflate: end of block\n")); - state->mode = TYPE; - break; - } - - /* invalid code */ - if (here.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - - /* length code -- get extra bits, if any */ - state->extra = (unsigned)(here.op) & 15; - if (state->extra != 0) { - NEEDBITS(state->extra); - state->length += BITS(state->extra); - DROPBITS(state->extra); - } - Tracevv((stderr, "inflate: length %u\n", state->length)); - - /* get distance code */ - for (;;) { - here = state->distcode[BITS(state->distbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if ((here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->distcode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - } - DROPBITS(here.bits); - if (here.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - state->offset = (unsigned)here.val; - - /* get distance extra bits, if any */ - state->extra = (unsigned)(here.op) & 15; - if (state->extra != 0) { - NEEDBITS(state->extra); - state->offset += BITS(state->extra); - DROPBITS(state->extra); - } - if (state->offset > state->wsize - (state->whave < state->wsize ? - left : 0)) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } - Tracevv((stderr, "inflate: distance %u\n", state->offset)); - - /* copy match from window to output */ - do { - ROOM(); - copy = state->wsize - state->offset; - if (copy < left) { - from = put + copy; - copy = left - copy; - } - else { - from = put - state->offset; - copy = left; - } - if (copy > state->length) copy = state->length; - state->length -= copy; - left -= copy; - do { - *put++ = *from++; - } while (--copy); - } while (state->length != 0); - break; - - case DONE: - /* inflate stream terminated properly -- write leftover output */ - ret = Z_STREAM_END; - if (left < state->wsize) { - if (out(out_desc, state->window, state->wsize - left)) - ret = Z_BUF_ERROR; - } - goto inf_leave; - - case BAD: - ret = Z_DATA_ERROR; - goto inf_leave; - - default: /* can't happen, but makes compilers happy */ - ret = Z_STREAM_ERROR; - goto inf_leave; - } - - /* Return unused input */ - inf_leave: - strm->next_in = next; - strm->avail_in = have; - return ret; -} - -int ZEXPORT inflateBackEnd(z_streamp strm) -{ - if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) - return Z_STREAM_ERROR; - ZFREE(strm, strm->state); - strm->state = Z_NULL; - Tracev((stderr, "inflate: end\n")); - return Z_OK; -} diff --git a/source/libz/inffast.c b/source/libz/inffast.c deleted file mode 100644 index d685e98..0000000 --- a/source/libz/inffast.c +++ /dev/null @@ -1,343 +0,0 @@ -/* inffast.c -- fast decoding - * Copyright (C) 1995-2008, 2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" -#include "inffast.h" - -#ifndef ASMINF - -/* Allow machine dependent optimization for post-increment or pre-increment. - Based on testing to date, - Pre-increment preferred for: - - PowerPC G3 (Adler) - - MIPS R5000 (Randers-Pehrson) - Post-increment preferred for: - - none - No measurable difference: - - Pentium III (Anderson) - - M68060 (Nikl) - */ -#ifdef POSTINC -# define OFF 0 -# define PUP(a) *(a)++ -#else -# define OFF 1 -# define PUP(a) *++(a) -#endif - -/* - Decode literal, length, and distance codes and write out the resulting - literal and match bytes until either not enough input or output is - available, an end-of-block is encountered, or a data error is encountered. - When large enough input and output buffers are supplied to inflate(), for - example, a 16K input buffer and a 64K output buffer, more than 95% of the - inflate execution time is spent in this routine. - - Entry assumptions: - - state->mode == LEN - strm->avail_in >= 6 - strm->avail_out >= 258 - start >= strm->avail_out - state->bits < 8 - - On return, state->mode is one of: - - LEN -- ran out of enough output space or enough available input - TYPE -- reached end of block code, inflate() to interpret next block - BAD -- error in block data - - Notes: - - - The maximum input bits used by a length/distance pair is 15 bits for the - length code, 5 bits for the length extra, 15 bits for the distance code, - and 13 bits for the distance extra. This totals 48 bits, or six bytes. - Therefore if strm->avail_in >= 6, then there is enough input to avoid - checking for available input while decoding. - - - The maximum bytes that a single length/distance pair can output is 258 - bytes, which is the maximum length that can be coded. inflate_fast() - requires strm->avail_out >= 258 for each loop to avoid checking for - output space. - */ - -// \param start - inflate()'s starting value for strm->avail_out - -void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start) -{ - struct inflate_state FAR *state; - unsigned char FAR *in; /* local strm->next_in */ - unsigned char FAR *last; /* while in < last, enough input available */ - unsigned char FAR *out; /* local strm->next_out */ - unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ - unsigned char FAR *end; /* while out < end, enough space available */ -#ifdef INFLATE_STRICT - unsigned dmax; /* maximum distance from zlib header */ -#endif - unsigned wsize; /* window size or zero if not using window */ - unsigned whave; /* valid bytes in the window */ - unsigned wnext; /* window write index */ - unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ - unsigned long hold; /* local strm->hold */ - unsigned bits; /* local strm->bits */ - code const FAR *lcode; /* local strm->lencode */ - code const FAR *dcode; /* local strm->distcode */ - unsigned lmask; /* mask for first level of length codes */ - unsigned dmask; /* mask for first level of distance codes */ - code const * here; /* retrieved table entry */ - unsigned op; /* code bits, operation, extra bits, or */ - /* window position, window bytes to copy */ - unsigned len; /* match length, unused bytes */ - unsigned dist; /* match distance */ - unsigned char FAR *from; /* where to copy match from */ - - /* copy state to local variables */ - state = (struct inflate_state FAR *)strm->state; - in = strm->next_in - OFF; - last = in + (strm->avail_in - 5); - out = strm->next_out - OFF; - beg = out - (start - strm->avail_out); - end = out + (strm->avail_out - 257); -#ifdef INFLATE_STRICT - dmax = state->dmax; -#endif - wsize = state->wsize; - whave = state->whave; - wnext = state->wnext; - window = state->window; - hold = state->hold; - bits = state->bits; - lcode = state->lencode; - dcode = state->distcode; - lmask = (1U << state->lenbits) - 1; - dmask = (1U << state->distbits) - 1; - - /* decode literals and length/distances until end-of-block or not enough - input data or output space */ - do { - if (bits < 15) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - here = lcode + (hold & lmask); - dolen: - op = (unsigned)(here->bits); - hold >>= op; - bits -= op; - op = (unsigned)(here->op); - if (op == 0) { /* literal */ - Tracevv((stderr, here->val >= 0x20 && here->val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", here->val)); - PUP(out) = (unsigned char)(here->val); - } - else if (op & 16) { /* length base */ - len = (unsigned)(here->val); - op &= 15; /* number of extra bits */ - if (op) { - if (bits < op) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - len += (unsigned)hold & ((1U << op) - 1); - hold >>= op; - bits -= op; - } - Tracevv((stderr, "inflate: length %u\n", len)); - if (bits < 15) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - here = dcode + (hold & dmask); - dodist: - op = (unsigned)(here->bits); - hold >>= op; - bits -= op; - op = (unsigned)(here->op); - if (op & 16) { /* distance base */ - dist = (unsigned)(here->val); - op &= 15; /* number of extra bits */ - if (bits < op) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - if (bits < op) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - } - dist += (unsigned)hold & ((1U << op) - 1); -#ifdef INFLATE_STRICT - if (dist > dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } -#endif - hold >>= op; - bits -= op; - Tracevv((stderr, "inflate: distance %u\n", dist)); - op = (unsigned)(out - beg); /* max distance in output */ - if (dist > op) { /* see if copy from window */ - op = dist - op; /* distance back in window */ - if (op > whave) { - if (state->sane) { - strm->msg = - (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } -#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR - if (len <= op - whave) { - do { - PUP(out) = 0; - } while (--len); - continue; - } - len -= op - whave; - do { - PUP(out) = 0; - } while (--op > whave); - if (op == 0) { - from = out - dist; - do { - PUP(out) = PUP(from); - } while (--len); - continue; - } -#endif - } - from = window - OFF; - if (wnext == 0) { /* very common case */ - from += wsize - op; - if (op < len) { /* some from window */ - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = out - dist; /* rest from output */ - } - } - else if (wnext < op) { /* wrap around window */ - from += wsize + wnext - op; - op -= wnext; - if (op < len) { /* some from end of window */ - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = window - OFF; - if (wnext < len) { /* some from start of window */ - op = wnext; - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = out - dist; /* rest from output */ - } - } - } - else { /* contiguous in window */ - from += wnext - op; - if (op < len) { /* some from window */ - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = out - dist; /* rest from output */ - } - } - while (len > 2) { - PUP(out) = PUP(from); - PUP(out) = PUP(from); - PUP(out) = PUP(from); - len -= 3; - } - if (len) { - PUP(out) = PUP(from); - if (len > 1) - PUP(out) = PUP(from); - } - } - else { - from = out - dist; /* copy direct from output */ - do { /* minimum length is three */ - PUP(out) = PUP(from); - PUP(out) = PUP(from); - PUP(out) = PUP(from); - len -= 3; - } while (len > 2); - if (len) { - PUP(out) = PUP(from); - if (len > 1) - PUP(out) = PUP(from); - } - } - } - else if ((op & 64) == 0) { /* 2nd level distance code */ - here = dcode + (here->val + (hold & ((1U << op) - 1))); - goto dodist; - } - else { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - } - else if ((op & 64) == 0) { /* 2nd level length code */ - here = lcode + (here->val + (hold & ((1U << op) - 1))); - goto dolen; - } - else if (op & 32) { /* end-of-block */ - Tracevv((stderr, "inflate: end of block\n")); - state->mode = TYPE; - break; - } - else { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - } while (in < last && out < end); - - /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ - len = bits >> 3; - in -= len; - bits -= len << 3; - hold &= (1U << bits) - 1; - - /* update state and return */ - strm->next_in = in + OFF; - strm->next_out = out + OFF; - strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); - strm->avail_out = (unsigned)(out < end ? - 257 + (end - out) : 257 - (out - end)); - state->hold = hold; - state->bits = bits; - return; -} - -/* - inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): - - Using bit fields for code structure - - Different op definition to avoid & for extra bits (do & for table bits) - - Three separate decoding do-loops for direct, window, and wnext == 0 - - Special case for distance > 1 copies to do overlapped load and store copy - - Explicit branch predictions (based on measured branch probabilities) - - Deferring match copy and interspersed it with decoding subsequent codes - - Swapping literal/length else - - Swapping window/direct else - - Larger unrolled copy loops (three is about right) - - Moving len -= 3 statement into middle of loop - */ - -#endif /* !ASMINF */ - - diff --git a/source/libz/inflate.c b/source/libz/inflate.c deleted file mode 100644 index c991207..0000000 --- a/source/libz/inflate.c +++ /dev/null @@ -1,1446 +0,0 @@ -/* inflate.c -- zlib decompression - * Copyright (C) 1995-2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * Change history: - * - * 1.2.beta0 24 Nov 2002 - * - First version -- complete rewrite of inflate to simplify code, avoid - * creation of window when not needed, minimize use of window when it is - * needed, make inffast.c even faster, implement gzip decoding, and to - * improve code readability and style over the previous zlib inflate code - * - * 1.2.beta1 25 Nov 2002 - * - Use pointers for available input and output checking in inffast.c - * - Remove input and output counters in inffast.c - * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 - * - Remove unnecessary second byte pull from length extra in inffast.c - * - Unroll direct copy to three copies per loop in inffast.c - * - * 1.2.beta2 4 Dec 2002 - * - Change external routine names to reduce potential conflicts - * - Correct filename to inffixed.h for fixed tables in inflate.c - * - Make hbuf[] unsigned char to match parameter type in inflate.c - * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) - * to avoid negation problem on Alphas (64 bit) in inflate.c - * - * 1.2.beta3 22 Dec 2002 - * - Add comments on state->bits assertion in inffast.c - * - Add comments on op field in inftrees.h - * - Fix bug in reuse of allocated window after inflateReset() - * - Remove bit fields--back to byte structure for speed - * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths - * - Change post-increments to pre-increments in inflate_fast(), PPC biased? - * - Add compile time option, POSTINC, to use post-increments instead (Intel?) - * - Make MATCH copy in inflate() much faster for when inflate_fast() not used - * - Use local copies of stream next and avail values, as well as local bit - * buffer and bit count in inflate()--for speed when inflate_fast() not used - * - * 1.2.beta4 1 Jan 2003 - * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings - * - Move a comment on output buffer sizes from inffast.c to inflate.c - * - Add comments in inffast.c to introduce the inflate_fast() routine - * - Rearrange window copies in inflate_fast() for speed and simplification - * - Unroll last copy for window match in inflate_fast() - * - Use local copies of window variables in inflate_fast() for speed - * - Pull out common wnext == 0 case for speed in inflate_fast() - * - Make op and len in inflate_fast() unsigned for consistency - * - Add FAR to lcode and dcode declarations in inflate_fast() - * - Simplified bad distance check in inflate_fast() - * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new - * source file infback.c to provide a call-back interface to inflate for - * programs like gzip and unzip -- uses window as output buffer to avoid - * window copying - * - * 1.2.beta5 1 Jan 2003 - * - Improved inflateBack() interface to allow the caller to provide initial - * input in strm. - * - Fixed stored blocks bug in inflateBack() - * - * 1.2.beta6 4 Jan 2003 - * - Added comments in inffast.c on effectiveness of POSTINC - * - Typecasting all around to reduce compiler warnings - * - Changed loops from while (1) or do {} while (1) to for (;;), again to - * make compilers happy - * - Changed type of window in inflateBackInit() to unsigned char * - * - * 1.2.beta7 27 Jan 2003 - * - Changed many types to unsigned or unsigned short to avoid warnings - * - Added inflateCopy() function - * - * 1.2.0 9 Mar 2003 - * - Changed inflateBack() interface to provide separate opaque descriptors - * for the in() and out() functions - * - Changed inflateBack() argument and in_func typedef to swap the length - * and buffer address return values for the input function - * - Check next_in and next_out for Z_NULL on entry to inflate() - * - * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. - */ - -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" -#include "inffast.h" - -#ifdef MAKEFIXED -# ifndef BUILDFIXED -# define BUILDFIXED -# endif -#endif - -/* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); -local int updatewindow OF((z_streamp strm, unsigned out)); -#ifdef BUILDFIXED - void makefixed OF((void)); -#endif -local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, - unsigned len)); - -int ZEXPORT inflateReset(z_streamp strm) -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - strm->total_in = strm->total_out = state->total = 0; - strm->msg = Z_NULL; - strm->adler = 1; /* to support ill-conceived Java test suite */ - state->mode = HEAD; - state->last = 0; - state->havedict = 0; - state->dmax = 32768U; - state->head = Z_NULL; - state->wsize = 0; - state->whave = 0; - state->wnext = 0; - state->hold = 0; - state->bits = 0; - state->lencode = state->distcode = state->next = state->codes; - state->sane = 1; - state->back = -1; - Tracev((stderr, "inflate: reset\n")); - return Z_OK; -} - -int ZEXPORT inflateReset2(z_streamp strm, int windowBits) -{ - int wrap; - struct inflate_state FAR *state; - - /* get the state */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - - /* extract wrap request from windowBits parameter */ - if (windowBits < 0) { - wrap = 0; - windowBits = -windowBits; - } - else { - wrap = (windowBits >> 4) + 1; -#ifdef GUNZIP - if (windowBits < 48) - windowBits &= 15; -#endif - } - - /* set number of window bits, free window if different */ - if (windowBits && (windowBits < 8 || windowBits > 15)) - return Z_STREAM_ERROR; - if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { - ZFREE(strm, state->window); - state->window = Z_NULL; - } - - /* update state and reset the rest of it */ - state->wrap = wrap; - state->wbits = (unsigned)windowBits; - return inflateReset(strm); -} - -int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char *version, int stream_size) -{ - int ret; - struct inflate_state FAR *state; - - if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || - stream_size != (int)(sizeof(z_stream))) - return Z_VERSION_ERROR; - if (strm == Z_NULL) return Z_STREAM_ERROR; - strm->msg = Z_NULL; /* in case we return an error */ - if (strm->zalloc == (alloc_func)0) { - strm->zalloc = zcalloc; - strm->opaque = (voidpf)0; - } - if (strm->zfree == (free_func)0) strm->zfree = zcfree; - state = (struct inflate_state FAR *) - ZALLOC(strm, 1, sizeof(struct inflate_state)); - if (state == Z_NULL) return Z_MEM_ERROR; - Tracev((stderr, "inflate: allocated\n")); - strm->state = (struct internal_state FAR *)state; - state->window = Z_NULL; - ret = inflateReset2(strm, windowBits); - if (ret != Z_OK) { - ZFREE(strm, state); - strm->state = Z_NULL; - } - return ret; -} - -int ZEXPORT inflateInit_(z_streamp strm, const char *version, int stream_size) -{ - return inflateInit2_(strm, DEF_WBITS, version, stream_size); -} - -int ZEXPORT inflatePrime(z_streamp strm, int bits, int value) -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (bits < 0) { - state->hold = 0; - state->bits = 0; - return Z_OK; - } - if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; - value &= (1L << bits) - 1; - state->hold += value << state->bits; - state->bits += bits; - return Z_OK; -} - -/* - Return state with length and distance decoding tables and index sizes set to - fixed code decoding. Normally this returns fixed tables from inffixed.h. - If BUILDFIXED is defined, then instead this routine builds the tables the - first time it's called, and returns those tables the first time and - thereafter. This reduces the size of the code by about 2K bytes, in - exchange for a little execution time. However, BUILDFIXED should not be - used for threaded applications, since the rewriting of the tables and virgin - may not be thread-safe. - */ -local void fixedtables(struct inflate_state FAR *state) -{ -#ifdef BUILDFIXED - static int virgin = 1; - static code *lenfix, *distfix; - static code fixed[544]; - - /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { - unsigned sym, bits; - static code *next; - - /* literal/length table */ - sym = 0; - while (sym < 144) state->lens[sym++] = 8; - while (sym < 256) state->lens[sym++] = 9; - while (sym < 280) state->lens[sym++] = 7; - while (sym < 288) state->lens[sym++] = 8; - next = fixed; - lenfix = next; - bits = 9; - inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); - - /* distance table */ - sym = 0; - while (sym < 32) state->lens[sym++] = 5; - distfix = next; - bits = 5; - inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); - - /* do this just once */ - virgin = 0; - } -#else /* !BUILDFIXED */ -# include "inffixed.h" -#endif /* BUILDFIXED */ - state->lencode = lenfix; - state->lenbits = 9; - state->distcode = distfix; - state->distbits = 5; -} - -#ifdef MAKEFIXED -#include - -/* - Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also - defines BUILDFIXED, so the tables are built on the fly. makefixed() writes - those tables to stdout, which would be piped to inffixed.h. A small program - can simply call makefixed to do this: - - void makefixed(void); - - int main(void) - { - makefixed(); - return 0; - } - - Then that can be linked with zlib built with MAKEFIXED defined and run: - - a.out > inffixed.h - */ -void makefixed() -{ - unsigned low, size; - struct inflate_state state; - - fixedtables(&state); - puts(" /* inffixed.h -- table for decoding fixed codes"); - puts(" * Generated automatically by makefixed()."); - puts(" */"); - puts(""); - puts(" /* WARNING: this file should *not* be used by applications."); - puts(" It is part of the implementation of this library and is"); - puts(" subject to change. Applications should only use zlib.h."); - puts(" */"); - puts(""); - size = 1U << 9; - printf(" static const code lenfix[%u] = {", size); - low = 0; - for (;;) { - if ((low % 7) == 0) printf("\n "); - printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, - state.lencode[low].val); - if (++low == size) break; - putchar(','); - } - puts("\n };"); - size = 1U << 5; - printf("\n static const code distfix[%u] = {", size); - low = 0; - for (;;) { - if ((low % 6) == 0) printf("\n "); - printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, - state.distcode[low].val); - if (++low == size) break; - putchar(','); - } - puts("\n };"); -} -#endif /* MAKEFIXED */ - -/* - Update the window with the last wsize (normally 32K) bytes written before - returning. If window does not exist yet, create it. This is only called - when a window is already in use, or when output has been written during this - inflate call, but the end of the deflate stream has not been reached yet. - It is also called to create a window for dictionary data when a dictionary - is loaded. - - Providing output buffers larger than 32K to inflate() should provide a speed - advantage, since only the last 32K of output is copied to the sliding window - upon return from inflate(), and since all distances after the first 32K of - output will fall in the output data, making match copies simpler and faster. - The advantage may be dependent on the size of the processor's data caches. - */ -local int updatewindow(z_streamp strm, unsigned out) -{ - struct inflate_state FAR *state; - unsigned copy, dist; - - state = (struct inflate_state FAR *)strm->state; - - /* if it hasn't been done already, allocate space for the window */ - if (state->window == Z_NULL) { - state->window = (unsigned char FAR *) - ZALLOC(strm, 1U << state->wbits, - sizeof(unsigned char)); - if (state->window == Z_NULL) return 1; - } - - /* if window not in use yet, initialize */ - if (state->wsize == 0) { - state->wsize = 1U << state->wbits; - state->wnext = 0; - state->whave = 0; - } - - /* copy state->wsize or less output bytes into the circular window */ - copy = out - strm->avail_out; - if (copy >= state->wsize) { - zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); - state->wnext = 0; - state->whave = state->wsize; - } - else { - dist = state->wsize - state->wnext; - if (dist > copy) dist = copy; - zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); - copy -= dist; - if (copy) { - zmemcpy(state->window, strm->next_out - copy, copy); - state->wnext = copy; - state->whave = state->wsize; - } - else { - state->wnext += dist; - if (state->wnext == state->wsize) state->wnext = 0; - if (state->whave < state->wsize) state->whave += dist; - } - } - return 0; -} - -/* Macros for inflate(): */ - -/* check function to use adler32() for zlib or crc32() for gzip */ -#ifdef GUNZIP -# define UPDATE(check, buf, len) \ - (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) -#else -# define UPDATE(check, buf, len) adler32(check, buf, len) -#endif - -/* check macros for header crc */ -#ifdef GUNZIP -# define CRC2(check, word) \ - do { \ - hbuf[0] = (unsigned char)(word); \ - hbuf[1] = (unsigned char)((word) >> 8); \ - check = crc32(check, hbuf, 2); \ - } while (0) - -# define CRC4(check, word) \ - do { \ - hbuf[0] = (unsigned char)(word); \ - hbuf[1] = (unsigned char)((word) >> 8); \ - hbuf[2] = (unsigned char)((word) >> 16); \ - hbuf[3] = (unsigned char)((word) >> 24); \ - check = crc32(check, hbuf, 4); \ - } while (0) -#endif - -/* Load registers with state in inflate() for speed */ -#define LOAD() \ - do { \ - put = strm->next_out; \ - left = strm->avail_out; \ - next = strm->next_in; \ - have = strm->avail_in; \ - hold = state->hold; \ - bits = state->bits; \ - } while (0) - -/* Restore state from registers in inflate() */ -#define RESTORE() \ - do { \ - strm->next_out = put; \ - strm->avail_out = left; \ - strm->next_in = next; \ - strm->avail_in = have; \ - state->hold = hold; \ - state->bits = bits; \ - } while (0) - -/* Clear the input bit accumulator */ -#define INITBITS() \ - do { \ - hold = 0; \ - bits = 0; \ - } while (0) - -/* Get a byte of input into the bit accumulator, or return from inflate() - if there is no input available. */ -#define PULLBYTE() \ - do { \ - if (have == 0) goto inf_leave; \ - have--; \ - hold += (unsigned long)(*next++) << bits; \ - bits += 8; \ - } while (0) - -/* Assure that there are at least n bits in the bit accumulator. If there is - not enough available input to do that, then return from inflate(). */ -#define NEEDBITS(n) \ - do { \ - while (bits < (unsigned)(n)) \ - PULLBYTE(); \ - } while (0) - -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - ((unsigned)hold & ((1U << (n)) - 1)) - -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) - -/* Remove zero to seven bits as needed to go to a byte boundary */ -#define BYTEBITS() \ - do { \ - hold >>= bits & 7; \ - bits -= bits & 7; \ - } while (0) - -/* Reverse the bytes in a 32-bit value */ -#define REVERSE(q) \ - ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ - (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) - -/* - inflate() uses a state machine to process as much input data and generate as - much output data as possible before returning. The state machine is - structured roughly as follows: - - for (;;) switch (state) { - ... - case STATEn: - if (not enough input data or output space to make progress) - return; - ... make progress ... - state = STATEm; - break; - ... - } - - so when inflate() is called again, the same case is attempted again, and - if the appropriate resources are provided, the machine proceeds to the - next state. The NEEDBITS() macro is usually the way the state evaluates - whether it can proceed or should return. NEEDBITS() does the return if - the requested bits are not available. The typical use of the BITS macros - is: - - NEEDBITS(n); - ... do something with BITS(n) ... - DROPBITS(n); - - where NEEDBITS(n) either returns from inflate() if there isn't enough - input left to load n bits into the accumulator, or it continues. BITS(n) - gives the low n bits in the accumulator. When done, DROPBITS(n) drops - the low n bits off the accumulator. INITBITS() clears the accumulator - and sets the number of available bits to zero. BYTEBITS() discards just - enough bits to put the accumulator on a byte boundary. After BYTEBITS() - and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. - - NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return - if there is no input available. The decoding of variable length codes uses - PULLBYTE() directly in order to pull just enough bytes to decode the next - code, and no more. - - Some states loop until they get enough input, making sure that enough - state information is maintained to continue the loop where it left off - if NEEDBITS() returns in the loop. For example, want, need, and keep - would all have to actually be part of the saved state in case NEEDBITS() - returns: - - case STATEw: - while (want < need) { - NEEDBITS(n); - keep[want++] = BITS(n); - DROPBITS(n); - } - state = STATEx; - case STATEx: - - As shown above, if the next state is also the next case, then the break - is omitted. - - A state may also return if there is not enough output space available to - complete that state. Those states are copying stored data, writing a - literal byte, and copying a matching string. - - When returning, a "goto inf_leave" is used to update the total counters, - update the check value, and determine whether any progress has been made - during that inflate() call in order to return the proper return code. - Progress is defined as a change in either strm->avail_in or strm->avail_out. - When there is a window, goto inf_leave will update the window with the last - output written. If a goto inf_leave occurs in the middle of decompression - and there is no window currently, goto inf_leave will create one and copy - output to the window for the next call of inflate(). - - In this implementation, the flush parameter of inflate() only affects the - return code (per zlib.h). inflate() always writes as much as possible to - strm->next_out, given the space available and the provided input--the effect - documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers - the allocation of and copying into a sliding window until necessary, which - provides the effect documented in zlib.h for Z_FINISH when the entire input - stream available. So the only thing the flush parameter actually does is: - when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it - will return Z_BUF_ERROR if it has not reached the end of the stream. - */ - -int ZEXPORT inflate(z_streamp strm, int flush) -{ - struct inflate_state FAR *state; - unsigned char FAR *next; /* next input */ - unsigned char FAR *put; /* next output */ - unsigned have, left; /* available input and output */ - unsigned long hold; /* bit buffer */ - unsigned bits; /* bits in bit buffer */ - unsigned in, out; /* save starting available input and output */ - unsigned copy; /* number of stored or match bytes to copy */ - unsigned char FAR *from; /* where to copy match bytes from */ - code here; /* current decoding table entry */ - code last; /* parent table entry */ - unsigned len; /* length to copy for repeats, bits to drop */ - int ret; /* return code */ -#ifdef GUNZIP - unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ -#endif - static const unsigned short order[19] = /* permutation of code lengths */ - {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; - - if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || - (strm->next_in == Z_NULL && strm->avail_in != 0)) - return Z_STREAM_ERROR; - - state = (struct inflate_state FAR *)strm->state; - if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ - LOAD(); - in = have; - out = left; - ret = Z_OK; - for (;;) - switch (state->mode) { - case HEAD: - if (state->wrap == 0) { - state->mode = TYPEDO; - break; - } - NEEDBITS(16); -#ifdef GUNZIP - if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ - state->check = crc32(0L, Z_NULL, 0); - CRC2(state->check, hold); - INITBITS(); - state->mode = FLAGS; - break; - } - state->flags = 0; /* expect zlib header */ - if (state->head != Z_NULL) - state->head->done = -1; - if (!(state->wrap & 1) || /* check if zlib header allowed */ -#else - if ( -#endif - ((BITS(8) << 8) + (hold >> 8)) % 31) { - strm->msg = (char *)"incorrect header check"; - state->mode = BAD; - break; - } - if (BITS(4) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; - break; - } - DROPBITS(4); - len = BITS(4) + 8; - if (state->wbits == 0) - state->wbits = len; - else if (len > state->wbits) { - strm->msg = (char *)"invalid window size"; - state->mode = BAD; - break; - } - state->dmax = 1U << len; - Tracev((stderr, "inflate: zlib header ok\n")); - strm->adler = state->check = adler32(0L, Z_NULL, 0); - state->mode = hold & 0x200 ? DICTID : TYPE; - INITBITS(); - break; -#ifdef GUNZIP - case FLAGS: - NEEDBITS(16); - state->flags = (int)(hold); - if ((state->flags & 0xff) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; - break; - } - if (state->flags & 0xe000) { - strm->msg = (char *)"unknown header flags set"; - state->mode = BAD; - break; - } - if (state->head != Z_NULL) - state->head->text = (int)((hold >> 8) & 1); - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - state->mode = TIME; - case TIME: - NEEDBITS(32); - if (state->head != Z_NULL) - state->head->time = hold; - if (state->flags & 0x0200) CRC4(state->check, hold); - INITBITS(); - state->mode = OS; - case OS: - NEEDBITS(16); - if (state->head != Z_NULL) { - state->head->xflags = (int)(hold & 0xff); - state->head->os = (int)(hold >> 8); - } - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - state->mode = EXLEN; - case EXLEN: - if (state->flags & 0x0400) { - NEEDBITS(16); - state->length = (unsigned)(hold); - if (state->head != Z_NULL) - state->head->extra_len = (unsigned)hold; - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - } - else if (state->head != Z_NULL) - state->head->extra = Z_NULL; - state->mode = EXTRA; - case EXTRA: - if (state->flags & 0x0400) { - copy = state->length; - if (copy > have) copy = have; - if (copy) { - if (state->head != Z_NULL && - state->head->extra != Z_NULL) { - len = state->head->extra_len - state->length; - zmemcpy(state->head->extra + len, next, - len + copy > state->head->extra_max ? - state->head->extra_max - len : copy); - } - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - state->length -= copy; - } - if (state->length) goto inf_leave; - } - state->length = 0; - state->mode = NAME; - case NAME: - if (state->flags & 0x0800) { - if (have == 0) goto inf_leave; - copy = 0; - do { - len = (unsigned)(next[copy++]); - if (state->head != Z_NULL && - state->head->name != Z_NULL && - state->length < state->head->name_max) - state->head->name[state->length++] = len; - } while (len && copy < have); - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - if (len) goto inf_leave; - } - else if (state->head != Z_NULL) - state->head->name = Z_NULL; - state->length = 0; - state->mode = COMMENT; - case COMMENT: - if (state->flags & 0x1000) { - if (have == 0) goto inf_leave; - copy = 0; - do { - len = (unsigned)(next[copy++]); - if (state->head != Z_NULL && - state->head->comment != Z_NULL && - state->length < state->head->comm_max) - state->head->comment[state->length++] = len; - } while (len && copy < have); - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - if (len) goto inf_leave; - } - else if (state->head != Z_NULL) - state->head->comment = Z_NULL; - state->mode = HCRC; - case HCRC: - if (state->flags & 0x0200) { - NEEDBITS(16); - if (hold != (state->check & 0xffff)) { - strm->msg = (char *)"header crc mismatch"; - state->mode = BAD; - break; - } - INITBITS(); - } - if (state->head != Z_NULL) { - state->head->hcrc = (int)((state->flags >> 9) & 1); - state->head->done = 1; - } - strm->adler = state->check = crc32(0L, Z_NULL, 0); - state->mode = TYPE; - break; -#endif - case DICTID: - NEEDBITS(32); - strm->adler = state->check = REVERSE(hold); - INITBITS(); - state->mode = DICT; - case DICT: - if (state->havedict == 0) { - RESTORE(); - return Z_NEED_DICT; - } - strm->adler = state->check = adler32(0L, Z_NULL, 0); - state->mode = TYPE; - case TYPE: - if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; - case TYPEDO: - if (state->last) { - BYTEBITS(); - state->mode = CHECK; - break; - } - NEEDBITS(3); - state->last = BITS(1); - DROPBITS(1); - switch (BITS(2)) { - case 0: /* stored block */ - Tracev((stderr, "inflate: stored block%s\n", - state->last ? " (last)" : "")); - state->mode = STORED; - break; - case 1: /* fixed block */ - fixedtables(state); - Tracev((stderr, "inflate: fixed codes block%s\n", - state->last ? " (last)" : "")); - state->mode = LEN_; /* decode codes */ - if (flush == Z_TREES) { - DROPBITS(2); - goto inf_leave; - } - break; - case 2: /* dynamic block */ - Tracev((stderr, "inflate: dynamic codes block%s\n", - state->last ? " (last)" : "")); - state->mode = TABLE; - break; - case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; - } - DROPBITS(2); - break; - case STORED: - BYTEBITS(); /* go to byte boundary */ - NEEDBITS(32); - if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; - break; - } - state->length = (unsigned)hold & 0xffff; - Tracev((stderr, "inflate: stored length %u\n", - state->length)); - INITBITS(); - state->mode = COPY_; - if (flush == Z_TREES) goto inf_leave; - case COPY_: - state->mode = COPY; - case COPY: - copy = state->length; - if (copy) { - if (copy > have) copy = have; - if (copy > left) copy = left; - if (copy == 0) goto inf_leave; - zmemcpy(put, next, copy); - have -= copy; - next += copy; - left -= copy; - put += copy; - state->length -= copy; - break; - } - Tracev((stderr, "inflate: stored end\n")); - state->mode = TYPE; - break; - case TABLE: - NEEDBITS(14); - state->nlen = BITS(5) + 257; - DROPBITS(5); - state->ndist = BITS(5) + 1; - DROPBITS(5); - state->ncode = BITS(4) + 4; - DROPBITS(4); -#ifndef PKZIP_BUG_WORKAROUND - if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; - break; - } -#endif - Tracev((stderr, "inflate: table sizes ok\n")); - state->have = 0; - state->mode = LENLENS; - case LENLENS: - while (state->have < state->ncode) { - NEEDBITS(3); - state->lens[order[state->have++]] = (unsigned short)BITS(3); - DROPBITS(3); - } - while (state->have < 19) - state->lens[order[state->have++]] = 0; - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: code lengths ok\n")); - state->have = 0; - state->mode = CODELENS; - case CODELENS: - while (state->have < state->nlen + state->ndist) { - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if (here.val < 16) { - NEEDBITS(here.bits); - DROPBITS(here.bits); - state->lens[state->have++] = here.val; - } - else { - if (here.val == 16) { - NEEDBITS(here.bits + 2); - DROPBITS(here.bits); - if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - len = state->lens[state->have - 1]; - copy = 3 + BITS(2); - DROPBITS(2); - } - else if (here.val == 17) { - NEEDBITS(here.bits + 3); - DROPBITS(here.bits); - len = 0; - copy = 3 + BITS(3); - DROPBITS(3); - } - else { - NEEDBITS(here.bits + 7); - DROPBITS(here.bits); - len = 0; - copy = 11 + BITS(7); - DROPBITS(7); - } - if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - while (copy--) - state->lens[state->have++] = (unsigned short)len; - } - } - - /* handle error breaks in while */ - if (state->mode == BAD) break; - - /* check for end-of-block code (better have one) */ - if (state->lens[256] == 0) { - strm->msg = (char *)"invalid code -- missing end-of-block"; - state->mode = BAD; - break; - } - - /* build code tables -- note: do not change the lenbits or distbits - values here (9 and 6) without reading the comments in inftrees.h - concerning the ENOUGH constants, which depend on those values */ - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; - break; - } - state->distcode = (code const FAR *)(state->next); - state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, - &(state->next), &(state->distbits), state->work); - if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: codes ok\n")); - state->mode = LEN_; - if (flush == Z_TREES) goto inf_leave; - case LEN_: - state->mode = LEN; - case LEN: - if (have >= 6 && left >= 258) { - RESTORE(); - inflate_fast(strm, out); - LOAD(); - if (state->mode == TYPE) - state->back = -1; - break; - } - state->back = 0; - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if (here.op && (here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - state->back += last.bits; - } - DROPBITS(here.bits); - state->back += here.bits; - state->length = (unsigned)here.val; - if ((int)(here.op) == 0) { - Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", here.val)); - state->mode = LIT; - break; - } - if (here.op & 32) { - Tracevv((stderr, "inflate: end of block\n")); - state->back = -1; - state->mode = TYPE; - break; - } - if (here.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - state->extra = (unsigned)(here.op) & 15; - state->mode = LENEXT; - case LENEXT: - if (state->extra) { - NEEDBITS(state->extra); - state->length += BITS(state->extra); - DROPBITS(state->extra); - state->back += state->extra; - } - Tracevv((stderr, "inflate: length %u\n", state->length)); - state->was = state->length; - state->mode = DIST; - case DIST: - for (;;) { - here = state->distcode[BITS(state->distbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if ((here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->distcode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - state->back += last.bits; - } - DROPBITS(here.bits); - state->back += here.bits; - if (here.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - state->offset = (unsigned)here.val; - state->extra = (unsigned)(here.op) & 15; - state->mode = DISTEXT; - case DISTEXT: - if (state->extra) { - NEEDBITS(state->extra); - state->offset += BITS(state->extra); - DROPBITS(state->extra); - state->back += state->extra; - } -#ifdef INFLATE_STRICT - if (state->offset > state->dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } -#endif - Tracevv((stderr, "inflate: distance %u\n", state->offset)); - state->mode = MATCH; - case MATCH: - if (left == 0) goto inf_leave; - copy = out - left; - if (state->offset > copy) { /* copy from window */ - copy = state->offset - copy; - if (copy > state->whave) { - if (state->sane) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } -#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR - Trace((stderr, "inflate.c too far\n")); - copy -= state->whave; - if (copy > state->length) copy = state->length; - if (copy > left) copy = left; - left -= copy; - state->length -= copy; - do { - *put++ = 0; - } while (--copy); - if (state->length == 0) state->mode = LEN; - break; -#endif - } - if (copy > state->wnext) { - copy -= state->wnext; - from = state->window + (state->wsize - copy); - } - else - from = state->window + (state->wnext - copy); - if (copy > state->length) copy = state->length; - } - else { /* copy from output */ - from = put - state->offset; - copy = state->length; - } - if (copy > left) copy = left; - left -= copy; - state->length -= copy; - do { - *put++ = *from++; - } while (--copy); - if (state->length == 0) state->mode = LEN; - break; - case LIT: - if (left == 0) goto inf_leave; - *put++ = (unsigned char)(state->length); - left--; - state->mode = LEN; - break; - case CHECK: - if (state->wrap) { - NEEDBITS(32); - out -= left; - strm->total_out += out; - state->total += out; - if (out) - strm->adler = state->check = - UPDATE(state->check, put - out, out); - out = left; - if (( -#ifdef GUNZIP - state->flags ? hold : -#endif - REVERSE(hold)) != state->check) { - strm->msg = (char *)"incorrect data check"; - state->mode = BAD; - break; - } - INITBITS(); - Tracev((stderr, "inflate: check matches trailer\n")); - } -#ifdef GUNZIP - state->mode = LENGTH; - case LENGTH: - if (state->wrap && state->flags) { - NEEDBITS(32); - if (hold != (state->total & 0xffffffffUL)) { - strm->msg = (char *)"incorrect length check"; - state->mode = BAD; - break; - } - INITBITS(); - Tracev((stderr, "inflate: length matches trailer\n")); - } -#endif - state->mode = DONE; - case DONE: - ret = Z_STREAM_END; - goto inf_leave; - case BAD: - ret = Z_DATA_ERROR; - goto inf_leave; - case MEM: - return Z_MEM_ERROR; - case SYNC: - default: - return Z_STREAM_ERROR; - } - - /* - Return from inflate(), updating the total counts and the check value. - If there was no progress during the inflate() call, return a buffer - error. Call updatewindow() to create and/or update the window state. - Note: a memory error from inflate() is non-recoverable. - */ - inf_leave: - RESTORE(); - if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) - if (updatewindow(strm, out)) { - state->mode = MEM; - return Z_MEM_ERROR; - } - in -= strm->avail_in; - out -= strm->avail_out; - strm->total_in += in; - strm->total_out += out; - state->total += out; - if (state->wrap && out) - strm->adler = state->check = - UPDATE(state->check, strm->next_out - out, out); - strm->data_type = state->bits + (state->last ? 64 : 0) + - (state->mode == TYPE ? 128 : 0) + - (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); - if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) - ret = Z_BUF_ERROR; - return ret; -} - -int ZEXPORT inflateEnd(z_streamp strm) -{ - struct inflate_state FAR *state; - if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) - return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (state->window != Z_NULL) ZFREE(strm, state->window); - ZFREE(strm, strm->state); - strm->state = Z_NULL; - Tracev((stderr, "inflate: end\n")); - return Z_OK; -} - -int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength) -{ - struct inflate_state FAR *state; - unsigned long id; - - /* check state */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (state->wrap != 0 && state->mode != DICT) - return Z_STREAM_ERROR; - - /* check for correct dictionary id */ - if (state->mode == DICT) { - id = adler32(0L, Z_NULL, 0); - id = adler32(id, dictionary, dictLength); - if (id != state->check) - return Z_DATA_ERROR; - } - - /* copy dictionary to window */ - if (updatewindow(strm, strm->avail_out)) { - state->mode = MEM; - return Z_MEM_ERROR; - } - if (dictLength > state->wsize) { - zmemcpy(state->window, dictionary + dictLength - state->wsize, - state->wsize); - state->whave = state->wsize; - } - else { - zmemcpy(state->window + state->wsize - dictLength, dictionary, - dictLength); - state->whave = dictLength; - } - state->havedict = 1; - Tracev((stderr, "inflate: dictionary set\n")); - return Z_OK; -} - -int ZEXPORT inflateGetHeader(z_streamp strm, gz_headerp head) -{ - struct inflate_state FAR *state; - - /* check state */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; - - /* save header structure */ - state->head = head; - head->done = 0; - return Z_OK; -} - -/* - Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found - or when out of input. When called, *have is the number of pattern bytes - found in order so far, in 0..3. On return *have is updated to the new - state. If on return *have equals four, then the pattern was found and the - return value is how many bytes were read including the last byte of the - pattern. If *have is less than four, then the pattern has not been found - yet and the return value is len. In the latter case, syncsearch() can be - called again with more data and the *have state. *have is initialized to - zero for the first call. - */ -local unsigned syncsearch(unsigned FAR *have, unsigned char FAR *buf, unsigned len) -{ - unsigned got; - unsigned next; - - got = *have; - next = 0; - while (next < len && got < 4) { - if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) - got++; - else if (buf[next]) - got = 0; - else - got = 4 - got; - next++; - } - *have = got; - return next; -} - -int ZEXPORT inflateSync(z_streamp strm) -{ - unsigned len; /* number of bytes to look at or looked at */ - unsigned long in, out; /* temporary to save total_in and total_out */ - unsigned char buf[4]; /* to restore bit buffer to byte string */ - struct inflate_state FAR *state; - - /* check parameters */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; - - /* if first time, start search in bit buffer */ - if (state->mode != SYNC) { - state->mode = SYNC; - state->hold <<= state->bits & 7; - state->bits -= state->bits & 7; - len = 0; - while (state->bits >= 8) { - buf[len++] = (unsigned char)(state->hold); - state->hold >>= 8; - state->bits -= 8; - } - state->have = 0; - syncsearch(&(state->have), buf, len); - } - - /* search available input */ - len = syncsearch(&(state->have), strm->next_in, strm->avail_in); - strm->avail_in -= len; - strm->next_in += len; - strm->total_in += len; - - /* return no joy or set up to restart inflate() on a new block */ - if (state->have != 4) return Z_DATA_ERROR; - in = strm->total_in; out = strm->total_out; - inflateReset(strm); - strm->total_in = in; strm->total_out = out; - state->mode = TYPE; - return Z_OK; -} - -/* - Returns true if inflate is currently at the end of a block generated by - Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP - implementation to provide an additional safety check. PPP uses - Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored - block. When decompressing, PPP checks that at the end of input packet, - inflate is waiting for these length bytes. - */ -int ZEXPORT inflateSyncPoint(z_streamp strm) -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - return state->mode == STORED && state->bits == 0; -} - -int ZEXPORT inflateCopy(z_streamp dest, z_streamp source) -{ - struct inflate_state FAR *state; - struct inflate_state FAR *copy; - unsigned char FAR *window; - unsigned wsize; - - /* check input */ - if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || - source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) - return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)source->state; - - /* allocate space */ - copy = (struct inflate_state FAR *) - ZALLOC(source, 1, sizeof(struct inflate_state)); - if (copy == Z_NULL) return Z_MEM_ERROR; - window = Z_NULL; - if (state->window != Z_NULL) { - window = (unsigned char FAR *) - ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); - if (window == Z_NULL) { - ZFREE(source, copy); - return Z_MEM_ERROR; - } - } - - /* copy state */ - zmemcpy(dest, source, sizeof(z_stream)); - zmemcpy(copy, state, sizeof(struct inflate_state)); - if (state->lencode >= state->codes && - state->lencode <= state->codes + ENOUGH - 1) { - copy->lencode = copy->codes + (state->lencode - state->codes); - copy->distcode = copy->codes + (state->distcode - state->codes); - } - copy->next = copy->codes + (state->next - state->codes); - if (window != Z_NULL) { - wsize = 1U << state->wbits; - zmemcpy(window, state->window, wsize); - } - copy->window = window; - dest->state = (struct internal_state FAR *)copy; - return Z_OK; -} - -int ZEXPORT inflateUndermine(z_streamp strm, int subvert) -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - state->sane = !subvert; -#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR - return Z_OK; -#else - state->sane = 1; - return Z_DATA_ERROR; -#endif -} - -long ZEXPORT inflateMark(z_streamp strm) -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; - state = (struct inflate_state FAR *)strm->state; - return ((long)(state->back) << 16) + - (state->mode == COPY ? state->length : - (state->mode == MATCH ? state->was - state->length : 0)); -} diff --git a/source/libz/inftrees.c b/source/libz/inftrees.c deleted file mode 100644 index 5302272..0000000 --- a/source/libz/inftrees.c +++ /dev/null @@ -1,330 +0,0 @@ -/* inftrees.c -- generate Huffman trees for efficient decoding - * Copyright (C) 1995-2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#include "zutil.h" -#include "inftrees.h" - -#define MAXBITS 15 - -const char inflate_copyright[] = - " inflate 1.2.5.f-ea Copyright 1995-2010 Mark Adler "; -/* - If you use the zlib library in a product, an acknowledgment is welcome - in the documentation of your product. If for some reason you cannot - include such an acknowledgment, I would appreciate that you keep this - copyright string in the executable of your product. - */ - -/* - Build a set of tables to decode the provided canonical Huffman code. - The code lengths are lens[0..codes-1]. The result starts at *table, - whose indices are 0..2^bits-1. work is a writable array of at least - lens shorts, which is used as a work area. type is the type of code - to be generated, CODES, LENS, or DISTS. On return, zero is success, - -1 is an invalid code, and +1 means that ENOUGH isn't enough. table - on return points to the next available entry's address. bits is the - requested root table index bits, and on return it is the actual root - table index bits. It will differ if the request is greater than the - longest code or if it is less than the shortest code. - */ -int ZLIB_INTERNAL inflate_table( - codetype type, - unsigned short FAR *lens, - unsigned codes, - code FAR * FAR *table, - unsigned FAR *bits, - unsigned short FAR *work) -{ - unsigned len; /* a code's length in bits */ - unsigned sym; /* index of code symbols */ - unsigned min, max; /* minimum and maximum code lengths */ - unsigned root; /* number of index bits for root table */ - unsigned curr; /* number of index bits for current table */ - unsigned drop; /* code bits to drop for sub-table */ - int left; /* number of prefix codes available */ - unsigned used; /* code entries in table used */ - unsigned huff; /* Huffman code */ - unsigned incr; /* for incrementing code, index */ - unsigned fill; /* index for replicating entries */ - unsigned low; /* low bits for current root entry */ - unsigned mask; /* mask for low root bits */ - code here; /* table entry for duplication */ - code FAR *next; /* next available space in table */ - const unsigned short FAR *base; /* base value table to use */ - const unsigned short FAR *extra; /* extra bits table to use */ - int end; /* use base and extra for symbol > end */ - unsigned short count[MAXBITS+1]; /* number of codes of each length */ - unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ - static const unsigned short lbase[31] = { /* Length codes 257..285 base */ - 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, - 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; - static const unsigned short lext[31] = { /* Length codes 257..285 extra */ - 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, - 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 73, 195}; - static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ - 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, - 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, - 8193, 12289, 16385, 24577, 0, 0}; - static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ - 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, - 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, - 28, 28, 29, 29, 64, 64}; - - /* - Process a set of code lengths to create a canonical Huffman code. The - code lengths are lens[0..codes-1]. Each length corresponds to the - symbols 0..codes-1. The Huffman code is generated by first sorting the - symbols by length from short to long, and retaining the symbol order - for codes with equal lengths. Then the code starts with all zero bits - for the first code of the shortest length, and the codes are integer - increments for the same length, and zeros are appended as the length - increases. For the deflate format, these bits are stored backwards - from their more natural integer increment ordering, and so when the - decoding tables are built in the large loop below, the integer codes - are incremented backwards. - - This routine assumes, but does not check, that all of the entries in - lens[] are in the range 0..MAXBITS. The caller must assure this. - 1..MAXBITS is interpreted as that code length. zero means that that - symbol does not occur in this code. - - The codes are sorted by computing a count of codes for each length, - creating from that a table of starting indices for each length in the - sorted table, and then entering the symbols in order in the sorted - table. The sorted table is work[], with that space being provided by - the caller. - - The length counts are used for other purposes as well, i.e. finding - the minimum and maximum length codes, determining if there are any - codes at all, checking for a valid set of lengths, and looking ahead - at length counts to determine sub-table sizes when building the - decoding tables. - */ - - /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ - for (len = 0; len <= MAXBITS; len++) - count[len] = 0; - for (sym = 0; sym < codes; sym++) - count[lens[sym]]++; - - /* bound code lengths, force root to be within code lengths */ - root = *bits; - for (max = MAXBITS; max >= 1; max--) - if (count[max] != 0) break; - if (root > max) root = max; - if (max == 0) { /* no symbols to code at all */ - here.op = (unsigned char)64; /* invalid code marker */ - here.bits = (unsigned char)1; - here.val = (unsigned short)0; - *(*table)++ = here; /* make a table to force an error */ - *(*table)++ = here; - *bits = 1; - return 0; /* no symbols, but wait for decoding to report error */ - } - for (min = 1; min < max; min++) - if (count[min] != 0) break; - if (root < min) root = min; - - /* check for an over-subscribed or incomplete set of lengths */ - left = 1; - for (len = 1; len <= MAXBITS; len++) { - left <<= 1; - left -= count[len]; - if (left < 0) return -1; /* over-subscribed */ - } - if (left > 0 && (type == CODES || max != 1)) - return -1; /* incomplete set */ - - /* generate offsets into symbol table for each length for sorting */ - offs[1] = 0; - for (len = 1; len < MAXBITS; len++) - offs[len + 1] = offs[len] + count[len]; - - /* sort symbols by length, by symbol order within each length */ - for (sym = 0; sym < codes; sym++) - if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; - - /* - Create and fill in decoding tables. In this loop, the table being - filled is at next and has curr index bits. The code being used is huff - with length len. That code is converted to an index by dropping drop - bits off of the bottom. For codes where len is less than drop + curr, - those top drop + curr - len bits are incremented through all values to - fill the table with replicated entries. - - root is the number of index bits for the root table. When len exceeds - root, sub-tables are created pointed to by the root entry with an index - of the low root bits of huff. This is saved in low to check for when a - new sub-table should be started. drop is zero when the root table is - being filled, and drop is root when sub-tables are being filled. - - When a new sub-table is needed, it is necessary to look ahead in the - code lengths to determine what size sub-table is needed. The length - counts are used for this, and so count[] is decremented as codes are - entered in the tables. - - used keeps track of how many table entries have been allocated from the - provided *table space. It is checked for LENS and DIST tables against - the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in - the initial root table size constants. See the comments in inftrees.h - for more information. - - sym increments through all symbols, and the loop terminates when - all codes of length max, i.e. all codes, have been processed. This - routine permits incomplete codes, so another loop after this one fills - in the rest of the decoding tables with invalid code markers. - */ - - /* set up for code type */ - switch (type) { - case CODES: - base = extra = work; /* dummy value--not used */ - end = 19; - break; - case LENS: - base = lbase; - base -= 257; - extra = lext; - extra -= 257; - end = 256; - break; - default: /* DISTS */ - base = dbase; - extra = dext; - end = -1; - } - - /* initialize state for loop */ - huff = 0; /* starting code */ - sym = 0; /* starting code symbol */ - len = min; /* starting code length */ - next = *table; /* current table to fill in */ - curr = root; /* current table index bits */ - drop = 0; /* current bits to drop from code for index */ - low = (unsigned)(-1); /* trigger new sub-table when len > root */ - used = 1U << root; /* use root table entries */ - mask = used - 1; /* mask for comparing low */ - - /* check available table space */ - if ((type == LENS && used >= ENOUGH_LENS) || - (type == DISTS && used >= ENOUGH_DISTS)) - return 1; - - /* process all codes and make table entries */ - for (;;) { - /* create table entry */ - here.bits = (unsigned char)(len - drop); - if ((int)(work[sym]) < end) { - here.op = (unsigned char)0; - here.val = work[sym]; - } - else if ((int)(work[sym]) > end) { - here.op = (unsigned char)(extra[work[sym]]); - here.val = base[work[sym]]; - } - else { - here.op = (unsigned char)(32 + 64); /* end of block */ - here.val = 0; - } - - /* replicate for those indices with low len bits equal to huff */ - incr = 1U << (len - drop); - fill = 1U << curr; - min = fill; /* save offset to next table */ - do { - fill -= incr; - next[(huff >> drop) + fill] = here; - } while (fill != 0); - - /* backwards increment the len-bit code huff */ - incr = 1U << (len - 1); - while (huff & incr) - incr >>= 1; - if (incr != 0) { - huff &= incr - 1; - huff += incr; - } - else - huff = 0; - - /* go to next symbol, update count, len */ - sym++; - if (--(count[len]) == 0) { - if (len == max) break; - len = lens[work[sym]]; - } - - /* create new sub-table if needed */ - if (len > root && (huff & mask) != low) { - /* if first time, transition to sub-tables */ - if (drop == 0) - drop = root; - - /* increment past last table */ - next += min; /* here min is 1 << curr */ - - /* determine length of next table */ - curr = len - drop; - left = (int)(1 << curr); - while (curr + drop < max) { - left -= count[curr + drop]; - if (left <= 0) break; - curr++; - left <<= 1; - } - - /* check for enough space */ - used += 1U << curr; - if ((type == LENS && used >= ENOUGH_LENS) || - (type == DISTS && used >= ENOUGH_DISTS)) - return 1; - - /* point entry in root table to sub-table */ - low = huff & mask; - (*table)[low].op = (unsigned char)curr; - (*table)[low].bits = (unsigned char)root; - (*table)[low].val = (unsigned short)(next - *table); - } - } - - /* - Fill in rest of table for incomplete codes. This loop is similar to the - loop above in incrementing huff for table indices. It is assumed that - len is equal to curr + drop, so there is no loop needed to increment - through high index bits. When the current sub-table is filled, the loop - drops back to the root table to fill in any remaining entries there. - */ - here.op = (unsigned char)64; /* invalid code marker */ - here.bits = (unsigned char)(len - drop); - here.val = (unsigned short)0; - while (huff != 0) { - /* when done with sub-table, drop back to root table */ - if (drop != 0 && (huff & mask) != low) { - drop = 0; - len = root; - next = *table; - here.bits = (unsigned char)len; - } - - /* put invalid code marker in table */ - next[huff >> drop] = here; - - /* backwards increment the len-bit code huff */ - incr = 1U << (len - 1); - while (huff & incr) - incr >>= 1; - if (incr != 0) { - huff &= incr - 1; - huff += incr; - } - else - huff = 0; - } - - /* set return parameters */ - *table += used; - *bits = root; - return 0; -} diff --git a/source/libz/trees.c b/source/libz/trees.c deleted file mode 100644 index 1f06e31..0000000 --- a/source/libz/trees.c +++ /dev/null @@ -1,1196 +0,0 @@ -/* trees.c -- output deflated data using Huffman coding - * Copyright (C) 1995-2010 Jean-loup Gailly - * detect_data_type() function provided freely by Cosmin Truta, 2006 - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * ALGORITHM - * - * The "deflation" process uses several Huffman trees. The more - * common source values are represented by shorter bit sequences. - * - * Each code tree is stored in a compressed form which is itself - * a Huffman encoding of the lengths of all the code strings (in - * ascending order by source values). The actual code strings are - * reconstructed from the lengths in the inflate process, as described - * in the deflate specification. - * - * REFERENCES - * - * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". - * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc - * - * Storer, James A. - * Data Compression: Methods and Theory, pp. 49-50. - * Computer Science Press, 1988. ISBN 0-7167-8156-5. - * - * Sedgewick, R. - * Algorithms, p290. - * Addison-Wesley, 1983. ISBN 0-201-06672-6. - */ - -/* @(#) $Id$ */ - -/* #define GEN_TREES_H */ - -#include "deflate.h" - -#ifdef DEBUG -# include -#endif - -/* =========================================================================== - * Constants - */ - -#define MAX_BL_BITS 7 -/* Bit length codes must not exceed MAX_BL_BITS bits */ - -#define END_BLOCK 256 -/* end of block literal code */ - -#define REP_3_6 16 -/* repeat previous bit length 3-6 times (2 bits of repeat count) */ - -#define REPZ_3_10 17 -/* repeat a zero length 3-10 times (3 bits of repeat count) */ - -#define REPZ_11_138 18 -/* repeat a zero length 11-138 times (7 bits of repeat count) */ - -local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ - = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; - -local const int extra_dbits[D_CODES] /* extra bits for each distance code */ - = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; - -local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ - = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; - -local const uch bl_order[BL_CODES] - = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; -/* The lengths of the bit length codes are sent in order of decreasing - * probability, to avoid transmitting the lengths for unused bit length codes. - */ - -#define Buf_size (8 * 2*sizeof(char)) -/* Number of bits used within bi_buf. (bi_buf might be implemented on - * more than 16 bits on some systems.) - */ - -/* =========================================================================== - * Local data. These are initialized only once. - */ - -#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ - -#if defined(GEN_TREES_H) || !defined(STDC) -/* non ANSI compilers may not accept trees.h */ - -local ct_data static_ltree[L_CODES+2]; -/* The static literal tree. Since the bit lengths are imposed, there is no - * need for the L_CODES extra codes used during heap construction. However - * The codes 286 and 287 are needed to build a canonical tree (see _tr_init - * below). - */ - -local ct_data static_dtree[D_CODES]; -/* The static distance tree. (Actually a trivial tree since all codes use - * 5 bits.) - */ - -uch _dist_code[DIST_CODE_LEN]; -/* Distance codes. The first 256 values correspond to the distances - * 3 .. 258, the last 256 values correspond to the top 8 bits of - * the 15 bit distances. - */ - -uch _length_code[MAX_MATCH-MIN_MATCH+1]; -/* length code for each normalized match length (0 == MIN_MATCH) */ - -local int base_length[LENGTH_CODES]; -/* First normalized length for each code (0 = MIN_MATCH) */ - -local int base_dist[D_CODES]; -/* First normalized distance for each code (0 = distance of 1) */ - -#else -# include "trees.h" -#endif /* GEN_TREES_H */ - -struct static_tree_desc_s { - const ct_data *static_tree; /* static tree or NULL */ - const intf *extra_bits; /* extra bits for each code or NULL */ - int extra_base; /* base index for extra_bits */ - int elems; /* max number of elements in the tree */ - int max_length; /* max bit length for the codes */ -}; - -local static_tree_desc static_l_desc = -{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; - -local static_tree_desc static_d_desc = -{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; - -local static_tree_desc static_bl_desc = -{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; - -/* =========================================================================== - * Local (static) routines in this file. - */ - -local void tr_static_init OF((void)); -local void init_block OF((deflate_state *s)); -local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); -local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); -local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); -local void build_tree OF((deflate_state *s, tree_desc *desc)); -local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local int build_bl_tree OF((deflate_state *s)); -local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, - int blcodes)); -local void compress_block OF((deflate_state *s, ct_data *ltree, - ct_data *dtree)); -local int detect_data_type OF((deflate_state *s)); -local unsigned bi_reverse OF((unsigned value, int length)); -local void bi_windup OF((deflate_state *s)); -local void bi_flush OF((deflate_state *s)); -local void copy_block OF((deflate_state *s, charf *buf, unsigned len, - int header)); - -#ifdef GEN_TREES_H -local void gen_trees_header OF((void)); -#endif - -#ifndef DEBUG -# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) - /* Send a code of the given tree. c and tree must not have side effects */ - -#else /* DEBUG */ -# define send_code(s, c, tree) \ - { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ - send_bits(s, tree[c].Code, tree[c].Len); } -#endif - -/* =========================================================================== - * Output a short LSB first on the stream. - * IN assertion: there is enough room in pendingBuf. - */ -#define put_short(s, w) { \ - put_byte(s, (uch)((w) & 0xff)); \ - put_byte(s, (uch)((ush)(w) >> 8)); \ -} - -/* =========================================================================== - * Send a value on a given number of bits. - * IN assertion: length <= 16 and value fits in length bits. - */ -#ifdef DEBUG -local void send_bits OF((deflate_state *s, int value, int length)); - -local void send_bits(deflate_state *s, int value /* value to send */, int length /* number of bits */) -{ - Tracevv((stderr," l %2d v %4x ", length, value)); - Assert(length > 0 && length <= 15, "invalid length"); - s->bits_sent += (ulg)length; - - /* If not enough room in bi_buf, use (valid) bits from bi_buf and - * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) - * unused bits in value. - */ - if (s->bi_valid > (int)Buf_size - length) { - s->bi_buf |= (ush)value << s->bi_valid; - put_short(s, s->bi_buf); - s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); - s->bi_valid += length - Buf_size; - } else { - s->bi_buf |= (ush)value << s->bi_valid; - s->bi_valid += length; - } -} -#else /* !DEBUG */ - -#define send_bits(s, value, length) \ -{ int len = length;\ - if (s->bi_valid > (int)Buf_size - len) {\ - int val = value;\ - s->bi_buf |= (ush)val << s->bi_valid;\ - put_short(s, s->bi_buf);\ - s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ - s->bi_valid += len - Buf_size;\ - } else {\ - s->bi_buf |= (ush)(value) << s->bi_valid;\ - s->bi_valid += len;\ - }\ -} -#endif /* DEBUG */ - - -/* the arguments must not have side effects */ - -/* =========================================================================== - * Initialize the various 'constant' tables. - */ -local void tr_static_init() -{ -#if defined(GEN_TREES_H) || !defined(STDC) - static int static_init_done = 0; - int n; /* iterates over tree elements */ - int bits; /* bit counter */ - int length; /* length value */ - int code; /* code value */ - int dist; /* distance index */ - ush bl_count[MAX_BITS+1]; - /* number of codes at each bit length for an optimal tree */ - - if (static_init_done) return; - - /* For some embedded targets, global variables are not initialized: */ -#ifdef NO_INIT_GLOBAL_POINTERS - static_l_desc.static_tree = static_ltree; - static_l_desc.extra_bits = extra_lbits; - static_d_desc.static_tree = static_dtree; - static_d_desc.extra_bits = extra_dbits; - static_bl_desc.extra_bits = extra_blbits; -#endif - - /* Initialize the mapping length (0..255) -> length code (0..28) */ - length = 0; - for (code = 0; code < LENGTH_CODES-1; code++) { - base_length[code] = length; - for (n = 0; n < (1< dist code (0..29) */ - dist = 0; - for (code = 0 ; code < 16; code++) { - base_dist[code] = dist; - for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ - for ( ; code < D_CODES; code++) { - base_dist[code] = dist << 7; - for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { - _dist_code[256 + dist++] = (uch)code; - } - } - Assert (dist == 256, "tr_static_init: 256+dist != 512"); - - /* Construct the codes of the static literal tree */ - for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; - n = 0; - while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; - while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; - while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; - while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; - /* Codes 286 and 287 do not exist, but we must include them in the - * tree construction to get a canonical Huffman tree (longest code - * all ones) - */ - gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); - - /* The static distance tree is trivial: */ - for (n = 0; n < D_CODES; n++) { - static_dtree[n].Len = 5; - static_dtree[n].Code = bi_reverse((unsigned)n, 5); - } - static_init_done = 1; - -# ifdef GEN_TREES_H - gen_trees_header(); -# endif -#endif /* defined(GEN_TREES_H) || !defined(STDC) */ -} - -/* =========================================================================== - * Genererate the file trees.h describing the static trees. - */ -#ifdef GEN_TREES_H -# ifndef DEBUG -# include -# endif - -# define SEPARATOR(i, last, width) \ - ((i) == (last)? "\n};\n\n" : \ - ((i) % (width) == (width)-1 ? ",\n" : ", ")) - -void gen_trees_header() -{ - FILE *header = fopen("trees.h", "w"); - int i; - - Assert (header != NULL, "Can't open trees.h"); - fprintf(header, - "/* header created automatically with -DGEN_TREES_H */\n\n"); - - fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); - for (i = 0; i < L_CODES+2; i++) { - fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, - static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); - } - - fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { - fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, - static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); - } - - fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); - for (i = 0; i < DIST_CODE_LEN; i++) { - fprintf(header, "%2u%s", _dist_code[i], - SEPARATOR(i, DIST_CODE_LEN-1, 20)); - } - - fprintf(header, - "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); - for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { - fprintf(header, "%2u%s", _length_code[i], - SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); - } - - fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); - for (i = 0; i < LENGTH_CODES; i++) { - fprintf(header, "%1u%s", base_length[i], - SEPARATOR(i, LENGTH_CODES-1, 20)); - } - - fprintf(header, "local const int base_dist[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { - fprintf(header, "%5u%s", base_dist[i], - SEPARATOR(i, D_CODES-1, 10)); - } - - fclose(header); -} -#endif /* GEN_TREES_H */ - -/* =========================================================================== - * Initialize the tree data structures for a new zlib stream. - */ -void ZLIB_INTERNAL _tr_init(deflate_state *s) -{ - tr_static_init(); - - s->l_desc.dyn_tree = s->dyn_ltree; - s->l_desc.stat_desc = &static_l_desc; - - s->d_desc.dyn_tree = s->dyn_dtree; - s->d_desc.stat_desc = &static_d_desc; - - s->bl_desc.dyn_tree = s->bl_tree; - s->bl_desc.stat_desc = &static_bl_desc; - - s->bi_buf = 0; - s->bi_valid = 0; - s->last_eob_len = 8; /* enough lookahead for inflate */ -#ifdef DEBUG - s->compressed_len = 0L; - s->bits_sent = 0L; -#endif - - /* Initialize the first block of the first file: */ - init_block(s); -} - -/* =========================================================================== - * Initialize a new block. - */ -local void init_block(deflate_state *s) -{ - int n; /* iterates over tree elements */ - - /* Initialize the trees. */ - for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; - for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; - for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; - - s->dyn_ltree[END_BLOCK].Freq = 1; - s->opt_len = s->static_len = 0L; - s->last_lit = s->matches = 0; -} - -#define SMALLEST 1 -/* Index within the heap array of least frequent node in the Huffman tree */ - - -/* =========================================================================== - * Remove the smallest element from the heap and recreate the heap with - * one less element. Updates heap and heap_len. - */ -#define pqremove(s, tree, top) \ -{\ - top = s->heap[SMALLEST]; \ - s->heap[SMALLEST] = s->heap[s->heap_len--]; \ - pqdownheap(s, tree, SMALLEST); \ -} - -/* =========================================================================== - * Compares to subtrees, using the tree depth as tie breaker when - * the subtrees have equal frequency. This minimizes the worst case length. - */ -#define smaller(tree, n, m, depth) \ - (tree[n].Freq < tree[m].Freq || \ - (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) - -/* =========================================================================== - * Restore the heap property by moving down the tree starting at node k, - * exchanging a node with the smallest of its two sons if necessary, stopping - * when the heap property is re-established (each father smaller than its - * two sons). - */ -local void pqdownheap(deflate_state *s, ct_data *tree /* the tree to restore */, int k /* node to move down */) -{ - int v = s->heap[k]; - int j = k << 1; /* left son of k */ - while (j <= s->heap_len) { - /* Set j to the smallest of the two sons: */ - if (j < s->heap_len && - smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { - j++; - } - /* Exit if v is smaller than both sons */ - if (smaller(tree, v, s->heap[j], s->depth)) break; - - /* Exchange v with the smallest son */ - s->heap[k] = s->heap[j]; k = j; - - /* And continue down the tree, setting j to the left son of k */ - j <<= 1; - } - s->heap[k] = v; -} - -/* =========================================================================== - * Compute the optimal bit lengths for a tree and update the total bit length - * for the current block. - * IN assertion: the fields freq and dad are set, heap[heap_max] and - * above are the tree nodes sorted by increasing frequency. - * OUT assertions: the field len is set to the optimal bit length, the - * array bl_count contains the frequencies for each bit length. - * The length opt_len is updated; static_len is also updated if stree is - * not null. - */ -local void gen_bitlen(deflate_state *s, tree_desc *desc /* the tree descriptor */) -{ - ct_data *tree = desc->dyn_tree; - int max_code = desc->max_code; - const ct_data *stree = desc->stat_desc->static_tree; - const intf *extra = desc->stat_desc->extra_bits; - int base = desc->stat_desc->extra_base; - int max_length = desc->stat_desc->max_length; - int h; /* heap index */ - int n, m; /* iterate over the tree elements */ - int bits; /* bit length */ - int xbits; /* extra bits */ - ush f; /* frequency */ - int overflow = 0; /* number of elements with bit length too large */ - - for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; - - /* In a first pass, compute the optimal bit lengths (which may - * overflow in the case of the bit length tree). - */ - tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ - - for (h = s->heap_max+1; h < HEAP_SIZE; h++) { - n = s->heap[h]; - bits = tree[tree[n].Dad].Len + 1; - if (bits > max_length) bits = max_length, overflow++; - tree[n].Len = (ush)bits; - /* We overwrite tree[n].Dad which is no longer needed */ - - if (n > max_code) continue; /* not a leaf node */ - - s->bl_count[bits]++; - xbits = 0; - if (n >= base) xbits = extra[n-base]; - f = tree[n].Freq; - s->opt_len += (ulg)f * (bits + xbits); - if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); - } - if (overflow == 0) return; - - Trace((stderr,"\nbit length overflow\n")); - /* This happens for example on obj2 and pic of the Calgary corpus */ - - /* Find the first bit length which could increase: */ - do { - bits = max_length-1; - while (s->bl_count[bits] == 0) bits--; - s->bl_count[bits]--; /* move one leaf down the tree */ - s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ - s->bl_count[max_length]--; - /* The brother of the overflow item also moves one step up, - * but this does not affect bl_count[max_length] - */ - overflow -= 2; - } while (overflow > 0); - - /* Now recompute all bit lengths, scanning in increasing frequency. - * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all - * lengths instead of fixing only the wrong ones. This idea is taken - * from 'ar' written by Haruhiko Okumura.) - */ - for (bits = max_length; bits != 0; bits--) { - n = s->bl_count[bits]; - while (n != 0) { - m = s->heap[--h]; - if (m > max_code) continue; - if ((unsigned) tree[m].Len != (unsigned) bits) { - Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); - s->opt_len += ((long)bits - (long)tree[m].Len) - *(long)tree[m].Freq; - tree[m].Len = (ush)bits; - } - n--; - } - } -} - -/* =========================================================================== - * Generate the codes for a given tree and bit counts (which need not be - * optimal). - * IN assertion: the array bl_count contains the bit length statistics for - * the given tree and the field len is set for all tree elements. - * OUT assertion: the field code is set for all tree elements of non - * zero code length. - */ -local void gen_codes (ct_data *tree /* the tree to decorate */, int max_code /* largest code with non zero frequency */, ushf *bl_count /* number of codes at each bit length */) -{ - ush next_code[MAX_BITS+1]; /* next code value for each bit length */ - ush code = 0; /* running code value */ - int bits; /* bit index */ - int n; /* code index */ - - /* The distribution counts are first used to generate the code values - * without bit reversal. - */ - for (bits = 1; bits <= MAX_BITS; bits++) { - next_code[bits] = code = (code + bl_count[bits-1]) << 1; - } - /* Check that the bit counts in bl_count are consistent. The last code - * must be all ones. - */ - Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; - const ct_data *stree = desc->stat_desc->static_tree; - int elems = desc->stat_desc->elems; - int n, m; /* iterate over heap elements */ - int max_code = -1; /* largest code with non zero frequency */ - int node; /* new node being created */ - - /* Construct the initial heap, with least frequent element in - * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. - * heap[0] is not used. - */ - s->heap_len = 0, s->heap_max = HEAP_SIZE; - - for (n = 0; n < elems; n++) { - if (tree[n].Freq != 0) { - s->heap[++(s->heap_len)] = max_code = n; - s->depth[n] = 0; - } else { - tree[n].Len = 0; - } - } - - /* The pkzip format requires that at least one distance code exists, - * and that at least one bit should be sent even if there is only one - * possible code. So to avoid special checks later on we force at least - * two codes of non zero frequency. - */ - while (s->heap_len < 2) { - node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); - tree[node].Freq = 1; - s->depth[node] = 0; - s->opt_len--; if (stree) s->static_len -= stree[node].Len; - /* node is 0 or 1 so it does not have extra bits */ - } - desc->max_code = max_code; - - /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, - * establish sub-heaps of increasing lengths: - */ - for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); - - /* Construct the Huffman tree by repeatedly combining the least two - * frequent nodes. - */ - node = elems; /* next internal node of the tree */ - do { - pqremove(s, tree, n); /* n = node of least frequency */ - m = s->heap[SMALLEST]; /* m = node of next least frequency */ - - s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ - s->heap[--(s->heap_max)] = m; - - /* Create a new node father of n and m */ - tree[node].Freq = tree[n].Freq + tree[m].Freq; - s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? - s->depth[n] : s->depth[m]) + 1); - tree[n].Dad = tree[m].Dad = (ush)node; -#ifdef DUMP_BL_TREE - if (tree == s->bl_tree) { - fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", - node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); - } -#endif - /* and insert the new node in the heap */ - s->heap[SMALLEST] = node++; - pqdownheap(s, tree, SMALLEST); - - } while (s->heap_len >= 2); - - s->heap[--(s->heap_max)] = s->heap[SMALLEST]; - - /* At this point, the fields freq and dad are set. We can now - * generate the bit lengths. - */ - gen_bitlen(s, (tree_desc *)desc); - - /* The field len is now set, we can generate the bit codes */ - gen_codes ((ct_data *)tree, max_code, s->bl_count); -} - -/* =========================================================================== - * Scan a literal or distance tree to determine the frequencies of the codes - * in the bit length tree. - */ -local void scan_tree (deflate_state *s, ct_data *tree /* the tree to be scanned */, int max_code /* and its largest code of non zero frequency */) -{ - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ - int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ - - if (nextlen == 0) max_count = 138, min_count = 3; - tree[max_code+1].Len = (ush)0xffff; /* guard */ - - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; - if (++count < max_count && curlen == nextlen) { - continue; - } else if (count < min_count) { - s->bl_tree[curlen].Freq += count; - } else if (curlen != 0) { - if (curlen != prevlen) s->bl_tree[curlen].Freq++; - s->bl_tree[REP_3_6].Freq++; - } else if (count <= 10) { - s->bl_tree[REPZ_3_10].Freq++; - } else { - s->bl_tree[REPZ_11_138].Freq++; - } - count = 0; prevlen = curlen; - if (nextlen == 0) { - max_count = 138, min_count = 3; - } else if (curlen == nextlen) { - max_count = 6, min_count = 3; - } else { - max_count = 7, min_count = 4; - } - } -} - -/* =========================================================================== - * Send a literal or distance tree in compressed form, using the codes in - * bl_tree. - */ -local void send_tree (deflate_state *s, ct_data *tree /* the tree to be scanned */, int max_code /* and its largest code of non zero frequency */) -{ - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ - int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ - - /* tree[max_code+1].Len = -1; */ /* guard already set */ - if (nextlen == 0) max_count = 138, min_count = 3; - - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; - if (++count < max_count && curlen == nextlen) { - continue; - } else if (count < min_count) { - do { send_code(s, curlen, s->bl_tree); } while (--count != 0); - - } else if (curlen != 0) { - if (curlen != prevlen) { - send_code(s, curlen, s->bl_tree); count--; - } - Assert(count >= 3 && count <= 6, " 3_6?"); - send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); - - } else if (count <= 10) { - send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); - - } else { - send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); - } - count = 0; prevlen = curlen; - if (nextlen == 0) { - max_count = 138, min_count = 3; - } else if (curlen == nextlen) { - max_count = 6, min_count = 3; - } else { - max_count = 7, min_count = 4; - } - } -} - -/* =========================================================================== - * Construct the Huffman tree for the bit lengths and return the index in - * bl_order of the last bit length code to send. - */ -local int build_bl_tree(deflate_state *s) -{ - int max_blindex; /* index of last bit length code of non zero freq */ - - /* Determine the bit length frequencies for literal and distance trees */ - scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); - scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); - - /* Build the bit length tree: */ - build_tree(s, (tree_desc *)(&(s->bl_desc))); - /* opt_len now includes the length of the tree representations, except - * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. - */ - - /* Determine the number of bit length codes to send. The pkzip format - * requires that at least 4 bit length codes be sent. (appnote.txt says - * 3 but the actual value used is 4.) - */ - for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { - if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; - } - /* Update opt_len to include the bit length tree and counts */ - s->opt_len += 3*(max_blindex+1) + 5+5+4; - Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", - s->opt_len, s->static_len)); - - return max_blindex; -} - -/* =========================================================================== - * Send the header for a block using dynamic Huffman trees: the counts, the - * lengths of the bit length codes, the literal tree and the distance tree. - * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. - */ -local void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes /* number of codes for each tree */) -{ - int rank; /* index in bl_order */ - - Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); - Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, - "too many codes"); - Tracev((stderr, "\nbl counts: ")); - send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ - send_bits(s, dcodes-1, 5); - send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ - for (rank = 0; rank < blcodes; rank++) { - Tracev((stderr, "\nbl code %2d ", bl_order[rank])); - send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); - } - Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); - - send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ - Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); - - send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ - Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); -} - -/* =========================================================================== - * Send a stored block - */ -void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf /* input block */, ulg stored_len /* length of input block */, int last /* one if this is the last block for a file */) -{ - send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ -#ifdef DEBUG - s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; - s->compressed_len += (stored_len + 4) << 3; -#endif - copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ -} - -/* =========================================================================== - * Send one empty static block to give enough lookahead for inflate. - * This takes 10 bits, of which 7 may remain in the bit buffer. - * The current inflate code requires 9 bits of lookahead. If the - * last two codes for the previous block (real code plus EOB) were coded - * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode - * the last real code. In this case we send two empty static blocks instead - * of one. (There are no problems if the previous block is stored or fixed.) - * To simplify the code, we assume the worst case of last real code encoded - * on one bit only. - */ -void ZLIB_INTERNAL _tr_align(deflate_state *s) -{ - send_bits(s, STATIC_TREES<<1, 3); - send_code(s, END_BLOCK, static_ltree); -#ifdef DEBUG - s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ -#endif - bi_flush(s); - /* Of the 10 bits for the empty block, we have already sent - * (10 - bi_valid) bits. The lookahead for the last real code (before - * the EOB of the previous block) was thus at least one plus the length - * of the EOB plus what we have just sent of the empty static block. - */ - if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { - send_bits(s, STATIC_TREES<<1, 3); - send_code(s, END_BLOCK, static_ltree); -#ifdef DEBUG - s->compressed_len += 10L; -#endif - bi_flush(s); - } - s->last_eob_len = 7; -} - -/* =========================================================================== - * Determine the best encoding for the current block: dynamic trees, static - * trees or store, and output the encoded block to the zip file. - */ -void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf /* input block, or NULL if too old */, ulg stored_len /* length of input block */, int last /* one if this is the last block for a file */) -{ - ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ - int max_blindex = 0; /* index of last bit length code of non zero freq */ - - /* Build the Huffman trees unless a stored block is forced */ - if (s->level > 0) { - - /* Check if the file is binary or text */ - if (s->strm->data_type == Z_UNKNOWN) - s->strm->data_type = detect_data_type(s); - - /* Construct the literal and distance trees */ - build_tree(s, (tree_desc *)(&(s->l_desc))); - Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, - s->static_len)); - - build_tree(s, (tree_desc *)(&(s->d_desc))); - Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, - s->static_len)); - /* At this point, opt_len and static_len are the total bit lengths of - * the compressed block data, excluding the tree representations. - */ - - /* Build the bit length tree for the above two trees, and get the index - * in bl_order of the last bit length code to send. - */ - max_blindex = build_bl_tree(s); - - /* Determine the best encoding. Compute the block lengths in bytes. */ - opt_lenb = (s->opt_len+3+7)>>3; - static_lenb = (s->static_len+3+7)>>3; - - Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", - opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, - s->last_lit)); - - if (static_lenb <= opt_lenb) opt_lenb = static_lenb; - - } else { - Assert(buf != (char*)0, "lost buf"); - opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ - } - -#ifdef FORCE_STORED - if (buf != (char*)0) { /* force stored block */ -#else - if (stored_len+4 <= opt_lenb && buf != (char*)0) { - /* 4: two words for the lengths */ -#endif - /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. - * Otherwise we can't have processed more than WSIZE input bytes since - * the last block flush, because compression would have been - * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to - * transform a block into a stored block. - */ - _tr_stored_block(s, buf, stored_len, last); - -#ifdef FORCE_STATIC - } else if (static_lenb >= 0) { /* force static trees */ -#else - } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { -#endif - send_bits(s, (STATIC_TREES<<1)+last, 3); - compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); -#ifdef DEBUG - s->compressed_len += 3 + s->static_len; -#endif - } else { - send_bits(s, (DYN_TREES<<1)+last, 3); - send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, - max_blindex+1); - compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); -#ifdef DEBUG - s->compressed_len += 3 + s->opt_len; -#endif - } - Assert (s->compressed_len == s->bits_sent, "bad compressed size"); - /* The above check is made mod 2^32, for files larger than 512 MB - * and uLong implemented on 32 bits. - */ - init_block(s); - - if (last) { - bi_windup(s); -#ifdef DEBUG - s->compressed_len += 7; /* align on byte boundary */ -#endif - } - Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, - s->compressed_len-7*last)); -} - -/* =========================================================================== - * Save the match info and tally the frequency counts. Return true if - * the current block must be flushed. - */ -int ZLIB_INTERNAL _tr_tally (deflate_state *s, unsigned dist /* distance of matched string */, unsigned lc /* match length-MIN_MATCH or unmatched char (if dist==0) */) -{ - s->d_buf[s->last_lit] = (ush)dist; - s->l_buf[s->last_lit++] = (uch)lc; - if (dist == 0) { - /* lc is the unmatched char */ - s->dyn_ltree[lc].Freq++; - } else { - s->matches++; - /* Here, lc is the match length - MIN_MATCH */ - dist--; /* dist = match distance - 1 */ - Assert((ush)dist < (ush)MAX_DIST(s) && - (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && - (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); - - s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; - s->dyn_dtree[d_code(dist)].Freq++; - } - -#ifdef TRUNCATE_BLOCK - /* Try to guess if it is profitable to stop the current block here */ - if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { - /* Compute an upper bound for the compressed length */ - ulg out_length = (ulg)s->last_lit*8L; - ulg in_length = (ulg)((long)s->strstart - s->block_start); - int dcode; - for (dcode = 0; dcode < D_CODES; dcode++) { - out_length += (ulg)s->dyn_dtree[dcode].Freq * - (5L+extra_dbits[dcode]); - } - out_length >>= 3; - Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", - s->last_lit, in_length, out_length, - 100L - out_length*100L/in_length)); - if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; - } -#endif - return (s->last_lit == s->lit_bufsize-1); - /* We avoid equality with lit_bufsize because of wraparound at 64K - * on 16 bit machines and because stored blocks are restricted to - * 64K-1 bytes. - */ -} - -/* =========================================================================== - * Send the block data compressed using the given Huffman trees - */ -local void compress_block(deflate_state *s, ct_data *ltree /* literal tree */, ct_data *dtree /* distance tree */) -{ - unsigned dist; /* distance of matched string */ - int lc; /* match length or unmatched char (if dist == 0) */ - unsigned lx = 0; /* running index in l_buf */ - unsigned code; /* the code to send */ - int extra; /* number of extra bits to send */ - - if (s->last_lit != 0) do { - dist = s->d_buf[lx]; - lc = s->l_buf[lx++]; - if (dist == 0) { - send_code(s, lc, ltree); /* send a literal byte */ - Tracecv(isgraph(lc), (stderr," '%c' ", lc)); - } else { - /* Here, lc is the match length - MIN_MATCH */ - code = _length_code[lc]; - send_code(s, code+LITERALS+1, ltree); /* send the length code */ - extra = extra_lbits[code]; - if (extra != 0) { - lc -= base_length[code]; - send_bits(s, lc, extra); /* send the extra length bits */ - } - dist--; /* dist is now the match distance - 1 */ - code = d_code(dist); - Assert (code < D_CODES, "bad d_code"); - - send_code(s, code, dtree); /* send the distance code */ - extra = extra_dbits[code]; - if (extra != 0) { - dist -= base_dist[code]; - send_bits(s, dist, extra); /* send the extra distance bits */ - } - } /* literal or match pair ? */ - - /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ - Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, - "pendingBuf overflow"); - - } while (lx < s->last_lit); - - send_code(s, END_BLOCK, ltree); - s->last_eob_len = ltree[END_BLOCK].Len; -} - -/* =========================================================================== - * Check if the data type is TEXT or BINARY, using the following algorithm: - * - TEXT if the two conditions below are satisfied: - * a) There are no non-portable control characters belonging to the - * "black list" (0..6, 14..25, 28..31). - * b) There is at least one printable character belonging to the - * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). - * - BINARY otherwise. - * - The following partially-portable control characters form a - * "gray list" that is ignored in this detection algorithm: - * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). - * IN assertion: the fields Freq of dyn_ltree are set. - */ -local int detect_data_type(deflate_state *s) -{ - /* black_mask is the bit mask of black-listed bytes - * set bits 0..6, 14..25, and 28..31 - * 0xf3ffc07f = binary 11110011111111111100000001111111 - */ - unsigned long black_mask = 0xf3ffc07fUL; - int n; - - /* Check for non-textual ("black-listed") bytes. */ - for (n = 0; n <= 31; n++, black_mask >>= 1) - if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) - return Z_BINARY; - - /* Check for textual ("white-listed") bytes. */ - if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 - || s->dyn_ltree[13].Freq != 0) - return Z_TEXT; - for (n = 32; n < LITERALS; n++) - if (s->dyn_ltree[n].Freq != 0) - return Z_TEXT; - - /* There are no "black-listed" or "white-listed" bytes: - * this stream either is empty or has tolerated ("gray-listed") bytes only. - */ - return Z_BINARY; -} - -/* =========================================================================== - * Reverse the first len bits of a code, using straightforward code (a faster - * method would use a table) - * IN assertion: 1 <= len <= 15 - */ -local unsigned bi_reverse(unsigned code /* the value to invert */, int len /* its bit length */) -{ - register unsigned res = 0; - do { - res |= code & 1; - code >>= 1, res <<= 1; - } while (--len > 0); - return res >> 1; -} - -/* =========================================================================== - * Flush the bit buffer, keeping at most 7 bits in it. - */ -local void bi_flush(deflate_state *s) -{ - if (s->bi_valid == 16) { - put_short(s, s->bi_buf); - s->bi_buf = 0; - s->bi_valid = 0; - } else if (s->bi_valid >= 8) { - put_byte(s, (Byte)s->bi_buf); - s->bi_buf >>= 8; - s->bi_valid -= 8; - } -} - -/* =========================================================================== - * Flush the bit buffer and align the output on a byte boundary - */ -local void bi_windup(deflate_state *s) -{ - if (s->bi_valid > 8) { - put_short(s, s->bi_buf); - } else if (s->bi_valid > 0) { - put_byte(s, (Byte)s->bi_buf); - } - s->bi_buf = 0; - s->bi_valid = 0; -#ifdef DEBUG - s->bits_sent = (s->bits_sent+7) & ~7; -#endif -} - -/* =========================================================================== - * Copy a stored block, storing first the length and its - * one's complement if requested. - */ -local void copy_block(deflate_state *s, charf *buf /* the input data */, unsigned len /* its length */, int header /* true if block header must be written */) -{ - bi_windup(s); /* align on byte boundary */ - s->last_eob_len = 8; /* enough lookahead for inflate */ - - if (header) { - put_short(s, (ush)len); - put_short(s, (ush)~len); -#ifdef DEBUG - s->bits_sent += 2*16; -#endif - } -#ifdef DEBUG - s->bits_sent += (ulg)len<<3; -#endif - while (len--) { - put_byte(s, *buf++); - } -} diff --git a/source/libz/uncompr.c b/source/libz/uncompr.c deleted file mode 100644 index fccdeb5..0000000 --- a/source/libz/uncompr.c +++ /dev/null @@ -1,55 +0,0 @@ -/* uncompr.c -- decompress a memory buffer - * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#define ZLIB_INTERNAL -#include "zlib.h" - -/* =========================================================================== - 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 compressed 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. -*/ -int ZEXPORT uncompress (Bytef * dest, uLongf * destLen, const Bytef * source, uLong sourceLen) -{ - z_stream stream; - int err; - - stream.next_in = (Bytef*)source; - stream.avail_in = (uInt)sourceLen; - /* Check for source > 64K on 16-bit machine: */ - if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; - - stream.next_out = dest; - stream.avail_out = (uInt)*destLen; - if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; - - stream.zalloc = (alloc_func)0; - stream.zfree = (free_func)0; - - err = inflateInit(&stream); - if (err != Z_OK) return err; - - err = inflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { - inflateEnd(&stream); - if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) - return Z_DATA_ERROR; - return err; - } - *destLen = stream.total_out; - - err = inflateEnd(&stream); - return err; -} diff --git a/source/libz/zutil.c b/source/libz/zutil.c deleted file mode 100644 index b78566f..0000000 --- a/source/libz/zutil.c +++ /dev/null @@ -1,304 +0,0 @@ -/* zutil.c -- target dependent utility functions for the compression library - * Copyright (C) 1995-2005, 2010 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#include "zutil.h" - -#ifndef NO_DUMMY_DECL -struct internal_state {int dummy;}; /* for buggy compilers */ -#endif - -const char * const z_errmsg[10] = { -"need dictionary", /* Z_NEED_DICT 2 */ -"stream end", /* Z_STREAM_END 1 */ -"", /* Z_OK 0 */ -"file error", /* Z_ERRNO (-1) */ -"stream error", /* Z_STREAM_ERROR (-2) */ -"data error", /* Z_DATA_ERROR (-3) */ -"insufficient memory", /* Z_MEM_ERROR (-4) */ -"buffer error", /* Z_BUF_ERROR (-5) */ -"incompatible version",/* Z_VERSION_ERROR (-6) */ -""}; - - -const char * ZEXPORT zlibVersion() -{ - return ZLIB_VERSION; -} - -uLong ZEXPORT zlibCompileFlags() -{ - uLong flags; - - flags = 0; - switch ((int)(sizeof(uInt))) { - case 2: break; - case 4: flags += 1; break; - case 8: flags += 2; break; - default: flags += 3; - } - switch ((int)(sizeof(uLong))) { - case 2: break; - case 4: flags += 1 << 2; break; - case 8: flags += 2 << 2; break; - default: flags += 3 << 2; - } - switch ((int)(sizeof(voidpf))) { - case 2: break; - case 4: flags += 1 << 4; break; - case 8: flags += 2 << 4; break; - default: flags += 3 << 4; - } - switch ((int)(sizeof(z_off_t))) { - case 2: break; - case 4: flags += 1 << 6; break; - case 8: flags += 2 << 6; break; - default: flags += 3 << 6; - } -#ifdef DEBUG - flags += 1 << 8; -#endif -#if defined(ASMV) || defined(ASMINF) - flags += 1 << 9; -#endif -#ifdef ZLIB_WINAPI - flags += 1 << 10; -#endif -#ifdef BUILDFIXED - flags += 1 << 12; -#endif -#ifdef DYNAMIC_CRC_TABLE - flags += 1 << 13; -#endif -#ifdef NO_GZCOMPRESS - flags += 1L << 16; -#endif -#ifdef NO_GZIP - flags += 1L << 17; -#endif -#ifdef PKZIP_BUG_WORKAROUND - flags += 1L << 20; -#endif -#ifdef FASTEST - flags += 1L << 21; -#endif -#ifdef STDC -# ifdef NO_vsnprintf - flags += 1L << 25; -# ifdef HAS_vsprintf_void - flags += 1L << 26; -# endif -# else -# ifdef HAS_vsnprintf_void - flags += 1L << 26; -# endif -# endif -#else - flags += 1L << 24; -# ifdef NO_snprintf - flags += 1L << 25; -# ifdef HAS_sprintf_void - flags += 1L << 26; -# endif -# else -# ifdef HAS_snprintf_void - flags += 1L << 26; -# endif -# endif -#endif - return flags; -} - -#ifdef DEBUG - -# ifndef verbose -# define verbose 0 -# endif -int ZLIB_INTERNAL z_verbose = verbose; - -void ZLIB_INTERNAL z_error (m) - char *m; -{ - fprintf(stderr, "%s\n", m); - exit(1); -} -#endif - -/* exported to allow conversion of error code to string for compress() and - * uncompress() - */ -const char * ZEXPORT zError(int err) -{ - return ERR_MSG(err); -} - -#if defined(_WIN32_WCE) - /* The Microsoft C Run-Time Library for Windows CE doesn't have - * errno. We define it as a global variable to simplify porting. - * Its value is always 0 and should not be used. - */ - int errno = 0; -#endif - -#ifndef HAVE_MEMCPY - -void ZLIB_INTERNAL zmemcpy(Bytef* dest, const Bytef* source, uInt len) -{ - if (len == 0) return; - do { - *dest++ = *source++; /* ??? to be unrolled */ - } while (--len != 0); -} - -int ZLIB_INTERNAL zmemcmp(const Bytef* s1, const Bytef* s2, uInt len) -{ - uInt j; - - for (j = 0; j < len; j++) { - if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; - } - return 0; -} - -void ZLIB_INTERNAL zmemzero(Bytef* dest, uInt len) -{ - if (len == 0) return; - do { - *dest++ = 0; /* ??? to be unrolled */ - } while (--len != 0); -} -#endif - - -#ifdef SYS16BIT - -#ifdef __TURBOC__ -/* Turbo C in 16-bit mode */ - -# define MY_ZCALLOC - -/* Turbo C malloc() does not allow dynamic allocation of 64K bytes - * and farmalloc(64K) returns a pointer with an offset of 8, so we - * must fix the pointer. Warning: the pointer must be put back to its - * original form in order to free it, use zcfree(). - */ - -#define MAX_PTR 10 -/* 10*64K = 640K */ - -local int next_ptr = 0; - -typedef struct ptr_table_s { - voidpf org_ptr; - voidpf new_ptr; -} ptr_table; - -local ptr_table table[MAX_PTR]; -/* This table is used to remember the original form of pointers - * to large buffers (64K). Such pointers are normalized with a zero offset. - * Since MSDOS is not a preemptive multitasking OS, this table is not - * protected from concurrent access. This hack doesn't work anyway on - * a protected system like OS/2. Use Microsoft C instead. - */ - -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) -{ - voidpf buf = opaque; /* just to make some compilers happy */ - ulg bsize = (ulg)items*size; - - /* If we allocate less than 65520 bytes, we assume that farmalloc - * will return a usable pointer which doesn't have to be normalized. - */ - if (bsize < 65520L) { - buf = farmalloc(bsize); - if (*(ush*)&buf != 0) return buf; - } else { - buf = farmalloc(bsize + 16L); - } - if (buf == NULL || next_ptr >= MAX_PTR) return NULL; - table[next_ptr].org_ptr = buf; - - /* Normalize the pointer to seg:0 */ - *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; - *(ush*)&buf = 0; - table[next_ptr++].new_ptr = buf; - return buf; -} - -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) -{ - int n; - if (*(ush*)&ptr != 0) { /* object < 64K */ - farfree(ptr); - return; - } - /* Find the original pointer */ - for (n = 0; n < next_ptr; n++) { - if (ptr != table[n].new_ptr) continue; - - farfree(table[n].org_ptr); - while (++n < next_ptr) { - table[n-1] = table[n]; - } - next_ptr--; - return; - } - ptr = opaque; /* just to make some compilers happy */ - Assert(0, "zcfree: ptr not found"); -} - -#endif /* __TURBOC__ */ - - -#ifdef M_I86 -/* Microsoft C in 16-bit mode */ - -# define MY_ZCALLOC - -#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) -# define _halloc halloc -# define _hfree hfree -#endif - -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) -{ - if (opaque) opaque = 0; /* to make compiler happy */ - return _halloc((long)items, size); -} - -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) -{ - if (opaque) opaque = 0; /* to make compiler happy */ - _hfree(ptr); -} - -#endif /* M_I86 */ - -#endif /* SYS16BIT */ - - -#ifndef MY_ZCALLOC /* Any system without a special alloc function */ - -#ifndef STDC -extern voidp malloc OF((uInt size)); -extern voidp calloc OF((uInt items, uInt size)); -extern void free OF((voidpf ptr)); -#endif - -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) -{ - if (opaque) items += size - size; /* make compiler happy */ - return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : - (voidpf)calloc(items, size); -} - -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) -{ - free(ptr); - if (opaque) return; /* make compiler happy */ -} - -#endif /* MY_ZCALLOC */ diff --git a/source/orbislink/orbislink.c b/source/orbislink/orbislink.c deleted file mode 100644 index bc31914..0000000 --- a/source/orbislink/orbislink.c +++ /dev/null @@ -1,1069 +0,0 @@ -/* -# ____ ____ ____ ___ ____ ____ _ _ -# | | ____> ____> | | | <____ \ / -# |____| | \ ____> | ___| ____| <____ \_/ ORBISDEV Open Source Project. -#------------------------------------------------------------------------------------ -# Copyright 2010-2020, orbisdev - http://orbisdev.github.io -# Licenced under MIT license -# Review README & LICENSE files for further details. -*/ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -OrbisGlobalConf globalConf; -int padEnabled; -int orbisGlEnabled; -int audioEnabled; -int msxEnabled; -int audioSamples; -int audioFrequency; -int audioFormat; -int keyboardEnabled; -int orbisNfsEnabled=0; -//#define SCE_LIBC_HEAP_SIZE_EXTENDED_ALLOC_NO_LIMIT (0xffffffffffffffffUL) -//extern size_t sceLibcHeapSize=0xffffffffffffffffUL; -//extern unsigned int sceLibcHeapExtendedAlloc=1; - -#define PIGLET_MODULE_NAME "libScePigletv2VSH.sprx" -#define SHCOMP_MODULE_NAME "libSceShaccVSH.sprx" -#define FSELF_NAME "homebrew.self" -#define ORBISLINK_TCP_PORT 18193 - -//#if 1 -//# define MODULE_PATH_PREFIX "/app0/sce_module" -//#else -#define MODULE_PATH_PREFIX "/data/self/system/common/lib" -//#endif - -static int s_piglet_module = -1; -static int s_shcomp_module = -1; - -const char* g_sandbox_word=NULL; -typedef void module_patch_cb_t(void* arg, uint8_t* base, uint64_t size); - -bool get_module_base(const char* name, uint64_t* base, uint64_t* size, int level) -{ - SceKernelModuleInfo moduleInfo; - int ret; - - ret = sceKernelGetModuleInfoByName(name, &moduleInfo); - if (ret) { - debugNetPrintf(level,"[ORBISLINK] %s sceKernelGetModuleInfoByName(%s) failed: 0x%08X\n",__FUNCTION__,name,ret); - goto err; - } - - if (base) { - *base = (uint64_t)moduleInfo.segmentInfo[0].address; - } - if (size) { - *size = moduleInfo.segmentInfo[0].size; - } - - return true; - -err: - return false; -} - -bool patch_module(const char* name, module_patch_cb_t* cb, void* arg,int level) { - uint64_t base, size; - int ret; - - if (!get_module_base(name, &base, &size,level)) { - debugNetPrintf(level,"[ORBISLINK] %s get_module_base return error\n",__FUNCTION__); - goto err; - } - debugNetPrintf(level,"[ORBISLINK] %s module base=0x%08X size=%ld\n",__FUNCTION__,base,size); - - ret = sceKernelMprotect((void*)base, size, PROT_READ | PROT_WRITE | PROT_EXEC); - if (ret) { - debugNetPrintf(level,"[ORBISLINK] %s sceKernelMprotect(%s) failed: 0x%08X\n",__FUNCTION__,name,ret); - goto err; - } - debugNetPrintf(level,"[ORBISLINK] %s patching module\n",__FUNCTION__); - - if (cb) { - (*cb)(arg, (uint8_t*)base, size); - } - - return true; - -err: - return false; -} - -void unloadPigletModules(int level) -{ - int ret; - - if (s_shcomp_module > 0) - { - ret=sceKernelStopUnloadModule(s_shcomp_module,0,NULL,0,NULL,NULL); - if (ret < 0) - { - debugNetPrintf(level,"[ORBISLINK] %s sceKernelStopUnloadModule(%s) failed: 0x%08X\n",__FUNCTION__,SHCOMP_MODULE_NAME,ret); - } - else - { - s_shcomp_module=-1; - } - } - - if (s_piglet_module>0) - { - ret=sceKernelStopUnloadModule(s_piglet_module,0,NULL,0,NULL,NULL); - if(ret<0) - { - debugNetPrintf(level,"[ORBISLINK] %s sceKernelStopUnloadModule(%s) failed: 0x%08X\n",__FUNCTION__,PIGLET_MODULE_NAME,ret); - } - else - { - s_piglet_module=-1; - } - } -} -int loadPigletModules(int flagPiglet,int level) -{ - int ret; - if(flagPiglet>0) - { - ret=sceKernelLoadStartModule(MODULE_PATH_PREFIX "/" PIGLET_MODULE_NAME,0,NULL,0,NULL,NULL); - if(ret<0) - { - debugNetPrintf(level,"[ORBISLINK] %s sceKernelLoadStartModule(%s) failed: 0x%08X\n",__FUNCTION__,PIGLET_MODULE_NAME,ret); - goto err; - } - s_piglet_module=ret; - debugNetPrintf(level,"[ORBISLINK] %s sceKernelLoadStartModule(%s) return id: %d\n",__FUNCTION__,PIGLET_MODULE_NAME,ret); - - if(flagPiglet>=2) - { - ret=sceKernelLoadStartModule(MODULE_PATH_PREFIX "/" SHCOMP_MODULE_NAME,0,NULL,0,NULL,NULL); - if (ret<0) - { - debugNetPrintf(level,"[ORBISLINK] %s sceKernelLoadStartModule(%s) failed: 0x%08X\n",__FUNCTION__,SHCOMP_MODULE_NAME,ret); - goto err; - } - s_shcomp_module = ret; - debugNetPrintf(level,"[ORBISLINK] %s sceKernelLoadStartModule(%s) return id: %d\n",__FUNCTION__,SHCOMP_MODULE_NAME,ret); - return 2; - } - return 1; - } - err: - return -1; -} -/* XXX: patches below are given for Piglet module from 4.74 Devkit PUP */ -static void pgl_patches_cb(void* arg, uint8_t* base, uint64_t size) -{ - /* Patch runtime compiler check */ - const uint8_t p_set_eax_to_1[] = { - 0x31, 0xC0, 0xFF, 0xC0, 0x90, - }; - memcpy(base + 0x5451F, p_set_eax_to_1, sizeof(p_set_eax_to_1)); - - /* Tell that runtime compiler exists */ - *(uint8_t*)(base + 0xB2DEC) = 0; - *(uint8_t*)(base + 0xB2DED) = 0; - *(uint8_t*)(base + 0xB2DEE) = 1; - *(uint8_t*)(base + 0xB2E21) = 1; - - /* Inform Piglet that we have shader compiler module loaded */ - *(int32_t*)(base + 0xB2E24) = s_shcomp_module; -} - -static bool do_patches(int level) -{ - if (!patch_module(PIGLET_MODULE_NAME, &pgl_patches_cb, NULL,level)) - { - debugNetPrintf(level,"[ORBISLINK] %s Unable to patch PGL module.\n",__FUNCTION__); - return false; - } - return true; -} - -static void cleanup(void) -{ - unloadPigletModules(DEBUGNET_DEBUG); - - int ret = sceSysmoduleUnloadModuleInternal(SCE_SYSMODULE_INTERNAL_SYSTEM_SERVICE); - if (ret) - { - debugNetPrintf(3,"[ORBISLINK] %s sceSysmoduleUnloadModuleInternal(%s) failed: 0x%08X\n",__FUNCTION__,"SCE_SYSMODULE_INTERNAL_SYSTEM_SERVICE", ret); - } -} - -void finishOrbisLinkApp(void) -{ - cleanup(); - - if(audioEnabled) orbisAudioFinish(); - if(keyboardEnabled) orbisKeyboardFinish(); - if(padEnabled) orbisPadFinish(); - if(orbisNfsEnabled) orbisNfsFinish(); -} - -int orbisLinkCreateSelfDirectories() -{ - struct stat sb; - int ret; - ret=sceKernelStat("/data/self/system/common/lib",&sb); - if(ret!=0) - { - ret=sceKernelMkdir("/data/self",0777); - if(ret!=0 && ret!=0x80020011) - { - return -1; - } - ret=sceKernelMkdir("/data/self/system",0777); - if(ret!=0 && ret!=0x80020011) - { - return -1; - } - ret=sceKernelMkdir("/data/self/system/common",0777); - if(ret!=0 && ret!=0x80020011) - { - return -1; - } - ret=sceKernelMkdir("/data/self/system/common/lib",0777); - if(ret!=0 && ret!=0x80020011) - { - return -1; - } - - } - return 0; -} -int orbisLinkCreateConfigDirectory( const char *path) -{ - int ret; - struct stat sb; - ret=sceKernelStat(path, &sb); - if(ret!=0) - { - ret=sceKernelMkdir(path,0777); - if(ret!=0) - { - return -1; - } - } - return 0; -} -int orbisLinkUploadPigletModules() -{ - struct stat sb; - int ret; - int fd; - int size_piglet; - int size_shcomp; - unsigned char* piglet_mod=NULL; - unsigned char* shcomp_mod=NULL; - ret=sceKernelStat(MODULE_PATH_PREFIX "/" PIGLET_MODULE_NAME,&sb); - if(ret!=0) - { - fd=orbisNfsOpen(PIGLET_MODULE_NAME,O_RDONLY, 0777); - if(fd<0) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s error opening %s module from your nfs server\n",__FUNCTION__,PIGLET_MODULE_NAME); - return -1; - } - size_piglet=orbisNfsLseek(fd,0,SEEK_END); - orbisNfsLseek(fd,0,SEEK_SET); - if(size_piglet<0) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s Failed to read size of file %s\n",__FUNCTION__,PIGLET_MODULE_NAME); - orbisNfsClose(fd); - return -1; - } - piglet_mod=malloc(sizeof(unsigned char)*size_piglet); - if(piglet_mod==NULL) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s Failed to allocate %d bytes\n",__FUNCTION__,size_piglet); - orbisNfsClose(fd); - return -1; - } - ret=orbisNfsRead(fd,piglet_mod,size_piglet); - if(ret!=size_piglet) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s Failed to read content of file %s\n",__FUNCTION__,PIGLET_MODULE_NAME); - orbisNfsClose(fd); - free(piglet_mod); - return -1; - } - orbisNfsClose(fd); - fd=-1; - fd=sceKernelOpen(MODULE_PATH_PREFIX "/" PIGLET_MODULE_NAME,O_WRONLY|O_CREAT|O_TRUNC,0777); - if(fd<0) - { - debugNetPrintf(3,"[ORBISLINK %s error sceKernelOpen err 0x%08X opening %s\n",__FUNCTION__,fd,PIGLET_MODULE_NAME); - return -1; - } - ret=sceKernelWrite(fd,piglet_mod,size_piglet); - if(ret!=size_piglet) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s sceKernelWrite err 0x%08X to write content of file %s\n",__FUNCTION__,ret,PIGLET_MODULE_NAME); - sceKernelClose(fd); - free(piglet_mod); - return -1; - } - sceKernelClose(fd); - sceKernelSync(); - free(piglet_mod); - - } - debugNetPrintf(DEBUGNET_DEBUG,"[ORBISLINK] %s %s module already on PlayStation file system\n",__FUNCTION__,PIGLET_MODULE_NAME); - fd=-1; - ret=sceKernelStat(MODULE_PATH_PREFIX "/" SHCOMP_MODULE_NAME,&sb); - if(ret!=0) - { - fd=orbisNfsOpen(SHCOMP_MODULE_NAME,O_RDONLY, 0777); - if(fd<0) - { - debugNetPrintf(3,"[ORBISLINK %s error opening %s module from your nfs server\n",__FUNCTION__,SHCOMP_MODULE_NAME); - } - size_shcomp=orbisNfsLseek(fd,0,SEEK_END); - orbisNfsLseek(fd,0,SEEK_SET); - if(size_shcomp<0) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s Failed to read size of file %s\n",__FUNCTION__,SHCOMP_MODULE_NAME); - orbisNfsClose(fd); - return -1; - } - shcomp_mod=malloc(sizeof(unsigned char)*size_shcomp); - if(shcomp_mod==NULL) - { - debugNetPrintf(DEBUGNET_ERROR,"[ORBISLINK] %s Failed to allocate %d bytes\n",__FUNCTION__,size_shcomp); - orbisNfsClose(fd); - return -1; - } - int numread=size_shcomp/(1024*1024); - int lastread=size_shcomp%(1024*1024); - int i,j; - for(j=0;j=1024*1024) - { - int numread=size/(1024*1024); - int lastread=size%(1024*1024); - int i,j; - for(j=0;j 0) - { - s += length; - if(s == full) - { - void *t; - full *= 2; - t = realloc(data, full); - if(t == NULL) - { - free(data); - return -1; - } - data = t; - } - } - //debugNetPrintf(3,"[ORBISLINK] %s read done\n",__FUNCTION__); - - //debugNetPrintf(3,"[ORBISLINK] %s %s\n",__FUNCTION__,data); - - int fd=sceKernelOpen("/data/orbislink/orbislink_config.ini",O_WRONLY|O_CREAT|O_TRUNC,0666); - if(fd<0) - { - //debugNetPrintf(3,"[ORBISLINK] %s error opening for write 0x%08X\n",__FUNCTION__,fd); - - return -1; - } - ret=sceKernelWrite(fd,data,s); - if(ret=0) - { - - - - debugNetPrintf(3,"[ORBISLINK] %s ready tp loading homebrew.elf\n",__FUNCTION__); - //orbisExecUserElf(); - - while(!orbisLinkGetGlobalConf()->orbisLinkFlag) - { - - } - } - else - { - debugNetPrintf(3,"[ORBISLINK] %s something wrong happen initOrbisLinkApp return 0x%8x %d \n",__FUNCTION__,ret,ret); - debugNetPrintf(3,"[ORBISLINK] %s Exiting\n",__FUNCTION__); - - } - - finishOrbisLinkApp(); - - exit(0); - - return 0; -} -void catchReturnFromMain(int exit_code) { -}*/ -