Check-in [40d223588a]
Overview
Comment:Added first attempt at Win64 build support
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1:40d223588a245c4dd3180a5c3a7fbc583dd0f40e
User & Date: rkeene on 2012-07-19 04:00:17
Other Links: manifest | tags
Context
2012-07-19
05:19
Updated to deal with newer versions of mingw32 check-in: d0b5ea65f9 user: rkeene tags: trunk
04:00
Added first attempt at Win64 build support check-in: 40d223588a user: rkeene tags: trunk
2012-05-09
16:38
Updated to print attribute type as string in lookups

Updated to include public key objects for DoD certificates check-in: 638b5f52a7 user: rkeene tags: trunk

Changes

Added build/cackey_win64_build/build.sh version [3415fb284b].

            1  +#! /bin/bash
            2  +
            3  +make distclean
            4  +
            5  +cp "./build/cackey_win64_build/lib/winscard.dll" "./build/cackey_win64_build/lib/WinSCard.dll"
            6  +
            7  +./configure --with-pcsc-headers="$(pwd)/build/cackey_win64_build/include" --with-pcsc-libs="-L$(pwd)/build/cackey_win64_build/lib -lwinscard" --host=amd64-mingw32msvc CPPFLAGS="-I$(pwd)/build/cackey_win64_build/include" || exit 1
            8  +
            9  +make || exit 1
           10  +
           11  +rm -f "./build/cackey_win64_build/lib/WinSCard.dll"
           12  +
           13  +exit 0

Added build/cackey_win64_build/include/SCardErr.h version [969de80f85].

            1  +/*
            2  + scarderr.mc
            3  +
            4  +   Error message codes from the Smart Card Resource Manager
            5  +   These messages must be reconciled with winerror.w
            6  +   They exist here to provide error messages on pre-Win2K systems.
            7  +
            8  +*/
            9  +#ifndef SCARD_S_SUCCESS
           10  +//
           11  +// =============================
           12  +// Facility SCARD Error Messages
           13  +// =============================
           14  +//
           15  +#define SCARD_S_SUCCESS NO_ERROR
           16  +//
           17  +//  Values are 32 bit values laid out as follows:
           18  +//
           19  +//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
           20  +//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
           21  +//  +---+-+-+-----------------------+-------------------------------+
           22  +//  |Sev|C|R|     Facility          |               Code            |
           23  +//  +---+-+-+-----------------------+-------------------------------+
           24  +//
           25  +//  where
           26  +//
           27  +//      Sev - is the severity code
           28  +//
           29  +//          00 - Success
           30  +//          01 - Informational
           31  +//          10 - Warning
           32  +//          11 - Error
           33  +//
           34  +//      C - is the Customer code flag
           35  +//
           36  +//      R - is a reserved bit
           37  +//
           38  +//      Facility - is the facility code
           39  +//
           40  +//      Code - is the facility's status code
           41  +//
           42  +//
           43  +// Define the facility codes
           44  +//
           45  +#define FACILITY_SYSTEM                  0x0
           46  +#define FACILITY_SCARD                   0x10
           47  +
           48  +
           49  +//
           50  +// Define the severity codes
           51  +//
           52  +#define STATUS_SEVERITY_WARNING          0x2
           53  +#define STATUS_SEVERITY_INFORMATIONAL    0x1
           54  +#define STATUS_SEVERITY_ERROR            0x3
           55  +
           56  +
           57  +//
           58  +// MessageId: SCARD_F_INTERNAL_ERROR
           59  +//
           60  +// MessageText:
           61  +//
           62  +// An internal consistency check failed.
           63  +//
           64  +#define SCARD_F_INTERNAL_ERROR           ((DWORD)0x80100001L)
           65  +
           66  +//
           67  +// MessageId: SCARD_E_CANCELLED
           68  +//
           69  +// MessageText:
           70  +//
           71  +// The action was cancelled by an SCardCancel request.
           72  +//
           73  +#define SCARD_E_CANCELLED                ((DWORD)0x80100002L)
           74  +
           75  +//
           76  +// MessageId: SCARD_E_INVALID_HANDLE
           77  +//
           78  +// MessageText:
           79  +//
           80  +// The supplied handle was invalid.
           81  +//
           82  +#define SCARD_E_INVALID_HANDLE           ((DWORD)0x80100003L)
           83  +
           84  +//
           85  +// MessageId: SCARD_E_INVALID_PARAMETER
           86  +//
           87  +// MessageText:
           88  +//
           89  +// One or more of the supplied parameters could not be properly interpreted.
           90  +//
           91  +#define SCARD_E_INVALID_PARAMETER        ((DWORD)0x80100004L)
           92  +
           93  +//
           94  +// MessageId: SCARD_E_INVALID_TARGET
           95  +//
           96  +// MessageText:
           97  +//
           98  +// Registry startup information is missing or invalid.
           99  +//
          100  +#define SCARD_E_INVALID_TARGET           ((DWORD)0x80100005L)
          101  +
          102  +//
          103  +// MessageId: SCARD_E_NO_MEMORY
          104  +//
          105  +// MessageText:
          106  +//
          107  +// Not enough memory available to complete this command.
          108  +//
          109  +#define SCARD_E_NO_MEMORY                ((DWORD)0x80100006L)
          110  +
          111  +//
          112  +// MessageId: SCARD_F_WAITED_TOO_LONG
          113  +//
          114  +// MessageText:
          115  +//
          116  +// An internal consistency timer has expired.
          117  +//
          118  +#define SCARD_F_WAITED_TOO_LONG          ((DWORD)0x80100007L)
          119  +
          120  +//
          121  +// MessageId: SCARD_E_INSUFFICIENT_BUFFER
          122  +//
          123  +// MessageText:
          124  +//
          125  +// The data buffer to receive returned data is too small for the returned data.
          126  +//
          127  +#define SCARD_E_INSUFFICIENT_BUFFER      ((DWORD)0x80100008L)
          128  +
          129  +//
          130  +// MessageId: SCARD_E_UNKNOWN_READER
          131  +//
          132  +// MessageText:
          133  +//
          134  +// The specified reader name is not recognized.
          135  +//
          136  +#define SCARD_E_UNKNOWN_READER           ((DWORD)0x80100009L)
          137  +
          138  +//
          139  +// MessageId: SCARD_E_TIMEOUT
          140  +//
          141  +// MessageText:
          142  +//
          143  +// The user-specified timeout value has expired.
          144  +//
          145  +#define SCARD_E_TIMEOUT                  ((DWORD)0x8010000AL)
          146  +
          147  +//
          148  +// MessageId: SCARD_E_SHARING_VIOLATION
          149  +//
          150  +// MessageText:
          151  +//
          152  +// The smart card cannot be accessed because of other connections outstanding.
          153  +//
          154  +#define SCARD_E_SHARING_VIOLATION        ((DWORD)0x8010000BL)
          155  +
          156  +//
          157  +// MessageId: SCARD_E_NO_SMARTCARD
          158  +//
          159  +// MessageText:
          160  +//
          161  +// The operation requires a Smart Card, but no Smart Card is currently in the device.
          162  +//
          163  +#define SCARD_E_NO_SMARTCARD             ((DWORD)0x8010000CL)
          164  +
          165  +//
          166  +// MessageId: SCARD_E_UNKNOWN_CARD
          167  +//
          168  +// MessageText:
          169  +//
          170  +// The specified smart card name is not recognized.
          171  +//
          172  +#define SCARD_E_UNKNOWN_CARD             ((DWORD)0x8010000DL)
          173  +
          174  +//
          175  +// MessageId: SCARD_E_CANT_DISPOSE
          176  +//
          177  +// MessageText:
          178  +//
          179  +// The system could not dispose of the media in the requested manner.
          180  +//
          181  +#define SCARD_E_CANT_DISPOSE             ((DWORD)0x8010000EL)
          182  +
          183  +//
          184  +// MessageId: SCARD_E_PROTO_MISMATCH
          185  +//
          186  +// MessageText:
          187  +//
          188  +// The requested protocols are incompatible with the protocol currently in use with the smart card.
          189  +//
          190  +#define SCARD_E_PROTO_MISMATCH           ((DWORD)0x8010000FL)
          191  +
          192  +//
          193  +// MessageId: SCARD_E_NOT_READY
          194  +//
          195  +// MessageText:
          196  +//
          197  +// The reader or smart card is not ready to accept commands.
          198  +//
          199  +#define SCARD_E_NOT_READY                ((DWORD)0x80100010L)
          200  +
          201  +//
          202  +// MessageId: SCARD_E_INVALID_VALUE
          203  +//
          204  +// MessageText:
          205  +//
          206  +// One or more of the supplied parameters values could not be properly interpreted.
          207  +//
          208  +#define SCARD_E_INVALID_VALUE            ((DWORD)0x80100011L)
          209  +
          210  +//
          211  +// MessageId: SCARD_E_SYSTEM_CANCELLED
          212  +//
          213  +// MessageText:
          214  +//
          215  +// The action was cancelled by the system, presumably to log off or shut down.
          216  +//
          217  +#define SCARD_E_SYSTEM_CANCELLED         ((DWORD)0x80100012L)
          218  +
          219  +//
          220  +// MessageId: SCARD_F_COMM_ERROR
          221  +//
          222  +// MessageText:
          223  +//
          224  +// An internal communications error has been detected.
          225  +//
          226  +#define SCARD_F_COMM_ERROR               ((DWORD)0x80100013L)
          227  +
          228  +//
          229  +// MessageId: SCARD_F_UNKNOWN_ERROR
          230  +//
          231  +// MessageText:
          232  +//
          233  +// An internal error has been detected, but the source is unknown.
          234  +//
          235  +#define SCARD_F_UNKNOWN_ERROR            ((DWORD)0x80100014L)
          236  +
          237  +//
          238  +// MessageId: SCARD_E_INVALID_ATR
          239  +//
          240  +// MessageText:
          241  +//
          242  +// An ATR obtained from the registry is not a valid ATR string.
          243  +//
          244  +#define SCARD_E_INVALID_ATR              ((DWORD)0x80100015L)
          245  +
          246  +//
          247  +// MessageId: SCARD_E_NOT_TRANSACTED
          248  +//
          249  +// MessageText:
          250  +//
          251  +// An attempt was made to end a non-existent transaction.
          252  +//
          253  +#define SCARD_E_NOT_TRANSACTED           ((DWORD)0x80100016L)
          254  +
          255  +//
          256  +// MessageId: SCARD_E_READER_UNAVAILABLE
          257  +//
          258  +// MessageText:
          259  +//
          260  +// The specified reader is not currently available for use.
          261  +//
          262  +#define SCARD_E_READER_UNAVAILABLE       ((DWORD)0x80100017L)
          263  +
          264  +//
          265  +// MessageId: SCARD_P_SHUTDOWN
          266  +//
          267  +// MessageText:
          268  +//
          269  +// The operation has been aborted to allow the server application to exit.
          270  +//
          271  +#define SCARD_P_SHUTDOWN                 ((DWORD)0x80100018L)
          272  +
          273  +//
          274  +// MessageId: SCARD_E_PCI_TOO_SMALL
          275  +//
          276  +// MessageText:
          277  +//
          278  +// The PCI Receive buffer was too small.
          279  +//
          280  +#define SCARD_E_PCI_TOO_SMALL            ((DWORD)0x80100019L)
          281  +
          282  +//
          283  +// MessageId: SCARD_E_READER_UNSUPPORTED
          284  +//
          285  +// MessageText:
          286  +//
          287  +// The reader driver does not meet minimal requirements for support.
          288  +//
          289  +#define SCARD_E_READER_UNSUPPORTED       ((DWORD)0x8010001AL)
          290  +
          291  +//
          292  +// MessageId: SCARD_E_DUPLICATE_READER
          293  +//
          294  +// MessageText:
          295  +//
          296  +// The reader driver did not produce a unique reader name.
          297  +//
          298  +#define SCARD_E_DUPLICATE_READER         ((DWORD)0x8010001BL)
          299  +
          300  +//
          301  +// MessageId: SCARD_E_CARD_UNSUPPORTED
          302  +//
          303  +// MessageText:
          304  +//
          305  +// The smart card does not meet minimal requirements for support.
          306  +//
          307  +#define SCARD_E_CARD_UNSUPPORTED         ((DWORD)0x8010001CL)
          308  +
          309  +//
          310  +// MessageId: SCARD_E_NO_SERVICE
          311  +//
          312  +// MessageText:
          313  +//
          314  +// The Smart card resource manager is not running.
          315  +//
          316  +#define SCARD_E_NO_SERVICE               ((DWORD)0x8010001DL)
          317  +
          318  +//
          319  +// MessageId: SCARD_E_SERVICE_STOPPED
          320  +//
          321  +// MessageText:
          322  +//
          323  +// The Smart card resource manager has shut down.
          324  +//
          325  +#define SCARD_E_SERVICE_STOPPED          ((DWORD)0x8010001EL)
          326  +
          327  +//
          328  +// MessageId: SCARD_E_UNEXPECTED
          329  +//
          330  +// MessageText:
          331  +//
          332  +// An unexpected card error has occurred.
          333  +//
          334  +#define SCARD_E_UNEXPECTED               ((DWORD)0x8010001FL)
          335  +
          336  +//
          337  +// MessageId: SCARD_E_ICC_INSTALLATION
          338  +//
          339  +// MessageText:
          340  +//
          341  +// No Primary Provider can be found for the smart card.
          342  +//
          343  +#define SCARD_E_ICC_INSTALLATION         ((DWORD)0x80100020L)
          344  +
          345  +//
          346  +// MessageId: SCARD_E_ICC_CREATEORDER
          347  +//
          348  +// MessageText:
          349  +//
          350  +// The requested order of object creation is not supported.
          351  +//
          352  +#define SCARD_E_ICC_CREATEORDER          ((DWORD)0x80100021L)
          353  +
          354  +//
          355  +// MessageId: SCARD_E_UNSUPPORTED_FEATURE
          356  +//
          357  +// MessageText:
          358  +//
          359  +// This smart card does not support the requested feature.
          360  +//
          361  +#define SCARD_E_UNSUPPORTED_FEATURE      ((DWORD)0x80100022L)
          362  +
          363  +//
          364  +// MessageId: SCARD_E_DIR_NOT_FOUND
          365  +//
          366  +// MessageText:
          367  +//
          368  +// The identified directory does not exist in the smart card.
          369  +//
          370  +#define SCARD_E_DIR_NOT_FOUND            ((DWORD)0x80100023L)
          371  +
          372  +//
          373  +// MessageId: SCARD_E_FILE_NOT_FOUND
          374  +//
          375  +// MessageText:
          376  +//
          377  +// The identified file does not exist in the smart card.
          378  +//
          379  +#define SCARD_E_FILE_NOT_FOUND           ((DWORD)0x80100024L)
          380  +
          381  +//
          382  +// MessageId: SCARD_E_NO_DIR
          383  +//
          384  +// MessageText:
          385  +//
          386  +// The supplied path does not represent a smart card directory.
          387  +//
          388  +#define SCARD_E_NO_DIR                   ((DWORD)0x80100025L)
          389  +
          390  +//
          391  +// MessageId: SCARD_E_NO_FILE
          392  +//
          393  +// MessageText:
          394  +//
          395  +// The supplied path does not represent a smart card file.
          396  +//
          397  +#define SCARD_E_NO_FILE                  ((DWORD)0x80100026L)
          398  +
          399  +//
          400  +// MessageId: SCARD_E_NO_ACCESS
          401  +//
          402  +// MessageText:
          403  +//
          404  +// Access is denied to this file.
          405  +//
          406  +#define SCARD_E_NO_ACCESS                ((DWORD)0x80100027L)
          407  +
          408  +//
          409  +// MessageId: SCARD_E_WRITE_TOO_MANY
          410  +//
          411  +// MessageText:
          412  +//
          413  +// The smartcard does not have enough memory to store the information.
          414  +//
          415  +#define SCARD_E_WRITE_TOO_MANY           ((DWORD)0x80100028L)
          416  +
          417  +//
          418  +// MessageId: SCARD_E_BAD_SEEK
          419  +//
          420  +// MessageText:
          421  +//
          422  +// There was an error trying to set the smart card file object pointer.
          423  +//
          424  +#define SCARD_E_BAD_SEEK                 ((DWORD)0x80100029L)
          425  +
          426  +//
          427  +// MessageId: SCARD_E_INVALID_CHV
          428  +//
          429  +// MessageText:
          430  +//
          431  +// The supplied PIN is incorrect.
          432  +//
          433  +#define SCARD_E_INVALID_CHV              ((DWORD)0x8010002AL)
          434  +
          435  +//
          436  +// MessageId: SCARD_E_UNKNOWN_RES_MNG
          437  +//
          438  +// MessageText:
          439  +//
          440  +// An unrecognized error code was returned from a layered component.
          441  +//
          442  +#define SCARD_E_UNKNOWN_RES_MNG          ((DWORD)0x8010002BL)
          443  +
          444  +//
          445  +// MessageId: SCARD_E_NO_SUCH_CERTIFICATE
          446  +//
          447  +// MessageText:
          448  +//
          449  +// The requested certificate does not exist.
          450  +//
          451  +#define SCARD_E_NO_SUCH_CERTIFICATE      ((DWORD)0x8010002CL)
          452  +
          453  +//
          454  +// MessageId: SCARD_E_CERTIFICATE_UNAVAILABLE
          455  +//
          456  +// MessageText:
          457  +//
          458  +// The requested certificate could not be obtained.
          459  +//
          460  +#define SCARD_E_CERTIFICATE_UNAVAILABLE  ((DWORD)0x8010002DL)
          461  +
          462  +//
          463  +// MessageId: SCARD_E_NO_READERS_AVAILABLE
          464  +//
          465  +// MessageText:
          466  +//
          467  +// Cannot find a smart card reader.
          468  +//
          469  +#define SCARD_E_NO_READERS_AVAILABLE     ((DWORD)0x8010002EL)
          470  +
          471  +//
          472  +// MessageId: SCARD_E_COMM_DATA_LOST
          473  +//
          474  +// MessageText:
          475  +//
          476  +// A communications error with the smart card has been detected.  Retry the operation.
          477  +//
          478  +#define SCARD_E_COMM_DATA_LOST           ((DWORD)0x8010002FL)
          479  +
          480  +//
          481  +// MessageId: SCARD_E_NO_KEY_CONTAINER
          482  +//
          483  +// MessageText:
          484  +//
          485  +// The requested key container does not exist on the smart card.
          486  +//
          487  +#define SCARD_E_NO_KEY_CONTAINER         ((DWORD)0x80100030L)
          488  +
          489  +//
          490  +// MessageId: SCARD_E_SERVER_TOO_BUSY
          491  +//
          492  +// MessageText:
          493  +//
          494  +// The Smart card resource manager is too busy to complete this operation.
          495  +//
          496  +#define SCARD_E_SERVER_TOO_BUSY          ((DWORD)0x80100031L)
          497  +
          498  +//
          499  +// MessageId: SCARD_E_PIN_CACHE_EXPIRED
          500  +//
          501  +// MessageText:
          502  +//
          503  +// The smart card PIN cache has expired.
          504  +//
          505  +#define SCARD_E_PIN_CACHE_EXPIRED        ((DWORD)0x80100032L)
          506  +
          507  +//
          508  +// MessageId: SCARD_E_NO_PIN_CACHE
          509  +//
          510  +// MessageText:
          511  +//
          512  +// The smart card PIN cannot be cached.
          513  +//
          514  +#define SCARD_E_NO_PIN_CACHE             ((DWORD)0x80100033L)
          515  +
          516  +//
          517  +// MessageId: SCARD_E_READ_ONLY_CARD
          518  +//
          519  +// MessageText:
          520  +//
          521  +// The smart card is read only and cannot be written to.
          522  +//
          523  +#define SCARD_E_READ_ONLY_CARD           ((DWORD)0x80100034L)
          524  +
          525  +//
          526  +// These are warning codes.
          527  +//
          528  +//
          529  +// MessageId: SCARD_W_UNSUPPORTED_CARD
          530  +//
          531  +// MessageText:
          532  +//
          533  +// The reader cannot communicate with the smart card, due to ATR configuration conflicts.
          534  +//
          535  +#define SCARD_W_UNSUPPORTED_CARD         ((DWORD)0x80100065L)
          536  +
          537  +//
          538  +// MessageId: SCARD_W_UNRESPONSIVE_CARD
          539  +//
          540  +// MessageText:
          541  +//
          542  +// The smart card is not responding to a reset.
          543  +//
          544  +#define SCARD_W_UNRESPONSIVE_CARD        ((DWORD)0x80100066L)
          545  +
          546  +//
          547  +// MessageId: SCARD_W_UNPOWERED_CARD
          548  +//
          549  +// MessageText:
          550  +//
          551  +// Power has been removed from the smart card, so that further communication is not possible.
          552  +//
          553  +#define SCARD_W_UNPOWERED_CARD           ((DWORD)0x80100067L)
          554  +
          555  +//
          556  +// MessageId: SCARD_W_RESET_CARD
          557  +//
          558  +// MessageText:
          559  +//
          560  +// The smart card has been reset, so any shared state information is invalid.
          561  +//
          562  +#define SCARD_W_RESET_CARD               ((DWORD)0x80100068L)
          563  +
          564  +//
          565  +// MessageId: SCARD_W_REMOVED_CARD
          566  +//
          567  +// MessageText:
          568  +//
          569  +// The smart card has been removed, so that further communication is not possible.
          570  +//
          571  +#define SCARD_W_REMOVED_CARD             ((DWORD)0x80100069L)
          572  +
          573  +//
          574  +// MessageId: SCARD_W_SECURITY_VIOLATION
          575  +//
          576  +// MessageText:
          577  +//
          578  +// Access was denied because of a security violation.
          579  +//
          580  +#define SCARD_W_SECURITY_VIOLATION       ((DWORD)0x8010006AL)
          581  +
          582  +//
          583  +// MessageId: SCARD_W_WRONG_CHV
          584  +//
          585  +// MessageText:
          586  +//
          587  +// The card cannot be accessed because the wrong PIN was presented.
          588  +//
          589  +#define SCARD_W_WRONG_CHV                ((DWORD)0x8010006BL)
          590  +
          591  +//
          592  +// MessageId: SCARD_W_CHV_BLOCKED
          593  +//
          594  +// MessageText:
          595  +//
          596  +// The card cannot be accessed because the maximum number of PIN entry attempts has been reached.
          597  +//
          598  +#define SCARD_W_CHV_BLOCKED              ((DWORD)0x8010006CL)
          599  +
          600  +//
          601  +// MessageId: SCARD_W_EOF
          602  +//
          603  +// MessageText:
          604  +//
          605  +// The end of the smart card file has been reached.
          606  +//
          607  +#define SCARD_W_EOF                      ((DWORD)0x8010006DL)
          608  +
          609  +//
          610  +// MessageId: SCARD_W_CANCELLED_BY_USER
          611  +//
          612  +// MessageText:
          613  +//
          614  +// The action was cancelled by the user.
          615  +//
          616  +#define SCARD_W_CANCELLED_BY_USER        ((DWORD)0x8010006EL)
          617  +
          618  +//
          619  +// MessageId: SCARD_W_CARD_NOT_AUTHENTICATED
          620  +//
          621  +// MessageText:
          622  +//
          623  +// No PIN was presented to the smart card.
          624  +//
          625  +#define SCARD_W_CARD_NOT_AUTHENTICATED   ((DWORD)0x8010006FL)
          626  +
          627  +//
          628  +// MessageId: SCARD_W_CACHE_ITEM_NOT_FOUND
          629  +//
          630  +// MessageText:
          631  +//
          632  +// The requested item could not be found in the cache.
          633  +//
          634  +#define SCARD_W_CACHE_ITEM_NOT_FOUND     ((DWORD)0x80100070L)
          635  +
          636  +//
          637  +// MessageId: SCARD_W_CACHE_ITEM_STALE
          638  +//
          639  +// MessageText:
          640  +//
          641  +// The requested cache item is too old and was deleted from the cache.
          642  +//
          643  +#define SCARD_W_CACHE_ITEM_STALE         ((DWORD)0x80100071L)
          644  +
          645  +//
          646  +// MessageId: SCARD_W_CACHE_ITEM_TOO_BIG
          647  +//
          648  +// MessageText:
          649  +//
          650  +// The new cache item exceeds the maximum per-item size defined for the cache.
          651  +//
          652  +#define SCARD_W_CACHE_ITEM_TOO_BIG       ((DWORD)0x80100072L)
          653  +
          654  +#endif // SCARD_S_SUCCESS
          655  +

Added build/cackey_win64_build/include/pcsclite.h version [fed57910aa].

            1  +#include <windows.h>

Added build/cackey_win64_build/include/winscard.h version [62b1252f08].

            1  +/*++
            2  +
            3  +Copyright (c) 1996  Microsoft Corporation
            4  +
            5  +Module Name:
            6  +
            7  +    WinSCard
            8  +
            9  +Abstract:
           10  +
           11  +    This header file provides the definitions and symbols necessary for an
           12  +    Application or Smart Card Service Provider to access the Smartcard
           13  +    Subsystem.
           14  +
           15  +Environment:
           16  +
           17  +    Win32
           18  +
           19  +Notes:
           20  +
           21  +--*/
           22  +
           23  +#ifndef _WINSCARD_H_
           24  +#define _WINSCARD_H_
           25  +
           26  +#if defined (_MSC_VER) && (_MSC_VER >= 1020)
           27  +#pragma once
           28  +#endif
           29  +
           30  +#include <wtypes.h>
           31  +#include <winioctl.h>
           32  +#include "winsmcrd.h"
           33  +#ifndef SCARD_S_SUCCESS
           34  +#include "SCardErr.h"
           35  +#endif
           36  +
           37  +#ifdef __cplusplus
           38  +extern "C" {
           39  +#endif
           40  +
           41  +#ifndef _LPCBYTE_DEFINED
           42  +#define _LPCBYTE_DEFINED
           43  +typedef const BYTE *LPCBYTE;
           44  +#endif
           45  +#ifndef _LPCVOID_DEFINED
           46  +#define _LPCVOID_DEFINED
           47  +typedef const VOID *LPCVOID;
           48  +#endif
           49  +
           50  +#ifndef WINSCARDAPI
           51  +#define WINSCARDAPI
           52  +#endif
           53  +#ifndef WINSCARDDATA
           54  +#define WINSCARDDATA __declspec(dllimport)
           55  +#endif
           56  +
           57  +/* In clr:pure we cannot mark data export with dllimport.
           58  + * We should add small functions which returns the value of
           59  + * the global.
           60  + */
           61  +#if !defined(_M_CEE_PURE)
           62  +WINSCARDDATA extern const SCARD_IO_REQUEST
           63  +    g_rgSCardT0Pci,
           64  +    g_rgSCardT1Pci,
           65  +    g_rgSCardRawPci;
           66  +#define SCARD_PCI_T0  (&g_rgSCardT0Pci)
           67  +#define SCARD_PCI_T1  (&g_rgSCardT1Pci)
           68  +#define SCARD_PCI_RAW (&g_rgSCardRawPci)
           69  +#endif
           70  +
           71  +//
           72  +////////////////////////////////////////////////////////////////////////////////
           73  +//
           74  +//  Service Manager Access Services
           75  +//
           76  +//      The following services are used to manage user and terminal contexts for
           77  +//      Smart Cards.
           78  +//
           79  +
           80  +typedef ULONG_PTR SCARDCONTEXT;
           81  +typedef SCARDCONTEXT *PSCARDCONTEXT, *LPSCARDCONTEXT;
           82  +
           83  +typedef ULONG_PTR SCARDHANDLE;
           84  +typedef SCARDHANDLE *PSCARDHANDLE, *LPSCARDHANDLE;
           85  +
           86  +#define SCARD_AUTOALLOCATE (DWORD)(-1)
           87  +
           88  +#define SCARD_SCOPE_USER     0  // The context is a user context, and any
           89  +                                // database operations are performed within the
           90  +                                // domain of the user.
           91  +#define SCARD_SCOPE_TERMINAL 1  // The context is that of the current terminal,
           92  +                                // and any database operations are performed
           93  +                                // within the domain of that terminal.  (The
           94  +                                // calling application must have appropriate
           95  +                                // access permissions for any database actions.)
           96  +#define SCARD_SCOPE_SYSTEM    2 // The context is the system context, and any
           97  +                                // database operations are performed within the
           98  +                                // domain of the system.  (The calling
           99  +                                // application must have appropriate access
          100  +                                // permissions for any database actions.)
          101  +
          102  +extern WINSCARDAPI LONG WINAPI
          103  +SCardEstablishContext(
          104  +    __in  DWORD dwScope,
          105  +    __reserved  LPCVOID pvReserved1,
          106  +    __reserved  LPCVOID pvReserved2,
          107  +    __out LPSCARDCONTEXT phContext);
          108  +
          109  +extern WINSCARDAPI LONG WINAPI
          110  +SCardReleaseContext(
          111  +    __in      SCARDCONTEXT hContext);
          112  +
          113  +extern WINSCARDAPI LONG WINAPI
          114  +SCardIsValidContext(
          115  +    __in      SCARDCONTEXT hContext);
          116  +
          117  +
          118  +//
          119  +////////////////////////////////////////////////////////////////////////////////
          120  +//
          121  +//  Smart Card Database Management Services
          122  +//
          123  +//      The following services provide for managing the Smart Card Database.
          124  +//
          125  +
          126  +#define SCARD_ALL_READERS       TEXT("SCard$AllReaders\000")
          127  +#define SCARD_DEFAULT_READERS   TEXT("SCard$DefaultReaders\000")
          128  +#define SCARD_LOCAL_READERS     TEXT("SCard$LocalReaders\000")
          129  +#define SCARD_SYSTEM_READERS    TEXT("SCard$SystemReaders\000")
          130  +
          131  +#define SCARD_PROVIDER_PRIMARY  1   // Primary Provider Id
          132  +#define SCARD_PROVIDER_CSP      2   // Crypto Service Provider Id
          133  +#define SCARD_PROVIDER_KSP      3   // Key Storage Provider Id
          134  +
          135  +
          136  +//
          137  +// Database Reader routines
          138  +//
          139  +
          140  +extern WINSCARDAPI LONG WINAPI
          141  +SCardListReaderGroupsA(
          142  +    __in    SCARDCONTEXT hContext,
          143  +    __nullnullterminated __out_ecount_opt(*pcchGroups)   LPSTR mszGroups,
          144  +    __inout LPDWORD pcchGroups);
          145  +extern WINSCARDAPI LONG WINAPI
          146  +SCardListReaderGroupsW(
          147  +    __in    SCARDCONTEXT hContext,
          148  +    __nullnullterminated __out_ecount_opt(*pcchGroups)   LPWSTR mszGroups,
          149  +    __inout LPDWORD pcchGroups);
          150  +#ifdef UNICODE
          151  +#define SCardListReaderGroups  SCardListReaderGroupsW
          152  +#else
          153  +#define SCardListReaderGroups  SCardListReaderGroupsA
          154  +#endif // !UNICODE
          155  +
          156  +extern WINSCARDAPI LONG WINAPI
          157  +SCardListReadersA(
          158  +    __in     SCARDCONTEXT hContext,
          159  +    __in_opt LPCSTR mszGroups,
          160  +    __nullnullterminated __out_ecount_opt(*pcchReaders) LPSTR mszReaders,
          161  +    __inout  LPDWORD pcchReaders);
          162  +extern WINSCARDAPI LONG WINAPI
          163  +SCardListReadersW(
          164  +    __in     SCARDCONTEXT hContext,
          165  +    __in_opt LPCWSTR mszGroups,
          166  +    __nullnullterminated __out_ecount_opt(*pcchReaders) LPWSTR mszReaders,
          167  +    __inout  LPDWORD pcchReaders);
          168  +#ifdef UNICODE
          169  +#define SCardListReaders  SCardListReadersW
          170  +#else
          171  +#define SCardListReaders  SCardListReadersA
          172  +#endif // !UNICODE
          173  +
          174  +extern WINSCARDAPI LONG WINAPI
          175  +SCardListCardsA(
          176  +    __in      SCARDCONTEXT hContext,
          177  +    __in_opt  LPCBYTE pbAtr,
          178  +    __in_ecount_opt(cguidInterfaceCount)  LPCGUID rgquidInterfaces,
          179  +    __in      DWORD cguidInterfaceCount,
          180  +    __nullnullterminated __out_ecount_opt(*pcchCards) LPSTR mszCards,
          181  +    __inout   LPDWORD pcchCards);
          182  +extern WINSCARDAPI LONG WINAPI
          183  +SCardListCardsW(
          184  +    __in      SCARDCONTEXT hContext,
          185  +    __in_opt  LPCBYTE pbAtr,
          186  +    __in_ecount_opt(cguidInterfaceCount)  LPCGUID rgquidInterfaces,
          187  +    __in      DWORD cguidInterfaceCount,
          188  +    __nullnullterminated __out_ecount_opt(*pcchCards) LPWSTR mszCards,
          189  +    __inout   LPDWORD pcchCards);
          190  +#ifdef UNICODE
          191  +#define SCardListCards  SCardListCardsW
          192  +#else
          193  +#define SCardListCards  SCardListCardsA
          194  +#endif // !UNICODE
          195  +//
          196  +// NOTE:    The routine SCardListCards name differs from the PC/SC definition.
          197  +//          It should be:
          198  +//
          199  +//              extern WINSCARDAPI LONG WINAPI
          200  +//              SCardListCardTypes(
          201  +//                  __in      SCARDCONTEXT hContext,
          202  +//                  __in_opt  LPCBYTE pbAtr,
          203  +//                  __in_opt  LPCGUID rgquidInterfaces,
          204  +//                  __in      DWORD cguidInterfaceCount,
          205  +//                  __out_opt LPTSTR mszCards,
          206  +//                  __inout   LPDWORD pcchCards);
          207  +//
          208  +//          Here's a work-around MACRO:
          209  +#define SCardListCardTypes SCardListCards
          210  +
          211  +extern WINSCARDAPI LONG WINAPI
          212  +SCardListInterfacesA(
          213  +    __in     SCARDCONTEXT hContext,
          214  +    __in     LPCSTR szCard,
          215  +    __out    LPGUID pguidInterfaces,
          216  +    __inout  LPDWORD pcguidInterfaces);
          217  +extern WINSCARDAPI LONG WINAPI
          218  +SCardListInterfacesW(
          219  +    __in     SCARDCONTEXT hContext,
          220  +    __in     LPCWSTR szCard,
          221  +    __out    LPGUID pguidInterfaces,
          222  +    __inout  LPDWORD pcguidInterfaces);
          223  +#ifdef UNICODE
          224  +#define SCardListInterfaces  SCardListInterfacesW
          225  +#else
          226  +#define SCardListInterfaces  SCardListInterfacesA
          227  +#endif // !UNICODE
          228  +
          229  +extern WINSCARDAPI LONG WINAPI
          230  +SCardGetProviderIdA(
          231  +    __in     SCARDCONTEXT hContext,
          232  +    __in     LPCSTR szCard,
          233  +    __out    LPGUID pguidProviderId);
          234  +extern WINSCARDAPI LONG WINAPI
          235  +SCardGetProviderIdW(
          236  +    __in     SCARDCONTEXT hContext,
          237  +    __in     LPCWSTR szCard,
          238  +    __out    LPGUID pguidProviderId);
          239  +#ifdef UNICODE
          240  +#define SCardGetProviderId  SCardGetProviderIdW
          241  +#else
          242  +#define SCardGetProviderId  SCardGetProviderIdA
          243  +#endif // !UNICODE
          244  +//
          245  +// NOTE:    The routine SCardGetProviderId in this implementation uses GUIDs.
          246  +//          The PC/SC definition uses BYTEs.
          247  +//
          248  +
          249  +extern WINSCARDAPI LONG WINAPI
          250  +SCardGetCardTypeProviderNameA(
          251  +    __in      SCARDCONTEXT hContext,
          252  +    __in      LPCSTR szCardName,
          253  +    __in      DWORD dwProviderId,
          254  +    __out_ecount_opt(*pcchProvider) LPSTR szProvider,
          255  +    __inout   LPDWORD pcchProvider);
          256  +extern WINSCARDAPI LONG WINAPI
          257  +SCardGetCardTypeProviderNameW(
          258  +    __in      SCARDCONTEXT hContext,
          259  +    __in      LPCWSTR szCardName,
          260  +    __in      DWORD dwProviderId,
          261  +    __out_ecount_opt(*pcchProvider) LPWSTR szProvider,
          262  +    __inout   LPDWORD pcchProvider);
          263  +#ifdef UNICODE
          264  +#define SCardGetCardTypeProviderName  SCardGetCardTypeProviderNameW
          265  +#else
          266  +#define SCardGetCardTypeProviderName  SCardGetCardTypeProviderNameA
          267  +#endif // !UNICODE
          268  +//
          269  +// NOTE:    This routine is an extension to the PC/SC definitions.
          270  +//
          271  +
          272  +
          273  +//
          274  +// Database Writer routines
          275  +//
          276  +
          277  +extern WINSCARDAPI LONG WINAPI
          278  +SCardIntroduceReaderGroupA(
          279  +    __in SCARDCONTEXT hContext,
          280  +    __in LPCSTR szGroupName);
          281  +extern WINSCARDAPI LONG WINAPI
          282  +SCardIntroduceReaderGroupW(
          283  +    __in SCARDCONTEXT hContext,
          284  +    __in LPCWSTR szGroupName);
          285  +#ifdef UNICODE
          286  +#define SCardIntroduceReaderGroup  SCardIntroduceReaderGroupW
          287  +#else
          288  +#define SCardIntroduceReaderGroup  SCardIntroduceReaderGroupA
          289  +#endif // !UNICODE
          290  +
          291  +extern WINSCARDAPI LONG WINAPI
          292  +SCardForgetReaderGroupA(
          293  +    __in SCARDCONTEXT hContext,
          294  +    __in LPCSTR szGroupName);
          295  +extern WINSCARDAPI LONG WINAPI
          296  +SCardForgetReaderGroupW(
          297  +    __in SCARDCONTEXT hContext,
          298  +    __in LPCWSTR szGroupName);
          299  +#ifdef UNICODE
          300  +#define SCardForgetReaderGroup  SCardForgetReaderGroupW
          301  +#else
          302  +#define SCardForgetReaderGroup  SCardForgetReaderGroupA
          303  +#endif // !UNICODE
          304  +
          305  +extern WINSCARDAPI LONG WINAPI
          306  +SCardIntroduceReaderA(
          307  +    __in SCARDCONTEXT hContext,
          308  +    __in LPCSTR szReaderName,
          309  +    __in LPCSTR szDeviceName);
          310  +extern WINSCARDAPI LONG WINAPI
          311  +SCardIntroduceReaderW(
          312  +    __in SCARDCONTEXT hContext,
          313  +    __in LPCWSTR szReaderName,
          314  +    __in LPCWSTR szDeviceName);
          315  +#ifdef UNICODE
          316  +#define SCardIntroduceReader  SCardIntroduceReaderW
          317  +#else
          318  +#define SCardIntroduceReader  SCardIntroduceReaderA
          319  +#endif // !UNICODE
          320  +
          321  +extern WINSCARDAPI LONG WINAPI
          322  +SCardForgetReaderA(
          323  +    __in SCARDCONTEXT hContext,
          324  +    __in LPCSTR szReaderName);
          325  +extern WINSCARDAPI LONG WINAPI
          326  +SCardForgetReaderW(
          327  +    __in SCARDCONTEXT hContext,
          328  +    __in LPCWSTR szReaderName);
          329  +#ifdef UNICODE
          330  +#define SCardForgetReader  SCardForgetReaderW
          331  +#else
          332  +#define SCardForgetReader  SCardForgetReaderA
          333  +#endif // !UNICODE
          334  +
          335  +extern WINSCARDAPI LONG WINAPI
          336  +SCardAddReaderToGroupA(
          337  +    __in SCARDCONTEXT hContext,
          338  +    __in LPCSTR szReaderName,
          339  +    __in LPCSTR szGroupName);
          340  +extern WINSCARDAPI LONG WINAPI
          341  +SCardAddReaderToGroupW(
          342  +    __in SCARDCONTEXT hContext,
          343  +    __in LPCWSTR szReaderName,
          344  +    __in LPCWSTR szGroupName);
          345  +#ifdef UNICODE
          346  +#define SCardAddReaderToGroup  SCardAddReaderToGroupW
          347  +#else
          348  +#define SCardAddReaderToGroup  SCardAddReaderToGroupA
          349  +#endif // !UNICODE
          350  +
          351  +extern WINSCARDAPI LONG WINAPI
          352  +SCardRemoveReaderFromGroupA(
          353  +    __in SCARDCONTEXT hContext,
          354  +    __in LPCSTR szReaderName,
          355  +    __in LPCSTR szGroupName);
          356  +extern WINSCARDAPI LONG WINAPI
          357  +SCardRemoveReaderFromGroupW(
          358  +    __in SCARDCONTEXT hContext,
          359  +    __in LPCWSTR szReaderName,
          360  +    __in LPCWSTR szGroupName);
          361  +#ifdef UNICODE
          362  +#define SCardRemoveReaderFromGroup  SCardRemoveReaderFromGroupW
          363  +#else
          364  +#define SCardRemoveReaderFromGroup  SCardRemoveReaderFromGroupA
          365  +#endif // !UNICODE
          366  +
          367  +extern WINSCARDAPI LONG WINAPI
          368  +SCardIntroduceCardTypeA(
          369  +    __in     SCARDCONTEXT hContext,
          370  +    __in     LPCSTR szCardName,
          371  +    __in_opt LPCGUID pguidPrimaryProvider,
          372  +    __in_opt LPCGUID rgguidInterfaces,
          373  +    __in     DWORD dwInterfaceCount,
          374  +    __in     LPCBYTE pbAtr,
          375  +    __in     LPCBYTE pbAtrMask,
          376  +    __in     DWORD cbAtrLen);
          377  +extern WINSCARDAPI LONG WINAPI
          378  +SCardIntroduceCardTypeW(
          379  +    __in     SCARDCONTEXT hContext,
          380  +    __in     LPCWSTR szCardName,
          381  +    __in_opt LPCGUID pguidPrimaryProvider,
          382  +    __in_opt LPCGUID rgguidInterfaces,
          383  +    __in     DWORD dwInterfaceCount,
          384  +    __in     LPCBYTE pbAtr,
          385  +    __in     LPCBYTE pbAtrMask,
          386  +    __in     DWORD cbAtrLen);
          387  +#ifdef UNICODE
          388  +#define SCardIntroduceCardType  SCardIntroduceCardTypeW
          389  +#else
          390  +#define SCardIntroduceCardType  SCardIntroduceCardTypeA
          391  +#endif // !UNICODE
          392  +//
          393  +// NOTE:    The routine SCardIntroduceCardType's parameters' order differs from
          394  +//          the PC/SC definition.  It should be:
          395  +//
          396  +//              extern WINSCARDAPI LONG WINAPI
          397  +//              SCardIntroduceCardType(
          398  +//                  __in     SCARDCONTEXT hContext,
          399  +//                  __in     LPCTSTR szCardName,
          400  +//                  __in     LPCBYTE pbAtr,
          401  +//                  __in     LPCBYTE pbAtrMask,
          402  +//                  __in     DWORD cbAtrLen,
          403  +//                  __in_opt LPCGUID pguidPrimaryProvider,
          404  +//                  __in_opt LPCGUID rgguidInterfaces,
          405  +//                  __in     DWORD dwInterfaceCount);
          406  +//
          407  +//          Here's a work-around MACRO:
          408  +#define PCSCardIntroduceCardType(hContext, szCardName, pbAtr, pbAtrMask, cbAtrLen, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount) \
          409  +          SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen)
          410  +
          411  +extern WINSCARDAPI LONG WINAPI
          412  +SCardSetCardTypeProviderNameA(
          413  +    __in SCARDCONTEXT hContext,
          414  +    __in LPCSTR szCardName,
          415  +    __in DWORD dwProviderId,
          416  +    __in LPCSTR szProvider);
          417  +extern WINSCARDAPI LONG WINAPI
          418  +SCardSetCardTypeProviderNameW(
          419  +    __in SCARDCONTEXT hContext,
          420  +    __in LPCWSTR szCardName,
          421  +    __in DWORD dwProviderId,
          422  +    __in LPCWSTR szProvider);
          423  +#ifdef UNICODE
          424  +#define SCardSetCardTypeProviderName  SCardSetCardTypeProviderNameW
          425  +#else
          426  +#define SCardSetCardTypeProviderName  SCardSetCardTypeProviderNameA
          427  +#endif // !UNICODE
          428  +//
          429  +// NOTE:    This routine is an extention to the PC/SC specifications.
          430  +//
          431  +
          432  +extern WINSCARDAPI LONG WINAPI
          433  +SCardForgetCardTypeA(
          434  +    __in SCARDCONTEXT hContext,
          435  +    __in LPCSTR szCardName);
          436  +extern WINSCARDAPI LONG WINAPI
          437  +SCardForgetCardTypeW(
          438  +    __in SCARDCONTEXT hContext,
          439  +    __in LPCWSTR szCardName);
          440  +#ifdef UNICODE
          441  +#define SCardForgetCardType  SCardForgetCardTypeW
          442  +#else
          443  +#define SCardForgetCardType  SCardForgetCardTypeA
          444  +#endif // !UNICODE
          445  +
          446  +
          447  +//
          448  +////////////////////////////////////////////////////////////////////////////////
          449  +//
          450  +//  Service Manager Support Routines
          451  +//
          452  +//      The following services are supplied to simplify the use of the Service
          453  +//      Manager API.
          454  +//
          455  +
          456  +extern WINSCARDAPI LONG WINAPI
          457  +SCardFreeMemory(
          458  +    __in SCARDCONTEXT hContext,
          459  +    __in LPCVOID pvMem);
          460  +
          461  +#if (NTDDI_VERSION >= NTDDI_WINXP)
          462  +extern WINSCARDAPI HANDLE WINAPI
          463  +SCardAccessStartedEvent(void);
          464  +
          465  +extern WINSCARDAPI void WINAPI
          466  +SCardReleaseStartedEvent(void);
          467  +#endif // (NTDDI_VERSION >= NTDDI_WINXP)
          468  +
          469  +//
          470  +////////////////////////////////////////////////////////////////////////////////
          471  +//
          472  +//  Reader Services
          473  +//
          474  +//      The following services supply means for tracking cards within readers.
          475  +//
          476  +
          477  +typedef struct {
          478  +    LPCSTR      szReader;       // reader name
          479  +    LPVOID      pvUserData;     // user defined data
          480  +    DWORD       dwCurrentState; // current state of reader at time of call
          481  +    DWORD       dwEventState;   // state of reader after state change
          482  +    DWORD       cbAtr;          // Number of bytes in the returned ATR.
          483  +    BYTE        rgbAtr[36];     // Atr of inserted card, (extra alignment bytes)
          484  +} SCARD_READERSTATEA, *PSCARD_READERSTATEA, *LPSCARD_READERSTATEA;
          485  +typedef struct {
          486  +    LPCWSTR     szReader;       // reader name
          487  +    LPVOID      pvUserData;     // user defined data
          488  +    DWORD       dwCurrentState; // current state of reader at time of call
          489  +    DWORD       dwEventState;   // state of reader after state change
          490  +    DWORD       cbAtr;          // Number of bytes in the returned ATR.
          491  +    BYTE        rgbAtr[36];     // Atr of inserted card, (extra alignment bytes)
          492  +} SCARD_READERSTATEW, *PSCARD_READERSTATEW, *LPSCARD_READERSTATEW;
          493  +#ifdef UNICODE
          494  +typedef SCARD_READERSTATEW SCARD_READERSTATE;
          495  +typedef PSCARD_READERSTATEW PSCARD_READERSTATE;
          496  +typedef LPSCARD_READERSTATEW LPSCARD_READERSTATE;
          497  +#else
          498  +typedef SCARD_READERSTATEA SCARD_READERSTATE;
          499  +typedef PSCARD_READERSTATEA PSCARD_READERSTATE;
          500  +typedef LPSCARD_READERSTATEA LPSCARD_READERSTATE;
          501  +#endif // UNICODE
          502  +
          503  +// Backwards compatibility macros
          504  +#define SCARD_READERSTATE_A SCARD_READERSTATEA
          505  +#define SCARD_READERSTATE_W SCARD_READERSTATEW
          506  +#define PSCARD_READERSTATE_A PSCARD_READERSTATEA
          507  +#define PSCARD_READERSTATE_W PSCARD_READERSTATEW
          508  +#define LPSCARD_READERSTATE_A LPSCARD_READERSTATEA
          509  +#define LPSCARD_READERSTATE_W LPSCARD_READERSTATEW
          510  +
          511  +#define SCARD_STATE_UNAWARE     0x00000000  // The application is unaware of the
          512  +                                            // current state, and would like to
          513  +                                            // know.  The use of this value
          514  +                                            // results in an immediate return
          515  +                                            // from state transition monitoring
          516  +                                            // services.  This is represented by
          517  +                                            // all bits set to zero.
          518  +#define SCARD_STATE_IGNORE      0x00000001  // The application requested that
          519  +                                            // this reader be ignored.  No other
          520  +                                            // bits will be set.
          521  +#define SCARD_STATE_CHANGED     0x00000002  // This implies that there is a
          522  +                                            // difference between the state
          523  +                                            // believed by the application, and
          524  +                                            // the state known by the Service
          525  +                                            // Manager.  When this bit is set,
          526  +                                            // the application may assume a
          527  +                                            // significant state change has
          528  +                                            // occurred on this reader.
          529  +#define SCARD_STATE_UNKNOWN     0x00000004  // This implies that the given
          530  +                                            // reader name is not recognized by
          531  +                                            // the Service Manager.  If this bit
          532  +                                            // is set, then SCARD_STATE_CHANGED
          533  +                                            // and SCARD_STATE_IGNORE will also
          534  +                                            // be set.
          535  +#define SCARD_STATE_UNAVAILABLE 0x00000008  // This implies that the actual
          536  +                                            // state of this reader is not
          537  +                                            // available.  If this bit is set,
          538  +                                            // then all the following bits are
          539  +                                            // clear.
          540  +#define SCARD_STATE_EMPTY       0x00000010  // This implies that there is not
          541  +                                            // card in the reader.  If this bit
          542  +                                            // is set, all the following bits
          543  +                                            // will be clear.
          544  +#define SCARD_STATE_PRESENT     0x00000020  // This implies that there is a card
          545  +                                            // in the reader.
          546  +#define SCARD_STATE_ATRMATCH    0x00000040  // This implies that there is a card
          547  +                                            // in the reader with an ATR
          548  +                                            // matching one of the target cards.
          549  +                                            // If this bit is set,
          550  +                                            // SCARD_STATE_PRESENT will also be
          551  +                                            // set.  This bit is only returned
          552  +                                            // on the SCardLocateCard() service.
          553  +#define SCARD_STATE_EXCLUSIVE   0x00000080  // This implies that the card in the
          554  +                                            // reader is allocated for exclusive
          555  +                                            // use by another application.  If
          556  +                                            // this bit is set,
          557  +                                            // SCARD_STATE_PRESENT will also be
          558  +                                            // set.
          559  +#define SCARD_STATE_INUSE       0x00000100  // This implies that the card in the
          560  +                                            // reader is in use by one or more
          561  +                                            // other applications, but may be
          562  +                                            // connected to in shared mode.  If
          563  +                                            // this bit is set,
          564  +                                            // SCARD_STATE_PRESENT will also be
          565  +                                            // set.
          566  +#define SCARD_STATE_MUTE        0x00000200  // This implies that the card in the
          567  +                                            // reader is unresponsive or not
          568  +                                            // supported by the reader or
          569  +                                            // software.
          570  +#define SCARD_STATE_UNPOWERED   0x00000400  // This implies that the card in the
          571  +                                            // reader has not been powered up.
          572  +
          573  +extern WINSCARDAPI LONG WINAPI
          574  +SCardLocateCardsA(
          575  +    __in    SCARDCONTEXT hContext,
          576  +    __in    LPCSTR mszCards,
          577  +    __inout LPSCARD_READERSTATEA rgReaderStates,
          578  +    __in    DWORD cReaders);
          579  +extern WINSCARDAPI LONG WINAPI
          580  +SCardLocateCardsW(
          581  +    __in    SCARDCONTEXT hContext,
          582  +    __in    LPCWSTR mszCards,
          583  +    __inout LPSCARD_READERSTATEW rgReaderStates,
          584  +    __in    DWORD cReaders);
          585  +#ifdef UNICODE
          586  +#define SCardLocateCards  SCardLocateCardsW
          587  +#else
          588  +#define SCardLocateCards  SCardLocateCardsA
          589  +#endif // !UNICODE
          590  +
          591  +#if (NTDDI_VERSION >= NTDDI_WINXP)
          592  +typedef struct _SCARD_ATRMASK {
          593  +    DWORD       cbAtr;          // Number of bytes in the ATR and the mask.
          594  +    BYTE        rgbAtr[36];     // Atr of card (extra alignment bytes)
          595  +    BYTE        rgbMask[36];    // Mask for the Atr (extra alignment bytes)
          596  +} SCARD_ATRMASK, *PSCARD_ATRMASK, *LPSCARD_ATRMASK;
          597  +
          598  +
          599  +extern WINSCARDAPI LONG WINAPI
          600  +SCardLocateCardsByATRA(
          601  +    __in    SCARDCONTEXT hContext,
          602  +    __in    LPSCARD_ATRMASK rgAtrMasks,
          603  +    __in    DWORD cAtrs,
          604  +    __inout LPSCARD_READERSTATEA rgReaderStates,
          605  +    __in    DWORD cReaders);
          606  +extern WINSCARDAPI LONG WINAPI
          607  +SCardLocateCardsByATRW(
          608  +    __in    SCARDCONTEXT hContext,
          609  +    __in    LPSCARD_ATRMASK rgAtrMasks,
          610  +    __in    DWORD cAtrs,
          611  +    __inout LPSCARD_READERSTATEW rgReaderStates,
          612  +    __in    DWORD cReaders);
          613  +#ifdef UNICODE
          614  +#define SCardLocateCardsByATR  SCardLocateCardsByATRW
          615  +#else
          616  +#define SCardLocateCardsByATR  SCardLocateCardsByATRA
          617  +#endif // !UNICODE
          618  +#endif // (NTDDI_VERSION >= NTDDI_WINXP)
          619  +
          620  +extern WINSCARDAPI LONG WINAPI
          621  +SCardGetStatusChangeA(
          622  +    __in    SCARDCONTEXT hContext,
          623  +    __in    DWORD dwTimeout,
          624  +    __inout LPSCARD_READERSTATEA rgReaderStates,
          625  +    __in    DWORD cReaders);
          626  +extern WINSCARDAPI LONG WINAPI
          627  +SCardGetStatusChangeW(
          628  +    __in    SCARDCONTEXT hContext,
          629  +    __in    DWORD dwTimeout,
          630  +    __inout LPSCARD_READERSTATEW rgReaderStates,
          631  +    __in    DWORD cReaders);
          632  +#ifdef UNICODE
          633  +#define SCardGetStatusChange  SCardGetStatusChangeW
          634  +#else
          635  +#define SCardGetStatusChange  SCardGetStatusChangeA
          636  +#endif // !UNICODE
          637  +
          638  +extern WINSCARDAPI LONG WINAPI
          639  +SCardCancel(
          640  +    __in    SCARDCONTEXT hContext);
          641  +
          642  +
          643  +//
          644  +////////////////////////////////////////////////////////////////////////////////
          645  +//
          646  +//  Card/Reader Communication Services
          647  +//
          648  +//      The following services provide means for communication with the card.
          649  +//
          650  +
          651  +#define SCARD_SHARE_EXCLUSIVE 1 // This application is not willing to share this
          652  +                                // card with other applications.
          653  +#define SCARD_SHARE_SHARED    2 // This application is willing to share this
          654  +                                // card with other applications.
          655  +#define SCARD_SHARE_DIRECT    3 // This application demands direct control of
          656  +                                // the reader, so it is not available to other
          657  +                                // applications.
          658  +
          659  +#define SCARD_LEAVE_CARD      0 // Don't do anything special on close
          660  +#define SCARD_RESET_CARD      1 // Reset the card on close
          661  +#define SCARD_UNPOWER_CARD    2 // Power down the card on close
          662  +#define SCARD_EJECT_CARD      3 // Eject the card on close
          663  +
          664  +extern WINSCARDAPI LONG WINAPI
          665  +SCardConnectA(
          666  +    __in    SCARDCONTEXT hContext,
          667  +    __in    LPCSTR szReader,
          668  +    __in    DWORD dwShareMode,
          669  +    __in    DWORD dwPreferredProtocols,
          670  +    __out   LPSCARDHANDLE phCard,
          671  +    __out   LPDWORD pdwActiveProtocol);
          672  +extern WINSCARDAPI LONG WINAPI
          673  +SCardConnectW(
          674  +    __in    SCARDCONTEXT hContext,
          675  +    __in    LPCWSTR szReader,
          676  +    __in    DWORD dwShareMode,
          677  +    __in    DWORD dwPreferredProtocols,
          678  +    __out   LPSCARDHANDLE phCard,
          679  +    __out   LPDWORD pdwActiveProtocol);
          680  +#ifdef UNICODE
          681  +#define SCardConnect  SCardConnectW
          682  +#else
          683  +#define SCardConnect  SCardConnectA
          684  +#endif // !UNICODE
          685  +
          686  +extern WINSCARDAPI LONG WINAPI
          687  +SCardReconnect(
          688  +    __in      SCARDHANDLE hCard,
          689  +    __in      DWORD dwShareMode,
          690  +    __in      DWORD dwPreferredProtocols,
          691  +    __in      DWORD dwInitialization,
          692  +    __out_opt LPDWORD pdwActiveProtocol);
          693  +
          694  +extern WINSCARDAPI LONG WINAPI
          695  +SCardDisconnect(
          696  +    __in    SCARDHANDLE hCard,
          697  +    __in    DWORD dwDisposition);
          698  +
          699  +extern WINSCARDAPI LONG WINAPI
          700  +SCardBeginTransaction(
          701  +    __in    SCARDHANDLE hCard);
          702  +
          703  +extern WINSCARDAPI LONG WINAPI
          704  +SCardEndTransaction(
          705  +    __in    SCARDHANDLE hCard,
          706  +    __in    DWORD dwDisposition);
          707  +
          708  +extern WINSCARDAPI LONG WINAPI
          709  +SCardCancelTransaction(
          710  +    __in    SCARDHANDLE hCard);
          711  +//
          712  +// NOTE:    This call corresponds to the PC/SC SCARDCOMM::Cancel routine,
          713  +//          terminating a blocked SCardBeginTransaction service.
          714  +//
          715  +
          716  +
          717  +extern WINSCARDAPI LONG WINAPI
          718  +SCardState(
          719  +    __in    SCARDHANDLE hCard,
          720  +    __out   LPDWORD pdwState,
          721  +    __out   LPDWORD pdwProtocol,
          722  +    __out_bcount(*pcbAtrLen)   LPBYTE pbAtr,
          723  +    __inout LPDWORD pcbAtrLen);
          724  +//
          725  +// NOTE:    SCardState is an obsolete routine.  PC/SC has replaced it with
          726  +//          SCardStatus.
          727  +//
          728  +
          729  +extern WINSCARDAPI LONG WINAPI
          730  +SCardStatusA(
          731  +    __in        SCARDHANDLE hCard,
          732  +    __nullnullterminated __out_ecount_opt(*pcchReaderLen) LPSTR mszReaderNames,
          733  +    __inout_opt LPDWORD pcchReaderLen,
          734  +    __out_opt   LPDWORD pdwState,
          735  +    __out_opt   LPDWORD pdwProtocol,
          736  +    __out_ecount_opt(*pcbAtrLen) LPBYTE pbAtr,
          737  +    __inout_opt LPDWORD pcbAtrLen);
          738  +extern WINSCARDAPI LONG WINAPI
          739  +SCardStatusW(
          740  +    __in        SCARDHANDLE hCard,
          741  +    __nullnullterminated __out_ecount_opt(*pcchReaderLen) LPWSTR mszReaderNames,
          742  +    __inout_opt LPDWORD pcchReaderLen,
          743  +    __out_opt   LPDWORD pdwState,
          744  +    __out_opt   LPDWORD pdwProtocol,
          745  +    __out_ecount_opt(*pcbAtrLen) LPBYTE pbAtr,
          746  +    __inout_opt LPDWORD pcbAtrLen);
          747  +#ifdef UNICODE
          748  +#define SCardStatus  SCardStatusW
          749  +#else
          750  +#define SCardStatus  SCardStatusA
          751  +#endif // !UNICODE
          752  +
          753  +extern WINSCARDAPI LONG WINAPI
          754  +SCardTransmit(
          755  +    __in        SCARDHANDLE hCard,
          756  +    __in        LPCSCARD_IO_REQUEST pioSendPci,
          757  +    __in_bcount(cbSendLength) LPCBYTE pbSendBuffer,
          758  +    __in        DWORD cbSendLength,
          759  +    __inout_opt LPSCARD_IO_REQUEST pioRecvPci,
          760  +    __out_bcount(*pcbRecvLength) LPBYTE pbRecvBuffer,
          761  +    __inout     LPDWORD pcbRecvLength);
          762  +
          763  +#if (NTDDI_VERSION >= NTDDI_VISTA)
          764  +extern WINSCARDAPI LONG WINAPI
          765  +SCardGetTransmitCount(
          766  +    __in SCARDHANDLE hCard,
          767  +    __out LPDWORD pcTransmitCount);
          768  +#endif // (NTDDI_VERSION >= NTDDI_VISTA)
          769  +
          770  +//
          771  +////////////////////////////////////////////////////////////////////////////////
          772  +//
          773  +//  Reader Control Routines
          774  +//
          775  +//      The following services provide for direct, low-level manipulation of the
          776  +//      reader by the calling application allowing it control over the
          777  +//      attributes of the communications with the card.
          778  +//
          779  +
          780  +extern WINSCARDAPI LONG WINAPI
          781  +SCardControl(
          782  +    __in    SCARDHANDLE hCard,
          783  +    __in    DWORD dwControlCode,
          784  +    __in_bcount(cbInBufferSize) LPCVOID lpInBuffer,
          785  +    __in    DWORD cbInBufferSize,
          786  +    __out_bcount(cbOutBufferSize) LPVOID lpOutBuffer,
          787  +    __in    DWORD cbOutBufferSize,
          788  +    __out   LPDWORD lpBytesReturned);
          789  +
          790  +extern WINSCARDAPI LONG WINAPI
          791  +SCardGetAttrib(
          792  +    __in    SCARDHANDLE hCard,
          793  +    __in    DWORD dwAttrId,
          794  +    __out_bcount_opt(*pcbAttrLen) LPBYTE pbAttr,
          795  +    __inout LPDWORD pcbAttrLen);
          796  +//
          797  +// NOTE:    The routine SCardGetAttrib's name differs from the PC/SC definition.
          798  +//          It should be:
          799  +//
          800  +//              extern WINSCARDAPI LONG WINAPI
          801  +//              SCardGetReaderCapabilities(
          802  +//                  __in    SCARDHANDLE hCard,
          803  +//                  __in    DWORD dwTag,
          804  +//                  __out   LPBYTE pbAttr,
          805  +//                  __inout LPDWORD pcbAttrLen);
          806  +//
          807  +//          Here's a work-around MACRO:
          808  +#define SCardGetReaderCapabilities SCardGetAttrib
          809  +
          810  +extern WINSCARDAPI LONG WINAPI
          811  +SCardSetAttrib(
          812  +    __in SCARDHANDLE hCard,
          813  +    __in DWORD dwAttrId,
          814  +    __in_bcount(cbAttrLen) LPCBYTE pbAttr,
          815  +    __in DWORD cbAttrLen);
          816  +//
          817  +// NOTE:    The routine SCardSetAttrib's name differs from the PC/SC definition.
          818  +//          It should be:
          819  +//
          820  +//              extern WINSCARDAPI LONG WINAPI
          821  +//              SCardSetReaderCapabilities(
          822  +//                  __in    SCARDHANDLE hCard,
          823  +//                  __in    DWORD dwTag,
          824  +//                  __in    LPCBYTE pbAttr,
          825  +//                  __in    DWORD cbAttrLen);
          826  +//
          827  +//          Here's a work-around MACRO:
          828  +#define SCardSetReaderCapabilities SCardSetAttrib
          829  +
          830  +
          831  +//
          832  +////////////////////////////////////////////////////////////////////////////////
          833  +//
          834  +//  Smart Card Dialog definitions
          835  +//
          836  +//      The following section contains structures and  exported function
          837  +//      declarations for the Smart Card Common Dialog dialog.
          838  +//
          839  +
          840  +// Defined constants
          841  +// Flags
          842  +#define SC_DLG_MINIMAL_UI       0x01
          843  +#define SC_DLG_NO_UI            0x02
          844  +#define SC_DLG_FORCE_UI         0x04
          845  +
          846  +#define SCERR_NOCARDNAME        0x4000
          847  +#define SCERR_NOGUIDS           0x8000
          848  +
          849  +typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCA) (__in SCARDCONTEXT, __in LPSTR, __in LPSTR, __in PVOID);
          850  +typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCW) (__in SCARDCONTEXT, __in LPWSTR, __in LPWSTR, __in PVOID);
          851  +#ifdef UNICODE
          852  +#define LPOCNCONNPROC  LPOCNCONNPROCW
          853  +#else
          854  +#define LPOCNCONNPROC  LPOCNCONNPROCA
          855  +#endif // !UNICODE
          856  +typedef BOOL (WINAPI *LPOCNCHKPROC) (__in SCARDCONTEXT, __in SCARDHANDLE, __in PVOID);
          857  +typedef void (WINAPI *LPOCNDSCPROC) (__in SCARDCONTEXT, __in SCARDHANDLE, __in PVOID);
          858  +
          859  +
          860  +//
          861  +// OPENCARD_SEARCH_CRITERIA: In order to specify a user-extended search,
          862  +// lpfnCheck must not be NULL.  Moreover, the connection to be made to the
          863  +// card before performing the callback must be indicated by either providing
          864  +// lpfnConnect and lpfnDisconnect OR by setting dwShareMode.
          865  +// If both the connection callbacks and dwShareMode are non-NULL, the callbacks
          866  +// will be used.
          867  +//
          868  +
          869  +typedef struct {
          870  +    DWORD           dwStructSize;
          871  +    LPSTR           lpstrGroupNames;        // OPTIONAL reader groups to include in
          872  +    DWORD           nMaxGroupNames;         //          search.  NULL defaults to
          873  +                                            //          SCard$DefaultReaders
          874  +    LPCGUID         rgguidInterfaces;       // OPTIONAL requested interfaces
          875  +    DWORD           cguidInterfaces;        //          supported by card's SSP
          876  +    LPSTR           lpstrCardNames;         // OPTIONAL requested card names; all cards w/
          877  +    DWORD           nMaxCardNames;          //          matching ATRs will be accepted
          878  +    LPOCNCHKPROC    lpfnCheck;              // OPTIONAL if NULL no user check will be performed.
          879  +    LPOCNCONNPROCA  lpfnConnect;            // OPTIONAL if lpfnConnect is provided,
          880  +    LPOCNDSCPROC    lpfnDisconnect;         //          lpfnDisconnect must also be set.
          881  +    LPVOID          pvUserData;             // OPTIONAL parameter to callbacks
          882  +    DWORD           dwShareMode;            // OPTIONAL must be set if lpfnCheck is not null
          883  +    DWORD           dwPreferredProtocols;   // OPTIONAL
          884  +} OPENCARD_SEARCH_CRITERIAA, *POPENCARD_SEARCH_CRITERIAA, *LPOPENCARD_SEARCH_CRITERIAA;
          885  +typedef struct {
          886  +    DWORD           dwStructSize;
          887  +    LPWSTR          lpstrGroupNames;        // OPTIONAL reader groups to include in
          888  +    DWORD           nMaxGroupNames;         //          search.  NULL defaults to
          889  +                                            //          SCard$DefaultReaders
          890  +    LPCGUID         rgguidInterfaces;       // OPTIONAL requested interfaces
          891  +    DWORD           cguidInterfaces;        //          supported by card's SSP
          892  +    LPWSTR          lpstrCardNames;         // OPTIONAL requested card names; all cards w/
          893  +    DWORD           nMaxCardNames;          //          matching ATRs will be accepted
          894  +    LPOCNCHKPROC    lpfnCheck;              // OPTIONAL if NULL no user check will be performed.
          895  +    LPOCNCONNPROCW  lpfnConnect;            // OPTIONAL if lpfnConnect is provided,
          896  +    LPOCNDSCPROC    lpfnDisconnect;         //          lpfnDisconnect must also be set.
          897  +    LPVOID          pvUserData;             // OPTIONAL parameter to callbacks
          898  +    DWORD           dwShareMode;            // OPTIONAL must be set if lpfnCheck is not null
          899  +    DWORD           dwPreferredProtocols;   // OPTIONAL
          900  +} OPENCARD_SEARCH_CRITERIAW, *POPENCARD_SEARCH_CRITERIAW, *LPOPENCARD_SEARCH_CRITERIAW;
          901  +#ifdef UNICODE
          902  +typedef OPENCARD_SEARCH_CRITERIAW OPENCARD_SEARCH_CRITERIA;
          903  +typedef POPENCARD_SEARCH_CRITERIAW POPENCARD_SEARCH_CRITERIA;
          904  +typedef LPOPENCARD_SEARCH_CRITERIAW LPOPENCARD_SEARCH_CRITERIA;
          905  +#else
          906  +typedef OPENCARD_SEARCH_CRITERIAA OPENCARD_SEARCH_CRITERIA;
          907  +typedef POPENCARD_SEARCH_CRITERIAA POPENCARD_SEARCH_CRITERIA;
          908  +typedef LPOPENCARD_SEARCH_CRITERIAA LPOPENCARD_SEARCH_CRITERIA;
          909  +#endif // UNICODE
          910  +
          911  +
          912  +//
          913  +// OPENCARDNAME_EX: used by SCardUIDlgSelectCard; replaces obsolete OPENCARDNAME
          914  +//
          915  +
          916  +typedef struct {
          917  +    DWORD           dwStructSize;           // REQUIRED
          918  +    SCARDCONTEXT    hSCardContext;          // REQUIRED
          919  +    HWND            hwndOwner;              // OPTIONAL
          920  +    DWORD           dwFlags;                // OPTIONAL -- default is SC_DLG_MINIMAL_UI
          921  +    LPCSTR          lpstrTitle;             // OPTIONAL
          922  +    LPCSTR          lpstrSearchDesc;        // OPTIONAL (eg. "Please insert your <brandname> smart card.")
          923  +    HICON           hIcon;                  // OPTIONAL 32x32 icon for your brand insignia
          924  +    POPENCARD_SEARCH_CRITERIAA pOpenCardSearchCriteria; // OPTIONAL
          925  +    LPOCNCONNPROCA  lpfnConnect;            // OPTIONAL - performed on successful selection
          926  +    LPVOID          pvUserData;             // OPTIONAL parameter to lpfnConnect
          927  +    DWORD           dwShareMode;            // OPTIONAL - if lpfnConnect is NULL, dwShareMode and
          928  +    DWORD           dwPreferredProtocols;   // OPTIONAL dwPreferredProtocols will be used to
          929  +                                            //          connect to the selected card
          930  +    LPSTR           lpstrRdr;               // REQUIRED [IN|OUT] Name of selected reader
          931  +    DWORD           nMaxRdr;                // REQUIRED [IN|OUT]
          932  +    LPSTR           lpstrCard;              // REQUIRED [IN|OUT] Name of selected card
          933  +    DWORD           nMaxCard;               // REQUIRED [IN|OUT]
          934  +    DWORD           dwActiveProtocol;       // [OUT] set only if dwShareMode not NULL
          935  +    SCARDHANDLE     hCardHandle;            // [OUT] set if a card connection was indicated
          936  +} OPENCARDNAME_EXA, *POPENCARDNAME_EXA, *LPOPENCARDNAME_EXA;
          937  +typedef struct {
          938  +    DWORD           dwStructSize;           // REQUIRED
          939  +    SCARDCONTEXT    hSCardContext;          // REQUIRED
          940  +    HWND            hwndOwner;              // OPTIONAL
          941  +    DWORD           dwFlags;                // OPTIONAL -- default is SC_DLG_MINIMAL_UI
          942  +    LPCWSTR         lpstrTitle;             // OPTIONAL
          943  +    LPCWSTR         lpstrSearchDesc;        // OPTIONAL (eg. "Please insert your <brandname> smart card.")
          944  +    HICON           hIcon;                  // OPTIONAL 32x32 icon for your brand insignia
          945  +    POPENCARD_SEARCH_CRITERIAW pOpenCardSearchCriteria; // OPTIONAL
          946  +    LPOCNCONNPROCW  lpfnConnect;            // OPTIONAL - performed on successful selection
          947  +    LPVOID          pvUserData;             // OPTIONAL parameter to lpfnConnect
          948  +    DWORD           dwShareMode;            // OPTIONAL - if lpfnConnect is NULL, dwShareMode and
          949  +    DWORD           dwPreferredProtocols;   // OPTIONAL dwPreferredProtocols will be used to
          950  +                                            //          connect to the selected card
          951  +    LPWSTR          lpstrRdr;               // REQUIRED [IN|OUT] Name of selected reader
          952  +    DWORD           nMaxRdr;                // REQUIRED [IN|OUT]
          953  +    LPWSTR          lpstrCard;              // REQUIRED [IN|OUT] Name of selected card
          954  +    DWORD           nMaxCard;               // REQUIRED [IN|OUT]
          955  +    DWORD           dwActiveProtocol;       // [OUT] set only if dwShareMode not NULL
          956  +    SCARDHANDLE     hCardHandle;            // [OUT] set if a card connection was indicated
          957  +} OPENCARDNAME_EXW, *POPENCARDNAME_EXW, *LPOPENCARDNAME_EXW;
          958  +#ifdef UNICODE
          959  +typedef OPENCARDNAME_EXW OPENCARDNAME_EX;
          960  +typedef POPENCARDNAME_EXW POPENCARDNAME_EX;
          961  +typedef LPOPENCARDNAME_EXW LPOPENCARDNAME_EX;
          962  +#else
          963  +typedef OPENCARDNAME_EXA OPENCARDNAME_EX;
          964  +typedef POPENCARDNAME_EXA POPENCARDNAME_EX;
          965  +typedef LPOPENCARDNAME_EXA LPOPENCARDNAME_EX;
          966  +#endif // UNICODE
          967  +
          968  +#define OPENCARDNAMEA_EX OPENCARDNAME_EXA
          969  +#define OPENCARDNAMEW_EX OPENCARDNAME_EXW
          970  +#define POPENCARDNAMEA_EX POPENCARDNAME_EXA
          971  +#define POPENCARDNAMEW_EX POPENCARDNAME_EXW
          972  +#define LPOPENCARDNAMEA_EX LPOPENCARDNAME_EXA
          973  +#define LPOPENCARDNAMEW_EX LPOPENCARDNAME_EXW
          974  +
          975  +
          976  +//
          977  +// SCardUIDlgSelectCard replaces GetOpenCardName
          978  +//
          979  +
          980  +extern WINSCARDAPI LONG WINAPI
          981  +SCardUIDlgSelectCardA(
          982  +    LPOPENCARDNAMEA_EX);
          983  +extern WINSCARDAPI LONG WINAPI
          984  +SCardUIDlgSelectCardW(
          985  +    LPOPENCARDNAMEW_EX);
          986  +#ifdef UNICODE
          987  +#define SCardUIDlgSelectCard  SCardUIDlgSelectCardW
          988  +#else
          989  +#define SCardUIDlgSelectCard  SCardUIDlgSelectCardA
          990  +#endif // !UNICODE
          991  +
          992  +
          993  +//
          994  +// "Smart Card Common Dialog" definitions for backwards compatibility
          995  +//  with the Smart Card Base Services SDK version 1.0
          996  +//
          997  +
          998  +typedef struct {
          999  +    DWORD           dwStructSize;
         1000  +    HWND            hwndOwner;
         1001  +    SCARDCONTEXT    hSCardContext;
         1002  +    LPSTR           lpstrGroupNames;
         1003  +    DWORD           nMaxGroupNames;
         1004  +    LPSTR           lpstrCardNames;
         1005  +    DWORD           nMaxCardNames;
         1006  +    LPCGUID         rgguidInterfaces;
         1007  +    DWORD           cguidInterfaces;
         1008  +    LPSTR           lpstrRdr;
         1009  +    DWORD           nMaxRdr;
         1010  +    LPSTR           lpstrCard;
         1011  +    DWORD           nMaxCard;
         1012  +    LPCSTR          lpstrTitle;
         1013  +    DWORD           dwFlags;
         1014  +    LPVOID          pvUserData;
         1015  +    DWORD           dwShareMode;
         1016  +    DWORD           dwPreferredProtocols;
         1017  +    DWORD           dwActiveProtocol;
         1018  +    LPOCNCONNPROCA  lpfnConnect;
         1019  +    LPOCNCHKPROC    lpfnCheck;
         1020  +    LPOCNDSCPROC    lpfnDisconnect;
         1021  +    SCARDHANDLE     hCardHandle;
         1022  +} OPENCARDNAMEA, *POPENCARDNAMEA, *LPOPENCARDNAMEA;
         1023  +typedef struct {
         1024  +    DWORD           dwStructSize;
         1025  +    HWND            hwndOwner;
         1026  +    SCARDCONTEXT    hSCardContext;
         1027  +    LPWSTR          lpstrGroupNames;
         1028  +    DWORD           nMaxGroupNames;
         1029  +    LPWSTR          lpstrCardNames;
         1030  +    DWORD           nMaxCardNames;
         1031  +    LPCGUID         rgguidInterfaces;
         1032  +    DWORD           cguidInterfaces;
         1033  +    LPWSTR          lpstrRdr;
         1034  +    DWORD           nMaxRdr;
         1035  +    LPWSTR          lpstrCard;
         1036  +    DWORD           nMaxCard;
         1037  +    LPCWSTR         lpstrTitle;
         1038  +    DWORD           dwFlags;
         1039  +    LPVOID          pvUserData;
         1040  +    DWORD           dwShareMode;
         1041  +    DWORD           dwPreferredProtocols;
         1042  +    DWORD           dwActiveProtocol;
         1043  +    LPOCNCONNPROCW  lpfnConnect;
         1044  +    LPOCNCHKPROC    lpfnCheck;
         1045  +    LPOCNDSCPROC    lpfnDisconnect;
         1046  +    SCARDHANDLE     hCardHandle;
         1047  +} OPENCARDNAMEW, *POPENCARDNAMEW, *LPOPENCARDNAMEW;
         1048  +#ifdef UNICODE
         1049  +typedef OPENCARDNAMEW OPENCARDNAME;
         1050  +typedef POPENCARDNAMEW POPENCARDNAME;
         1051  +typedef LPOPENCARDNAMEW LPOPENCARDNAME;
         1052  +#else
         1053  +typedef OPENCARDNAMEA OPENCARDNAME;
         1054  +typedef POPENCARDNAMEA POPENCARDNAME;
         1055  +typedef LPOPENCARDNAMEA LPOPENCARDNAME;
         1056  +#endif // UNICODE
         1057  +
         1058  +// Backwards compatibility macros
         1059  +#define OPENCARDNAME_A OPENCARDNAMEA
         1060  +#define OPENCARDNAME_W OPENCARDNAMEW
         1061  +#define POPENCARDNAME_A POPENCARDNAMEA
         1062  +#define POPENCARDNAME_W POPENCARDNAMEW
         1063  +#define LPOPENCARDNAME_A LPOPENCARDNAMEA
         1064  +#define LPOPENCARDNAME_W LPOPENCARDNAMEW
         1065  +
         1066  +extern WINSCARDAPI LONG WINAPI
         1067  +GetOpenCardNameA(
         1068  +    LPOPENCARDNAMEA);
         1069  +extern WINSCARDAPI LONG WINAPI
         1070  +GetOpenCardNameW(
         1071  +    LPOPENCARDNAMEW);
         1072  +#ifdef UNICODE
         1073  +#define GetOpenCardName  GetOpenCardNameW
         1074  +#else
         1075  +#define GetOpenCardName  GetOpenCardNameA
         1076  +#endif // !UNICODE
         1077  +
         1078  +extern WINSCARDAPI LONG WINAPI
         1079  +SCardDlgExtendedError (void);
         1080  +
         1081  +#if (NTDDI_VERSION >= NTDDI_VISTA)
         1082  +
         1083  +//
         1084  +// Smartcard Caching API
         1085  +//
         1086  +
         1087  +extern WINSCARDAPI LONG WINAPI
         1088  +SCardReadCacheA(
         1089  +    __in  SCARDCONTEXT hContext,
         1090  +    __in  UUID *CardIdentifier,
         1091  +    __in  DWORD FreshnessCounter,
         1092  +    __in  LPSTR LookupName,
         1093  +    __out_bcount(*DataLen) PBYTE Data,
         1094  +    __out DWORD *DataLen);
         1095  +extern WINSCARDAPI LONG WINAPI
         1096  +SCardReadCacheW(
         1097  +    __in  SCARDCONTEXT hContext,
         1098  +    __in  UUID *CardIdentifier,
         1099  +    __in  DWORD FreshnessCounter,
         1100  +    __in  LPWSTR LookupName,
         1101  +    __out_bcount(*DataLen) PBYTE Data,
         1102  +    __out DWORD *DataLen);
         1103  +#ifdef UNICODE
         1104  +#define SCardReadCache  SCardReadCacheW
         1105  +#else
         1106  +#define SCardReadCache  SCardReadCacheA
         1107  +#endif // !UNICODE
         1108  +
         1109  +extern WINSCARDAPI LONG WINAPI
         1110  +SCardWriteCacheA(
         1111  +    __in SCARDCONTEXT hContext,
         1112  +    __in UUID *CardIdentifier,
         1113  +    __in DWORD FreshnessCounter,
         1114  +    __in LPSTR LookupName,
         1115  +    __in_bcount(DataLen) PBYTE Data,
         1116  +    __in DWORD DataLen);
         1117  +extern WINSCARDAPI LONG WINAPI
         1118  +SCardWriteCacheW(
         1119  +    __in SCARDCONTEXT hContext,
         1120  +    __in UUID *CardIdentifier,
         1121  +    __in DWORD FreshnessCounter,
         1122  +    __in LPWSTR LookupName,
         1123  +    __in_bcount(DataLen) PBYTE Data,
         1124  +    __in DWORD DataLen);
         1125  +#ifdef UNICODE
         1126  +#define SCardWriteCache  SCardWriteCacheW
         1127  +#else
         1128  +#define SCardWriteCache  SCardWriteCacheA
         1129  +#endif // !UNICODE
         1130  +
         1131  +#endif // (NTDDI_VERSION >= NTDDI_VISTA)
         1132  +
         1133  +#ifdef __cplusplus
         1134  +}
         1135  +#endif
         1136  +#endif // _WINSCARD_H_
         1137  +
         1138  +

Added build/cackey_win64_build/include/winsmcrd.h version [b14ff00d72].

            1  +/*++
            2  +
            3  +Copyright (c) 1996  Microsoft Corporation
            4  +
            5  +Module Name:
            6  +
            7  +    winsmcrd.h
            8  +
            9  +Abstract:
           10  +    Smart Card class/port IOCTL codes. This file is required for all code
           11  +    user mode and kernel mode, using Smart Card IOCTL's, defines,
           12  +    data structures
           13  +
           14  +Revision History:
           15  +
           16  +--*/
           17  +
           18  +
           19  +#ifndef _NTDDSCRD_H2_
           20  +#define _NTDDSCRD_H2_
           21  +
           22  +#if defined (_MSC_VER) && (_MSC_VER >= 1020)
           23  +#pragma once
           24  +#endif
           25  +
           26  +#ifdef __cplusplus
           27  +extern "C" {
           28  +#endif
           29  +
           30  +#ifdef _WINSCARD_H_
           31  +typedef DWORD ULONG;
           32  +typedef WORD UWORD;
           33  +typedef BYTE UCHAR;
           34  +#else
           35  +typedef ULONG DWORD;
           36  +// typedef UWORD WORD;
           37  +typedef UCHAR BYTE;
           38  +#endif
           39  +
           40  +#ifndef DEVICE_TYPE_SMARTCARD
           41  +#define FILE_DEVICE_SMARTCARD           0x00000031
           42  +#else
           43  +#if 0x00000031 != FILE_DEVICE_SMARTCARD
           44  +#error "Incorrect Smart Card Device Definition"
           45  +#endif
           46  +#endif
           47  +
           48  +
           49  +//
           50  +// Various constants
           51  +//
           52  +
           53  +#define SCARD_ATR_LENGTH 33  // ISO 7816-3 spec.
           54  +
           55  +//
           56  +///////////////////////////////////////////////////////////////////////////////
           57  +//
           58  +//  Protocol Flag definitions
           59  +//
           60  +
           61  +#define SCARD_PROTOCOL_UNDEFINED    0x00000000  // There is no active protocol.
           62  +#define SCARD_PROTOCOL_T0           0x00000001  // T=0 is the active protocol.
           63  +#define SCARD_PROTOCOL_T1           0x00000002  // T=1 is the active protocol.
           64  +#define SCARD_PROTOCOL_RAW          0x00010000  // Raw is the active protocol.
           65  +//
           66  +// This is the mask of ISO defined transmission protocols
           67  +//
           68  +#define SCARD_PROTOCOL_Tx           (SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1)
           69  +//
           70  +// Use the default transmission parameters / card clock freq.
           71  +//
           72  +#define SCARD_PROTOCOL_DEFAULT      0x80000000
           73  +//
           74  +// Use optimal transmission parameters / card clock freq.
           75  +// Since using the optimal parameters is the default case no bit is defined to be 1
           76  +//
           77  +#define SCARD_PROTOCOL_OPTIMAL      0x00000000
           78  +
           79  +
           80  +//
           81  +// Ioctl parameters 1 for IOCTL_SMARTCARD_POWER
           82  +//
           83  +#define SCARD_POWER_DOWN 0          // Power down the card.
           84  +#define SCARD_COLD_RESET 1          // Cycle power and reset the card.
           85  +#define SCARD_WARM_RESET 2          // Force a reset on the card.
           86  +
           87  +//
           88  +///////////////////////////////////////////////////////////////////////////////
           89  +//
           90  +//  Reader Action IOCTLs
           91  +//
           92  +
           93  +#define SCARD_CTL_CODE(code)        CTL_CODE(FILE_DEVICE_SMARTCARD, \
           94  +                                            (code), \
           95  +                                            METHOD_BUFFERED, \
           96  +                                            FILE_ANY_ACCESS)
           97  +
           98  +#define IOCTL_SMARTCARD_POWER           SCARD_CTL_CODE( 1)
           99  +#define IOCTL_SMARTCARD_GET_ATTRIBUTE   SCARD_CTL_CODE( 2)
          100  +#define IOCTL_SMARTCARD_SET_ATTRIBUTE   SCARD_CTL_CODE( 3)
          101  +#define IOCTL_SMARTCARD_CONFISCATE      SCARD_CTL_CODE( 4)
          102  +#define IOCTL_SMARTCARD_TRANSMIT        SCARD_CTL_CODE( 5)
          103  +#define IOCTL_SMARTCARD_EJECT           SCARD_CTL_CODE( 6)
          104  +#define IOCTL_SMARTCARD_SWALLOW         SCARD_CTL_CODE( 7)
          105  +// #define IOCTL_SMARTCARD_READ            SCARD_CTL_CODE( 8) obsolete
          106  +// #define IOCTL_SMARTCARD_WRITE           SCARD_CTL_CODE( 9) obsolete
          107  +#define IOCTL_SMARTCARD_IS_PRESENT      SCARD_CTL_CODE(10)
          108  +#define IOCTL_SMARTCARD_IS_ABSENT       SCARD_CTL_CODE(11)
          109  +#define IOCTL_SMARTCARD_SET_PROTOCOL    SCARD_CTL_CODE(12)
          110  +#define IOCTL_SMARTCARD_GET_STATE       SCARD_CTL_CODE(14)
          111  +#define IOCTL_SMARTCARD_GET_LAST_ERROR  SCARD_CTL_CODE(15)
          112  +#define IOCTL_SMARTCARD_GET_PERF_CNTR   SCARD_CTL_CODE(16)
          113  +
          114  +
          115  +//
          116  +///////////////////////////////////////////////////////////////////////////////
          117  +//
          118  +// Tags for requesting card and reader attributes
          119  +//
          120  +
          121  +#define MAXIMUM_ATTR_STRING_LENGTH 32   // Nothing bigger than this from getAttr
          122  +#define MAXIMUM_SMARTCARD_READERS  10   // Limit the readers on the system
          123  +
          124  +#define SCARD_ATTR_VALUE(Class, Tag) ((((ULONG)(Class)) << 16) | ((ULONG)(Tag)))
          125  +
          126  +#define SCARD_CLASS_VENDOR_INFO     1   // Vendor information definitions
          127  +#define SCARD_CLASS_COMMUNICATIONS  2   // Communication definitions
          128  +#define SCARD_CLASS_PROTOCOL        3   // Protocol definitions
          129  +#define SCARD_CLASS_POWER_MGMT      4   // Power Management definitions
          130  +#define SCARD_CLASS_SECURITY        5   // Security Assurance definitions
          131  +#define SCARD_CLASS_MECHANICAL      6   // Mechanical characteristic definitions
          132  +#define SCARD_CLASS_VENDOR_DEFINED  7   // Vendor specific definitions
          133  +#define SCARD_CLASS_IFD_PROTOCOL    8   // Interface Device Protocol options
          134  +#define SCARD_CLASS_ICC_STATE       9   // ICC State specific definitions
          135  +#define SCARD_CLASS_PERF       0x7ffe   // performace counters
          136  +#define SCARD_CLASS_SYSTEM     0x7fff   // System-specific definitions
          137  +
          138  +#define SCARD_ATTR_VENDOR_NAME SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0100)
          139  +#define SCARD_ATTR_VENDOR_IFD_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0101)
          140  +#define SCARD_ATTR_VENDOR_IFD_VERSION SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0102)
          141  +#define SCARD_ATTR_VENDOR_IFD_SERIAL_NO SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0103)
          142  +#define SCARD_ATTR_CHANNEL_ID SCARD_ATTR_VALUE(SCARD_CLASS_COMMUNICATIONS, 0x0110)
          143  +#define SCARD_ATTR_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120)
          144  +// #define SCARD_ATTR_ASYNC_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120)
          145  +#define SCARD_ATTR_DEFAULT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0121)
          146  +#define SCARD_ATTR_MAX_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0122)
          147  +#define SCARD_ATTR_DEFAULT_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0123)
          148  +#define SCARD_ATTR_MAX_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0124)
          149  +#define SCARD_ATTR_MAX_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0125)
          150  +// #define SCARD_ATTR_SYNC_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0126)
          151  +#define SCARD_ATTR_POWER_MGMT_SUPPORT SCARD_ATTR_VALUE(SCARD_CLASS_POWER_MGMT, 0x0131)
          152  +#define SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0140)
          153  +#define SCARD_ATTR_USER_AUTH_INPUT_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0142)
          154  +#define SCARD_ATTR_CHARACTERISTICS SCARD_ATTR_VALUE(SCARD_CLASS_MECHANICAL, 0x0150)
          155  +
          156  +#define SCARD_ATTR_CURRENT_PROTOCOL_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0201)
          157  +#define SCARD_ATTR_CURRENT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0202)
          158  +#define SCARD_ATTR_CURRENT_F SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0203)
          159  +#define SCARD_ATTR_CURRENT_D SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0204)
          160  +#define SCARD_ATTR_CURRENT_N SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0205)
          161  +#define SCARD_ATTR_CURRENT_W SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0206)
          162  +#define SCARD_ATTR_CURRENT_IFSC SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0207)
          163  +#define SCARD_ATTR_CURRENT_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0208)
          164  +#define SCARD_ATTR_CURRENT_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0209)
          165  +#define SCARD_ATTR_CURRENT_CWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020a)
          166  +#define SCARD_ATTR_CURRENT_EBC_ENCODING SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020b)
          167  +#define SCARD_ATTR_EXTENDED_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020c)
          168  +
          169  +#define SCARD_ATTR_ICC_PRESENCE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0300)
          170  +#define SCARD_ATTR_ICC_INTERFACE_STATUS SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0301)
          171  +#define SCARD_ATTR_CURRENT_IO_STATE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0302)
          172  +#define SCARD_ATTR_ATR_STRING SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0303)
          173  +#define SCARD_ATTR_ICC_TYPE_PER_ATR SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0304)
          174  +
          175  +#define SCARD_ATTR_ESC_RESET SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA000)
          176  +#define SCARD_ATTR_ESC_CANCEL SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA003)
          177  +#define SCARD_ATTR_ESC_AUTHREQUEST SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA005)
          178  +#define SCARD_ATTR_MAXINPUT SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA007)
          179  +
          180  +#define SCARD_ATTR_DEVICE_UNIT SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0001)
          181  +#define SCARD_ATTR_DEVICE_IN_USE SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0002)
          182  +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0003)
          183  +#define SCARD_ATTR_DEVICE_SYSTEM_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0004)
          184  +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0005)
          185  +#define SCARD_ATTR_DEVICE_SYSTEM_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0006)
          186  +#define SCARD_ATTR_SUPRESS_T1_IFS_REQUEST SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0007)
          187  +
          188  +#define SCARD_PERF_NUM_TRANSMISSIONS SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0001)
          189  +#define SCARD_PERF_BYTES_TRANSMITTED SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0002)
          190  +#define SCARD_PERF_TRANSMISSION_TIME SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0003)
          191  +
          192  +#ifdef UNICODE
          193  +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
          194  +#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_W
          195  +#else
          196  +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
          197  +#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_A
          198  +#endif
          199  +
          200  +
          201  +//
          202  +// T=0 Protocol Defines
          203  +//
          204  +
          205  +#define SCARD_T0_HEADER_LENGTH 7
          206  +#define SCARD_T0_CMD_LENGTH 5
          207  +
          208  +
          209  +//
          210  +// T=1 Protocol Defines
          211  +//
          212  +
          213  +#define SCARD_T1_PROLOGUE_LENGTH 3
          214  +#define SCARD_T1_EPILOGUE_LENGTH 2
          215  +#define SCARD_T1_MAX_IFS 254
          216  +
          217  +
          218  +//
          219  +///////////////////////////////////////////////////////////////////////////////
          220  +//
          221  +//  Reader states
          222  +//
          223  +
          224  +#define SCARD_UNKNOWN     0   // This value implies the driver is unaware
          225  +                              // of the current state of the reader.
          226  +#define SCARD_ABSENT      1   // This value implies there is no card in
          227  +                              // the reader.
          228  +#define SCARD_PRESENT     2   // This value implies there is a card is
          229  +                              // present in the reader, but that it has
          230  +                              // not been moved into position for use.
          231  +#define SCARD_SWALLOWED   3   // This value implies there is a card in the
          232  +                              // reader in position for use.  The card is
          233  +                              // not powered.
          234  +#define SCARD_POWERED     4   // This value implies there is power is
          235  +                              // being provided to the card, but the
          236  +                              // Reader Driver is unaware of the mode of
          237  +                              // the card.
          238  +#define SCARD_NEGOTIABLE  5   // This value implies the card has been
          239  +                              // reset and is awaiting PTS negotiation.
          240  +#define SCARD_SPECIFIC    6   // This value implies the card has been
          241  +                              // reset and specific communication
          242  +                              // protocols have been established.
          243  +
          244  +////////////////////////////////////////////////////////////////////////////////
          245  +//
          246  +//  I/O Services
          247  +//
          248  +//      The following services provide access to the I/O capabilities of the
          249  +//      reader drivers.  Services of the Smart Card are requested by placing the
          250  +//      following structure into the protocol buffer:
          251  +//
          252  +
          253  +
          254  +typedef struct _SCARD_IO_REQUEST{
          255  +    DWORD dwProtocol;   // Protocol identifier
          256  +    DWORD cbPciLength;  // Protocol Control Information Length
          257  +} SCARD_IO_REQUEST, *PSCARD_IO_REQUEST, *LPSCARD_IO_REQUEST;
          258  +typedef const SCARD_IO_REQUEST *LPCSCARD_IO_REQUEST;
          259  +
          260  +
          261  +//
          262  +// T=0 protocol services.
          263  +//
          264  +
          265  +typedef struct {
          266  +    BYTE
          267  +        bCla,   // The instruction class
          268  +        bIns,   // The instruction code within the instruction class
          269  +        bP1,
          270  +        bP2,    // Parameters to the instruction
          271  +        bP3;    // Size of I/O Transfer
          272  +} SCARD_T0_COMMAND, *LPSCARD_T0_COMMAND;
          273  +
          274  +typedef struct {
          275  +    SCARD_IO_REQUEST ioRequest;
          276  +    BYTE
          277  +        bSw1,
          278  +        bSw2;           // Return codes from the instruction
          279  +    union
          280  +    {
          281  +        SCARD_T0_COMMAND CmdBytes;
          282  +        BYTE rgbHeader[5];
          283  +    } DUMMYUNIONNAME;
          284  +} SCARD_T0_REQUEST;
          285  +
          286  +typedef SCARD_T0_REQUEST *PSCARD_T0_REQUEST, *LPSCARD_T0_REQUEST;
          287  +
          288  +
          289  +//
          290  +//  T=1 Protocol Services
          291  +//
          292  +
          293  +typedef struct {
          294  +    SCARD_IO_REQUEST ioRequest;
          295  +} SCARD_T1_REQUEST;
          296  +typedef SCARD_T1_REQUEST *PSCARD_T1_REQUEST, *LPSCARD_T1_REQUEST;
          297  +
          298  +
          299  +//
          300  +////////////////////////////////////////////////////////////////////////////////
          301  +//
          302  +//  Driver attribute flags
          303  +//
          304  +
          305  +#define SCARD_READER_SWALLOWS       0x00000001  // Reader has a card swallowing
          306  +                                                // mechanism.
          307  +#define SCARD_READER_EJECTS         0x00000002  // Reader has a card ejection
          308  +                                                // mechanism.
          309  +#define SCARD_READER_CONFISCATES    0x00000004  // Reader has a card capture
          310  +                                                // mechanism.
          311  +
          312  +//
          313  +///////////////////////////////////////////////////////////////////////////////
          314  +//
          315  +// Type of reader
          316  +//
          317  +#define SCARD_READER_TYPE_SERIAL    0x01
          318  +#define SCARD_READER_TYPE_PARALELL  0x02
          319  +#define SCARD_READER_TYPE_KEYBOARD  0x04
          320  +#define SCARD_READER_TYPE_SCSI      0x08
          321  +#define SCARD_READER_TYPE_IDE       0x10
          322  +#define SCARD_READER_TYPE_USB       0x20
          323  +#define SCARD_READER_TYPE_PCMCIA    0x40
          324  +#define SCARD_READER_TYPE_VENDOR    0xF0
          325  +
          326  +#ifdef __cplusplus
          327  +}
          328  +#endif
          329  +#endif
          330  +
          331  +

Added build/cackey_win64_build/include/zconf.h version [2806b070c7].

            1  +/* zconf.h -- configuration of the zlib compression library
            2  + * Copyright (C) 1995-2012 Jean-loup Gailly.
            3  + * For conditions of distribution and use, see copyright notice in zlib.h
            4  + */
            5  +
            6  +/* @(#) $Id$ */
            7  +
            8  +#ifndef ZCONF_H
            9  +#define ZCONF_H
           10  +
           11  +/*
           12  + * If you *really* need a unique prefix for all types and library functions,
           13  + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
           14  + * Even better than compiling with -DZ_PREFIX would be to use configure to set
           15  + * this permanently in zconf.h using "./configure --zprefix".
           16  + */
           17  +#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
           18  +#  define Z_PREFIX_SET
           19  +
           20  +/* all linked symbols */
           21  +#  define _dist_code            z__dist_code
           22  +#  define _length_code          z__length_code
           23  +#  define _tr_align             z__tr_align
           24  +#  define _tr_flush_block       z__tr_flush_block
           25  +#  define _tr_init              z__tr_init
           26  +#  define _tr_stored_block      z__tr_stored_block
           27  +#  define _tr_tally             z__tr_tally
           28  +#  define adler32               z_adler32
           29  +#  define adler32_combine       z_adler32_combine
           30  +#  define adler32_combine64     z_adler32_combine64
           31  +#  ifndef Z_SOLO
           32  +#    define compress              z_compress
           33  +#    define compress2             z_compress2
           34  +#    define compressBound         z_compressBound
           35  +#  endif
           36  +#  define crc32                 z_crc32
           37  +#  define crc32_combine         z_crc32_combine
           38  +#  define crc32_combine64       z_crc32_combine64
           39  +#  define deflate               z_deflate
           40  +#  define deflateBound          z_deflateBound
           41  +#  define deflateCopy           z_deflateCopy
           42  +#  define deflateEnd            z_deflateEnd
           43  +#  define deflateInit2_         z_deflateInit2_
           44  +#  define deflateInit_          z_deflateInit_
           45  +#  define deflateParams         z_deflateParams
           46  +#  define deflatePending        z_deflatePending
           47  +#  define deflatePrime          z_deflatePrime
           48  +#  define deflateReset          z_deflateReset
           49  +#  define deflateResetKeep      z_deflateResetKeep
           50  +#  define deflateSetDictionary  z_deflateSetDictionary
           51  +#  define deflateSetHeader      z_deflateSetHeader
           52  +#  define deflateTune           z_deflateTune
           53  +#  define deflate_copyright     z_deflate_copyright
           54  +#  define get_crc_table         z_get_crc_table
           55  +#  ifndef Z_SOLO
           56  +#    define gz_error              z_gz_error
           57  +#    define gz_intmax             z_gz_intmax
           58  +#    define gz_strwinerror        z_gz_strwinerror
           59  +#    define gzbuffer              z_gzbuffer
           60  +#    define gzclearerr            z_gzclearerr
           61  +#    define gzclose               z_gzclose
           62  +#    define gzclose_r             z_gzclose_r
           63  +#    define gzclose_w             z_gzclose_w
           64  +#    define gzdirect              z_gzdirect
           65  +#    define gzdopen               z_gzdopen
           66  +#    define gzeof                 z_gzeof
           67  +#    define gzerror               z_gzerror
           68  +#    define gzflush               z_gzflush
           69  +#    define gzgetc                z_gzgetc
           70  +#    define gzgetc_               z_gzgetc_
           71  +#    define gzgets                z_gzgets
           72  +#    define gzoffset              z_gzoffset
           73  +#    define gzoffset64            z_gzoffset64
           74  +#    define gzopen                z_gzopen
           75  +#    define gzopen64              z_gzopen64
           76  +#    ifdef _WIN32
           77  +#      define gzopen_w              z_gzopen_w
           78  +#    endif
           79  +#    define gzprintf              z_gzprintf
           80  +#    define gzputc                z_gzputc
           81  +#    define gzputs                z_gzputs
           82  +#    define gzread                z_gzread
           83  +#    define gzrewind              z_gzrewind
           84  +#    define gzseek                z_gzseek
           85  +#    define gzseek64              z_gzseek64
           86  +#    define gzsetparams           z_gzsetparams
           87  +#    define gztell                z_gztell
           88  +#    define gztell64              z_gztell64
           89  +#    define gzungetc              z_gzungetc
           90  +#    define gzwrite               z_gzwrite
           91  +#  endif
           92  +#  define inflate               z_inflate
           93  +#  define inflateBack           z_inflateBack
           94  +#  define inflateBackEnd        z_inflateBackEnd
           95  +#  define inflateBackInit_      z_inflateBackInit_
           96  +#  define inflateCopy           z_inflateCopy
           97  +#  define inflateEnd            z_inflateEnd
           98  +#  define inflateGetHeader      z_inflateGetHeader
           99  +#  define inflateInit2_         z_inflateInit2_
          100  +#  define inflateInit_          z_inflateInit_
          101  +#  define inflateMark           z_inflateMark
          102  +#  define inflatePrime          z_inflatePrime
          103  +#  define inflateReset          z_inflateReset
          104  +#  define inflateReset2         z_inflateReset2
          105  +#  define inflateSetDictionary  z_inflateSetDictionary
          106  +#  define inflateSync           z_inflateSync
          107  +#  define inflateSyncPoint      z_inflateSyncPoint
          108  +#  define inflateUndermine      z_inflateUndermine
          109  +#  define inflateResetKeep      z_inflateResetKeep
          110  +#  define inflate_copyright     z_inflate_copyright
          111  +#  define inflate_fast          z_inflate_fast
          112  +#  define inflate_table         z_inflate_table
          113  +#  ifndef Z_SOLO
          114  +#    define uncompress            z_uncompress
          115  +#  endif
          116  +#  define zError                z_zError
          117  +#  ifndef Z_SOLO
          118  +#    define zcalloc               z_zcalloc
          119  +#    define zcfree                z_zcfree
          120  +#  endif
          121  +#  define zlibCompileFlags      z_zlibCompileFlags
          122  +#  define zlibVersion           z_zlibVersion
          123  +
          124  +/* all zlib typedefs in zlib.h and zconf.h */
          125  +#  define Byte                  z_Byte
          126  +#  define Bytef                 z_Bytef
          127  +#  define alloc_func            z_alloc_func
          128  +#  define charf                 z_charf
          129  +#  define free_func             z_free_func
          130  +#  ifndef Z_SOLO
          131  +#    define gzFile                z_gzFile
          132  +#  endif
          133  +#  define gz_header             z_gz_header
          134  +#  define gz_headerp            z_gz_headerp
          135  +#  define in_func               z_in_func
          136  +#  define intf                  z_intf
          137  +#  define out_func              z_out_func
          138  +#  define uInt                  z_uInt
          139  +#  define uIntf                 z_uIntf
          140  +#  define uLong                 z_uLong
          141  +#  define uLongf                z_uLongf
          142  +#  define voidp                 z_voidp
          143  +#  define voidpc                z_voidpc
          144  +#  define voidpf                z_voidpf
          145  +
          146  +/* all zlib structs in zlib.h and zconf.h */
          147  +#  define gz_header_s           z_gz_header_s
          148  +#  define internal_state        z_internal_state
          149  +
          150  +#endif
          151  +
          152  +#if defined(__MSDOS__) && !defined(MSDOS)
          153  +#  define MSDOS
          154  +#endif
          155  +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
          156  +#  define OS2
          157  +#endif
          158  +#if defined(_WINDOWS) && !defined(WINDOWS)
          159  +#  define WINDOWS
          160  +#endif
          161  +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
          162  +#  ifndef WIN32
          163  +#    define WIN32
          164  +#  endif
          165  +#endif
          166  +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
          167  +#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
          168  +#    ifndef SYS16BIT
          169  +#      define SYS16BIT
          170  +#    endif
          171  +#  endif
          172  +#endif
          173  +
          174  +/*
          175  + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
          176  + * than 64k bytes at a time (needed on systems with 16-bit int).
          177  + */
          178  +#ifdef SYS16BIT
          179  +#  define MAXSEG_64K
          180  +#endif
          181  +#ifdef MSDOS
          182  +#  define UNALIGNED_OK
          183  +#endif
          184  +
          185  +#ifdef __STDC_VERSION__
          186  +#  ifndef STDC
          187  +#    define STDC
          188  +#  endif
          189  +#  if __STDC_VERSION__ >= 199901L
          190  +#    ifndef STDC99
          191  +#      define STDC99
          192  +#    endif
          193  +#  endif
          194  +#endif
          195  +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
          196  +#  define STDC
          197  +#endif
          198  +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
          199  +#  define STDC
          200  +#endif
          201  +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
          202  +#  define STDC
          203  +#endif
          204  +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
          205  +#  define STDC
          206  +#endif
          207  +
          208  +#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
          209  +#  define STDC
          210  +#endif
          211  +
          212  +#ifndef STDC
          213  +#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
          214  +#    define const       /* note: need a more gentle solution here */
          215  +#  endif
          216  +#endif
          217  +
          218  +#if defined(ZLIB_CONST) && !defined(z_const)
          219  +#  define z_const const
          220  +#else
          221  +#  define z_const
          222  +#endif
          223  +
          224  +/* Some Mac compilers merge all .h files incorrectly: */
          225  +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
          226  +#  define NO_DUMMY_DECL
          227  +#endif
          228  +
          229  +/* Maximum value for memLevel in deflateInit2 */
          230  +#ifndef MAX_MEM_LEVEL
          231  +#  ifdef MAXSEG_64K
          232  +#    define MAX_MEM_LEVEL 8
          233  +#  else
          234  +#    define MAX_MEM_LEVEL 9
          235  +#  endif
          236  +#endif
          237  +
          238  +/* Maximum value for windowBits in deflateInit2 and inflateInit2.
          239  + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
          240  + * created by gzip. (Files created by minigzip can still be extracted by
          241  + * gzip.)
          242  + */
          243  +#ifndef MAX_WBITS
          244  +#  define MAX_WBITS   15 /* 32K LZ77 window */
          245  +#endif
          246  +
          247  +/* The memory requirements for deflate are (in bytes):
          248  +            (1 << (windowBits+2)) +  (1 << (memLevel+9))
          249  + that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
          250  + plus a few kilobytes for small objects. For example, if you want to reduce
          251  + the default memory requirements from 256K to 128K, compile with
          252  +     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
          253  + Of course this will generally degrade compression (there's no free lunch).
          254  +
          255  +   The memory requirements for inflate are (in bytes) 1 << windowBits
          256  + that is, 32K for windowBits=15 (default value) plus a few kilobytes
          257  + for small objects.
          258  +*/
          259  +
          260  +                        /* Type declarations */
          261  +
          262  +#ifndef OF /* function prototypes */
          263  +#  ifdef STDC
          264  +#    define OF(args)  args
          265  +#  else
          266  +#    define OF(args)  ()
          267  +#  endif
          268  +#endif
          269  +
          270  +#ifndef Z_ARG /* function prototypes for stdarg */
          271  +#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
          272  +#    define Z_ARG(args)  args
          273  +#  else
          274  +#    define Z_ARG(args)  ()
          275  +#  endif
          276  +#endif
          277  +
          278  +/* The following definitions for FAR are needed only for MSDOS mixed
          279  + * model programming (small or medium model with some far allocations).
          280  + * This was tested only with MSC; for other MSDOS compilers you may have
          281  + * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
          282  + * just define FAR to be empty.
          283  + */
          284  +#ifdef SYS16BIT
          285  +#  if defined(M_I86SM) || defined(M_I86MM)
          286  +     /* MSC small or medium model */
          287  +#    define SMALL_MEDIUM
          288  +#    ifdef _MSC_VER
          289  +#      define FAR _far
          290  +#    else
          291  +#      define FAR far
          292  +#    endif
          293  +#  endif
          294  +#  if (defined(__SMALL__) || defined(__MEDIUM__))
          295  +     /* Turbo C small or medium model */
          296  +#    define SMALL_MEDIUM
          297  +#    ifdef __BORLANDC__
          298  +#      define FAR _far
          299  +#    else
          300  +#      define FAR far
          301  +#    endif
          302  +#  endif
          303  +#endif
          304  +
          305  +#if defined(WINDOWS) || defined(WIN32)
          306  +   /* If building or using zlib as a DLL, define ZLIB_DLL.
          307  +    * This is not mandatory, but it offers a little performance increase.
          308  +    */
          309  +#  ifdef ZLIB_DLL
          310  +#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
          311  +#      ifdef ZLIB_INTERNAL
          312  +#        define ZEXTERN extern __declspec(dllexport)
          313  +#      else
          314  +#        define ZEXTERN extern __declspec(dllimport)
          315  +#      endif
          316  +#    endif
          317  +#  endif  /* ZLIB_DLL */
          318  +   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
          319  +    * define ZLIB_WINAPI.
          320  +    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
          321  +    */
          322  +#  ifdef ZLIB_WINAPI
          323  +#    ifdef FAR
          324  +#      undef FAR
          325  +#    endif
          326  +#    include <windows.h>
          327  +     /* No need for _export, use ZLIB.DEF instead. */
          328  +     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
          329  +#    define ZEXPORT WINAPI
          330  +#    ifdef WIN32
          331  +#      define ZEXPORTVA WINAPIV
          332  +#    else
          333  +#      define ZEXPORTVA FAR CDECL
          334  +#    endif
          335  +#  endif
          336  +#endif
          337  +
          338  +#if defined (__BEOS__)
          339  +#  ifdef ZLIB_DLL
          340  +#    ifdef ZLIB_INTERNAL
          341  +#      define ZEXPORT   __declspec(dllexport)
          342  +#      define ZEXPORTVA __declspec(dllexport)
          343  +#    else
          344  +#      define ZEXPORT   __declspec(dllimport)
          345  +#      define ZEXPORTVA __declspec(dllimport)
          346  +#    endif
          347  +#  endif
          348  +#endif
          349  +
          350  +#ifndef ZEXTERN
          351  +#  define ZEXTERN extern
          352  +#endif
          353  +#ifndef ZEXPORT
          354  +#  define ZEXPORT
          355  +#endif
          356  +#ifndef ZEXPORTVA
          357  +#  define ZEXPORTVA
          358  +#endif
          359  +
          360  +#ifndef FAR
          361  +#  define FAR
          362  +#endif
          363  +
          364  +#if !defined(__MACTYPES__)
          365  +typedef unsigned char  Byte;  /* 8 bits */
          366  +#endif
          367  +typedef unsigned int   uInt;  /* 16 bits or more */
          368  +typedef unsigned long  uLong; /* 32 bits or more */
          369  +
          370  +#ifdef SMALL_MEDIUM
          371  +   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
          372  +#  define Bytef Byte FAR
          373  +#else
          374  +   typedef Byte  FAR Bytef;
          375  +#endif
          376  +typedef char  FAR charf;
          377  +typedef int   FAR intf;
          378  +typedef uInt  FAR uIntf;
          379  +typedef uLong FAR uLongf;
          380  +
          381  +#ifdef STDC
          382  +   typedef void const *voidpc;
          383  +   typedef void FAR   *voidpf;
          384  +   typedef void       *voidp;
          385  +#else
          386  +   typedef Byte const *voidpc;
          387  +   typedef Byte FAR   *voidpf;
          388  +   typedef Byte       *voidp;
          389  +#endif
          390  +
          391  +/* ./configure may #define Z_U4 here */
          392  +
          393  +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
          394  +#  include <limits.h>
          395  +#  if (UINT_MAX == 0xffffffffUL)
          396  +#    define Z_U4 unsigned
          397  +#  else
          398  +#    if (ULONG_MAX == 0xffffffffUL)
          399  +#      define Z_U4 unsigned long
          400  +#    else
          401  +#      if (USHRT_MAX == 0xffffffffUL)
          402  +#        define Z_U4 unsigned short
          403  +#      endif
          404  +#    endif
          405  +#  endif
          406  +#endif
          407  +
          408  +#ifdef Z_U4
          409  +   typedef Z_U4 z_crc_t;
          410  +#else
          411  +   typedef unsigned long z_crc_t;
          412  +#endif
          413  +
          414  +#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
          415  +#  define Z_HAVE_UNISTD_H
          416  +#endif
          417  +
          418  +#if 1    /* was set to #if 1 by ./configure */
          419  +#  define Z_HAVE_STDARG_H
          420  +#endif
          421  +
          422  +#ifdef STDC
          423  +#  ifndef Z_SOLO
          424  +#    include <sys/types.h>      /* for off_t */
          425  +#  endif
          426  +#endif
          427  +
          428  +#ifdef _WIN32
          429  +#  include <stddef.h>           /* for wchar_t */
          430  +#endif
          431  +
          432  +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
          433  + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
          434  + * though the former does not conform to the LFS document), but considering
          435  + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
          436  + * equivalently requesting no 64-bit operations
          437  + */
          438  +#if defined(LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
          439  +#  undef _LARGEFILE64_SOURCE
          440  +#endif
          441  +
          442  +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
          443  +#  define Z_HAVE_UNISTD_H
          444  +#endif
          445  +#ifndef Z_SOLO
          446  +#  if defined(Z_HAVE_UNISTD_H) || defined(LARGEFILE64_SOURCE)
          447  +#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
          448  +#    ifdef VMS
          449  +#      include <unixio.h>       /* for off_t */
          450  +#    endif
          451  +#    ifndef z_off_t
          452  +#      define z_off_t off_t
          453  +#    endif
          454  +#  endif
          455  +#endif
          456  +
          457  +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
          458  +#  define Z_LFS64
          459  +#endif
          460  +
          461  +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
          462  +#  define Z_LARGE64
          463  +#endif
          464  +
          465  +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
          466  +#  define Z_WANT64
          467  +#endif
          468  +
          469  +#if !defined(SEEK_SET) && !defined(Z_SOLO)
          470  +#  define SEEK_SET        0       /* Seek from beginning of file.  */
          471  +#  define SEEK_CUR        1       /* Seek from current position.  */
          472  +#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
          473  +#endif
          474  +
          475  +#ifndef z_off_t
          476  +#  define z_off_t long
          477  +#endif
          478  +
          479  +#if !defined(_WIN32) && defined(Z_LARGE64)
          480  +#  define z_off64_t off64_t
          481  +#else
          482  +#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
          483  +#    define z_off64_t __int64
          484  +#  else
          485  +#    define z_off64_t z_off_t
          486  +#  endif
          487  +#endif
          488  +
          489  +/* MVS linker does not support external names larger than 8 bytes */
          490  +#if defined(__MVS__)
          491  +  #pragma map(deflateInit_,"DEIN")
          492  +  #pragma map(deflateInit2_,"DEIN2")
          493  +  #pragma map(deflateEnd,"DEEND")
          494  +  #pragma map(deflateBound,"DEBND")
          495  +  #pragma map(inflateInit_,"ININ")
          496  +  #pragma map(inflateInit2_,"ININ2")
          497  +  #pragma map(inflateEnd,"INEND")
          498  +  #pragma map(inflateSync,"INSY")
          499  +  #pragma map(inflateSetDictionary,"INSEDI")
          500  +  #pragma map(compressBound,"CMBND")
          501  +  #pragma map(inflate_table,"INTABL")
          502  +  #pragma map(inflate_fast,"INFA")
          503  +  #pragma map(inflate_copyright,"INCOPY")
          504  +#endif
          505  +
          506  +#endif /* ZCONF_H */

Added build/cackey_win64_build/include/zlib.h version [eacf75e16a].

            1  +/* zlib.h -- interface of the 'zlib' general purpose compression library
            2  +  version 1.2.7, May 2nd, 2012
            3  +
            4  +  Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler
            5  +
            6  +  This software is provided 'as-is', without any express or implied
            7  +  warranty.  In no event will the authors be held liable for any damages
            8  +  arising from the use of this software.
            9  +
           10  +  Permission is granted to anyone to use this software for any purpose,
           11  +  including commercial applications, and to alter it and redistribute it
           12  +  freely, subject to the following restrictions:
           13  +
           14  +  1. The origin of this software must not be misrepresented; you must not
           15  +     claim that you wrote the original software. If you use this software
           16  +     in a product, an acknowledgment in the product documentation would be
           17  +     appreciated but is not required.
           18  +  2. Altered source versions must be plainly marked as such, and must not be
           19  +     misrepresented as being the original software.
           20  +  3. This notice may not be removed or altered from any source distribution.
           21  +
           22  +  Jean-loup Gailly        Mark Adler
           23  +  jloup@gzip.org          madler@alumni.caltech.edu
           24  +
           25  +
           26  +  The data format used by the zlib library is described by RFCs (Request for
           27  +  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
           28  +  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
           29  +*/
           30  +
           31  +#ifndef ZLIB_H
           32  +#define ZLIB_H
           33  +
           34  +#include "zconf.h"
           35  +
           36  +#ifdef __cplusplus
           37  +extern "C" {
           38  +#endif
           39  +
           40  +#define ZLIB_VERSION "1.2.7"
           41  +#define ZLIB_VERNUM 0x1270
           42  +#define ZLIB_VER_MAJOR 1
           43  +#define ZLIB_VER_MINOR 2
           44  +#define ZLIB_VER_REVISION 7
           45  +#define ZLIB_VER_SUBREVISION 0
           46  +
           47  +/*
           48  +    The 'zlib' compression library provides in-memory compression and
           49  +  decompression functions, including integrity checks of the uncompressed data.
           50  +  This version of the library supports only one compression method (deflation)
           51  +  but other algorithms will be added later and will have the same stream
           52  +  interface.
           53  +
           54  +    Compression can be done in a single step if the buffers are large enough,
           55  +  or can be done by repeated calls of the compression function.  In the latter
           56  +  case, the application must provide more input and/or consume the output
           57  +  (providing more output space) before each call.
           58  +
           59  +    The compressed data format used by default by the in-memory functions is
           60  +  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
           61  +  around a deflate stream, which is itself documented in RFC 1951.
           62  +
           63  +    The library also supports reading and writing files in gzip (.gz) format
           64  +  with an interface similar to that of stdio using the functions that start
           65  +  with "gz".  The gzip format is different from the zlib format.  gzip is a
           66  +  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
           67  +
           68  +    This library can optionally read and write gzip streams in memory as well.
           69  +
           70  +    The zlib format was designed to be compact and fast for use in memory
           71  +  and on communications channels.  The gzip format was designed for single-
           72  +  file compression on file systems, has a larger header than zlib to maintain
           73  +  directory information, and uses a different, slower check method than zlib.
           74  +
           75  +    The library does not install any signal handler.  The decoder checks
           76  +  the consistency of the compressed data, so the library should never crash
           77  +  even in case of corrupted input.
           78  +*/
           79  +
           80  +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
           81  +typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
           82  +
           83  +struct internal_state;
           84  +
           85  +typedef struct z_stream_s {
           86  +    z_const Bytef *next_in;     /* next input byte */
           87  +    uInt     avail_in;  /* number of bytes available at next_in */
           88  +    uLong    total_in;  /* total number of input bytes read so far */
           89  +
           90  +    Bytef    *next_out; /* next output byte should be put there */
           91  +    uInt     avail_out; /* remaining free space at next_out */
           92  +    uLong    total_out; /* total number of bytes output so far */
           93  +
           94  +    z_const char *msg;  /* last error message, NULL if no error */
           95  +    struct internal_state FAR *state; /* not visible by applications */
           96  +
           97  +    alloc_func zalloc;  /* used to allocate the internal state */
           98  +    free_func  zfree;   /* used to free the internal state */
           99  +    voidpf     opaque;  /* private data object passed to zalloc and zfree */
          100  +
          101  +    int     data_type;  /* best guess about the data type: binary or text */
          102  +    uLong   adler;      /* adler32 value of the uncompressed data */
          103  +    uLong   reserved;   /* reserved for future use */
          104  +} z_stream;
          105  +
          106  +typedef z_stream FAR *z_streamp;
          107  +
          108  +/*
          109  +     gzip header information passed to and from zlib routines.  See RFC 1952
          110  +  for more details on the meanings of these fields.
          111  +*/
          112  +typedef struct gz_header_s {
          113  +    int     text;       /* true if compressed data believed to be text */
          114  +    uLong   time;       /* modification time */
          115  +    int     xflags;     /* extra flags (not used when writing a gzip file) */
          116  +    int     os;         /* operating system */
          117  +    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
          118  +    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
          119  +    uInt    extra_max;  /* space at extra (only when reading header) */
          120  +    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
          121  +    uInt    name_max;   /* space at name (only when reading header) */
          122  +    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
          123  +    uInt    comm_max;   /* space at comment (only when reading header) */
          124  +    int     hcrc;       /* true if there was or will be a header crc */
          125  +    int     done;       /* true when done reading gzip header (not used
          126  +                           when writing a gzip file) */
          127  +} gz_header;
          128  +
          129  +typedef gz_header FAR *gz_headerp;
          130  +
          131  +/*
          132  +     The application must update next_in and avail_in when avail_in has dropped
          133  +   to zero.  It must update next_out and avail_out when avail_out has dropped
          134  +   to zero.  The application must initialize zalloc, zfree and opaque before
          135  +   calling the init function.  All other fields are set by the compression
          136  +   library and must not be updated by the application.
          137  +
          138  +     The opaque value provided by the application will be passed as the first
          139  +   parameter for calls of zalloc and zfree.  This can be useful for custom
          140  +   memory management.  The compression library attaches no meaning to the
          141  +   opaque value.
          142  +
          143  +     zalloc must return Z_NULL if there is not enough memory for the object.
          144  +   If zlib is used in a multi-threaded application, zalloc and zfree must be
          145  +   thread safe.
          146  +
          147  +     On 16-bit systems, the functions zalloc and zfree must be able to allocate
          148  +   exactly 65536 bytes, but will not be required to allocate more than this if
          149  +   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
          150  +   returned by zalloc for objects of exactly 65536 bytes *must* have their
          151  +   offset normalized to zero.  The default allocation function provided by this
          152  +   library ensures this (see zutil.c).  To reduce memory requirements and avoid
          153  +   any allocation of 64K objects, at the expense of compression ratio, compile
          154  +   the library with -DMAX_WBITS=14 (see zconf.h).
          155  +
          156  +     The fields total_in and total_out can be used for statistics or progress
          157  +   reports.  After compression, total_in holds the total size of the
          158  +   uncompressed data and may be saved for use in the decompressor (particularly
          159  +   if the decompressor wants to decompress everything in a single step).
          160  +*/
          161  +
          162  +                        /* constants */
          163  +
          164  +#define Z_NO_FLUSH      0
          165  +#define Z_PARTIAL_FLUSH 1
          166  +#define Z_SYNC_FLUSH    2
          167  +#define Z_FULL_FLUSH    3
          168  +#define Z_FINISH        4
          169  +#define Z_BLOCK         5
          170  +#define Z_TREES         6
          171  +/* Allowed flush values; see deflate() and inflate() below for details */
          172  +
          173  +#define Z_OK            0
          174  +#define Z_STREAM_END    1
          175  +#define Z_NEED_DICT     2
          176  +#define Z_ERRNO        (-1)
          177  +#define Z_STREAM_ERROR (-2)
          178  +#define Z_DATA_ERROR   (-3)
          179  +#define Z_MEM_ERROR    (-4)
          180  +#define Z_BUF_ERROR    (-5)
          181  +#define Z_VERSION_ERROR (-6)
          182  +/* Return codes for the compression/decompression functions. Negative values
          183  + * are errors, positive values are used for special but normal events.
          184  + */
          185  +
          186  +#define Z_NO_COMPRESSION         0
          187  +#define Z_BEST_SPEED             1
          188  +#define Z_BEST_COMPRESSION       9
          189  +#define Z_DEFAULT_COMPRESSION  (-1)
          190  +/* compression levels */
          191  +
          192  +#define Z_FILTERED            1
          193  +#define Z_HUFFMAN_ONLY        2
          194  +#define Z_RLE                 3
          195  +#define Z_FIXED               4
          196  +#define Z_DEFAULT_STRATEGY    0
          197  +/* compression strategy; see deflateInit2() below for details */
          198  +
          199  +#define Z_BINARY   0
          200  +#define Z_TEXT     1
          201  +#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
          202  +#define Z_UNKNOWN  2
          203  +/* Possible values of the data_type field (though see inflate()) */
          204  +
          205  +#define Z_DEFLATED   8
          206  +/* The deflate compression method (the only one supported in this version) */
          207  +
          208  +#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
          209  +
          210  +#define zlib_version zlibVersion()
          211  +/* for compatibility with versions < 1.0.2 */
          212  +
          213  +
          214  +                        /* basic functions */
          215  +
          216  +ZEXTERN const char * ZEXPORT zlibVersion OF((void));
          217  +/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
          218  +   If the first character differs, the library code actually used is not
          219  +   compatible with the zlib.h header file used by the application.  This check
          220  +   is automatically made by deflateInit and inflateInit.
          221  + */
          222  +
          223  +/*
          224  +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
          225  +
          226  +     Initializes the internal stream state for compression.  The fields
          227  +   zalloc, zfree and opaque must be initialized before by the caller.  If
          228  +   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
          229  +   allocation functions.
          230  +
          231  +     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
          232  +   1 gives best speed, 9 gives best compression, 0 gives no compression at all
          233  +   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
          234  +   requests a default compromise between speed and compression (currently
          235  +   equivalent to level 6).
          236  +
          237  +     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
          238  +   memory, Z_STREAM_ERROR if level is not a valid compression level, or
          239  +   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
          240  +   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
          241  +   if there is no error message.  deflateInit does not perform any compression:
          242  +   this will be done by deflate().
          243  +*/
          244  +
          245  +
          246  +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
          247  +/*
          248  +    deflate compresses as much data as possible, and stops when the input
          249  +  buffer becomes empty or the output buffer becomes full.  It may introduce
          250  +  some output latency (reading input without producing any output) except when
          251  +  forced to flush.
          252  +
          253  +    The detailed semantics are as follows.  deflate performs one or both of the
          254  +  following actions:
          255  +
          256  +  - Compress more input starting at next_in and update next_in and avail_in
          257  +    accordingly.  If not all input can be processed (because there is not
          258  +    enough room in the output buffer), next_in and avail_in are updated and
          259  +    processing will resume at this point for the next call of deflate().
          260  +
          261  +  - Provide more output starting at next_out and update next_out and avail_out
          262  +    accordingly.  This action is forced if the parameter flush is non zero.
          263  +    Forcing flush frequently degrades the compression ratio, so this parameter
          264  +    should be set only when necessary (in interactive applications).  Some
          265  +    output may be provided even if flush is not set.
          266  +
          267  +    Before the call of deflate(), the application should ensure that at least
          268  +  one of the actions is possible, by providing more input and/or consuming more
          269  +  output, and updating avail_in or avail_out accordingly; avail_out should
          270  +  never be zero before the call.  The application can consume the compressed
          271  +  output when it wants, for example when the output buffer is full (avail_out
          272  +  == 0), or after each call of deflate().  If deflate returns Z_OK and with
          273  +  zero avail_out, it must be called again after making room in the output
          274  +  buffer because there might be more output pending.
          275  +
          276  +    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
          277  +  decide how much data to accumulate before producing output, in order to
          278  +  maximize compression.
          279  +
          280  +    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
          281  +  flushed to the output buffer and the output is aligned on a byte boundary, so
          282  +  that the decompressor can get all input data available so far.  (In
          283  +  particular avail_in is zero after the call if enough output space has been
          284  +  provided before the call.) Flushing may degrade compression for some
          285  +  compression algorithms and so it should be used only when necessary.  This
          286  +  completes the current deflate block and follows it with an empty stored block
          287  +  that is three bits plus filler bits to the next byte, followed by four bytes
          288  +  (00 00 ff ff).
          289  +
          290  +    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
          291  +  output buffer, but the output is not aligned to a byte boundary.  All of the
          292  +  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
          293  +  This completes the current deflate block and follows it with an empty fixed
          294  +  codes block that is 10 bits long.  This assures that enough bytes are output
          295  +  in order for the decompressor to finish the block before the empty fixed code
          296  +  block.
          297  +
          298  +    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
          299  +  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
          300  +  seven bits of the current block are held to be written as the next byte after
          301  +  the next deflate block is completed.  In this case, the decompressor may not
          302  +  be provided enough bits at this point in order to complete decompression of
          303  +  the data provided so far to the compressor.  It may need to wait for the next
          304  +  block to be emitted.  This is for advanced applications that need to control
          305  +  the emission of deflate blocks.
          306  +
          307  +    If flush is set to Z_FULL_FLUSH, all output is flushed as with
          308  +  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
          309  +  restart from this point if previous compressed data has been damaged or if
          310  +  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
          311  +  compression.
          312  +
          313  +    If deflate returns with avail_out == 0, this function must be called again
          314  +  with the same value of the flush parameter and more output space (updated
          315  +  avail_out), until the flush is complete (deflate returns with non-zero
          316  +  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
          317  +  avail_out is greater than six to avoid repeated flush markers due to
          318  +  avail_out == 0 on return.
          319  +
          320  +    If the parameter flush is set to Z_FINISH, pending input is processed,
          321  +  pending output is flushed and deflate returns with Z_STREAM_END if there was
          322  +  enough output space; if deflate returns with Z_OK, this function must be
          323  +  called again with Z_FINISH and more output space (updated avail_out) but no
          324  +  more input data, until it returns with Z_STREAM_END or an error.  After
          325  +  deflate has returned Z_STREAM_END, the only possible operations on the stream
          326  +  are deflateReset or deflateEnd.
          327  +
          328  +    Z_FINISH can be used immediately after deflateInit if all the compression
          329  +  is to be done in a single step.  In this case, avail_out must be at least the
          330  +  value returned by deflateBound (see below).  Then deflate is guaranteed to
          331  +  return Z_STREAM_END.  If not enough output space is provided, deflate will
          332  +  not return Z_STREAM_END, and it must be called again as described above.
          333  +
          334  +    deflate() sets strm->adler to the adler32 checksum of all input read
          335  +  so far (that is, total_in bytes).
          336  +
          337  +    deflate() may update strm->data_type if it can make a good guess about
          338  +  the input data type (Z_BINARY or Z_TEXT).  In doubt, the data is considered
          339  +  binary.  This field is only for information purposes and does not affect the
          340  +  compression algorithm in any manner.
          341  +
          342  +    deflate() returns Z_OK if some progress has been made (more input
          343  +  processed or more output produced), Z_STREAM_END if all input has been
          344  +  consumed and all output has been produced (only when flush is set to
          345  +  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
          346  +  if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
          347  +  (for example avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not
          348  +  fatal, and deflate() can be called again with more input and more output
          349  +  space to continue compressing.
          350  +*/
          351  +
          352  +
          353  +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
          354  +/*
          355  +     All dynamically allocated data structures for this stream are freed.
          356  +   This function discards any unprocessed input and does not flush any pending
          357  +   output.
          358  +
          359  +     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
          360  +   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
          361  +   prematurely (some input or output was discarded).  In the error case, msg
          362  +   may be set but then points to a static string (which must not be
          363  +   deallocated).
          364  +*/
          365  +
          366  +
          367  +/*
          368  +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
          369  +
          370  +     Initializes the internal stream state for decompression.  The fields
          371  +   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
          372  +   the caller.  If next_in is not Z_NULL and avail_in is large enough (the
          373  +   exact value depends on the compression method), inflateInit determines the
          374  +   compression method from the zlib header and allocates all data structures
          375  +   accordingly; otherwise the allocation will be deferred to the first call of
          376  +   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
          377  +   use default allocation functions.
          378  +
          379  +     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
          380  +   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
          381  +   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
          382  +   invalid, such as a null pointer to the structure.  msg is set to null if
          383  +   there is no error message.  inflateInit does not perform any decompression
          384  +   apart from possibly reading the zlib header if present: actual decompression
          385  +   will be done by inflate().  (So next_in and avail_in may be modified, but
          386  +   next_out and avail_out are unused and unchanged.) The current implementation
          387  +   of inflateInit() does not process any header information -- that is deferred
          388  +   until inflate() is called.
          389  +*/
          390  +
          391  +
          392  +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
          393  +/*
          394  +    inflate decompresses as much data as possible, and stops when the input
          395  +  buffer becomes empty or the output buffer becomes full.  It may introduce
          396  +  some output latency (reading input without producing any output) except when
          397  +  forced to flush.
          398  +
          399  +  The detailed semantics are as follows.  inflate performs one or both of the
          400  +  following actions:
          401  +
          402  +  - Decompress more input starting at next_in and update next_in and avail_in
          403  +    accordingly.  If not all input can be processed (because there is not
          404  +    enough room in the output buffer), next_in is updated and processing will
          405  +    resume at this point for the next call of inflate().
          406  +
          407  +  - Provide more output starting at next_out and update next_out and avail_out
          408  +    accordingly.  inflate() provides as much output as possible, until there is
          409  +    no more input data or no more space in the output buffer (see below about
          410  +    the flush parameter).
          411  +
          412  +    Before the call of inflate(), the application should ensure that at least
          413  +  one of the actions is possible, by providing more input and/or consuming more
          414  +  output, and updating the next_* and avail_* values accordingly.  The
          415  +  application can consume the uncompressed output when it wants, for example
          416  +  when the output buffer is full (avail_out == 0), or after each call of
          417  +  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
          418  +  called again after making room in the output buffer because there might be
          419  +  more output pending.
          420  +
          421  +    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
          422  +  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
          423  +  output as possible to the output buffer.  Z_BLOCK requests that inflate()
          424  +  stop if and when it gets to the next deflate block boundary.  When decoding
          425  +  the zlib or gzip format, this will cause inflate() to return immediately
          426  +  after the header and before the first block.  When doing a raw inflate,
          427  +  inflate() will go ahead and process the first block, and will return when it
          428  +  gets to the end of that block, or when it runs out of data.
          429  +
          430  +    The Z_BLOCK option assists in appending to or combining deflate streams.
          431  +  Also to assist in this, on return inflate() will set strm->data_type to the
          432  +  number of unused bits in the last byte taken from strm->next_in, plus 64 if
          433  +  inflate() is currently decoding the last block in the deflate stream, plus
          434  +  128 if inflate() returned immediately after decoding an end-of-block code or
          435  +  decoding the complete header up to just before the first byte of the deflate
          436  +  stream.  The end-of-block will not be indicated until all of the uncompressed
          437  +  data from that block has been written to strm->next_out.  The number of
          438  +  unused bits may in general be greater than seven, except when bit 7 of
          439  +  data_type is set, in which case the number of unused bits will be less than
          440  +  eight.  data_type is set as noted here every time inflate() returns for all
          441  +  flush options, and so can be used to determine the amount of currently
          442  +  consumed input in bits.
          443  +
          444  +    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
          445  +  end of each deflate block header is reached, before any actual data in that
          446  +  block is decoded.  This allows the caller to determine the length of the
          447  +  deflate block header for later use in random access within a deflate block.
          448  +  256 is added to the value of strm->data_type when inflate() returns
          449  +  immediately after reaching the end of the deflate block header.
          450  +
          451  +    inflate() should normally be called until it returns Z_STREAM_END or an
          452  +  error.  However if all decompression is to be performed in a single step (a
          453  +  single call of inflate), the parameter flush should be set to Z_FINISH.  In
          454  +  this case all pending input is processed and all pending output is flushed;
          455  +  avail_out must be large enough to hold all of the uncompressed data for the
          456  +  operation to complete.  (The size of the uncompressed data may have been
          457  +  saved by the compressor for this purpose.) The use of Z_FINISH is not
          458  +  required to perform an inflation in one step.  However it may be used to
          459  +  inform inflate that a faster approach can be used for the single inflate()
          460  +  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
          461  +  stream completes, which reduces inflate's memory footprint.  If the stream
          462  +  does not complete, either because not all of the stream is provided or not
          463  +  enough output space is provided, then a sliding window will be allocated and
          464  +  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
          465  +  been used.
          466  +
          467  +     In this implementation, inflate() always flushes as much output as
          468  +  possible to the output buffer, and always uses the faster approach on the
          469  +  first call.  So the effects of the flush parameter in this implementation are
          470  +  on the return value of inflate() as noted below, when inflate() returns early
          471  +  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
          472  +  memory for a sliding window when Z_FINISH is used.
          473  +
          474  +     If a preset dictionary is needed after this call (see inflateSetDictionary
          475  +  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
          476  +  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
          477  +  strm->adler to the Adler-32 checksum of all output produced so far (that is,
          478  +  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
          479  +  below.  At the end of the stream, inflate() checks that its computed adler32
          480  +  checksum is equal to that saved by the compressor and returns Z_STREAM_END
          481  +  only if the checksum is correct.
          482  +
          483  +    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
          484  +  deflate data.  The header type is detected automatically, if requested when
          485  +  initializing with inflateInit2().  Any information contained in the gzip
          486  +  header is not retained, so applications that need that information should
          487  +  instead use raw inflate, see inflateInit2() below, or inflateBack() and
          488  +  perform their own processing of the gzip header and trailer.  When processing
          489  +  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
          490  +  producted so far.  The CRC-32 is checked against the gzip trailer.
          491  +
          492  +    inflate() returns Z_OK if some progress has been made (more input processed
          493  +  or more output produced), Z_STREAM_END if the end of the compressed data has
          494  +  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
          495  +  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
          496  +  corrupted (input stream not conforming to the zlib format or incorrect check
          497  +  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
          498  +  next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
          499  +  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
          500  +  output buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
          501  +  inflate() can be called again with more input and more output space to
          502  +  continue decompressing.  If Z_DATA_ERROR is returned, the application may
          503  +  then call inflateSync() to look for a good compression block if a partial
          504  +  recovery of the data is desired.
          505  +*/
          506  +
          507  +
          508  +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
          509  +/*
          510  +     All dynamically allocated data structures for this stream are freed.
          511  +   This function discards any unprocessed input and does not flush any pending
          512  +   output.
          513  +
          514  +     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
          515  +   was inconsistent.  In the error case, msg may be set but then points to a
          516  +   static string (which must not be deallocated).
          517  +*/
          518  +
          519  +
          520  +                        /* Advanced functions */
          521  +
          522  +/*
          523  +    The following functions are needed only in some special applications.
          524  +*/
          525  +
          526  +/*
          527  +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
          528  +                                     int  level,
          529  +                                     int  method,
          530  +                                     int  windowBits,
          531  +                                     int  memLevel,
          532  +                                     int  strategy));
          533  +
          534  +     This is another version of deflateInit with more compression options.  The
          535  +   fields next_in, zalloc, zfree and opaque must be initialized before by the
          536  +   caller.
          537  +
          538  +     The method parameter is the compression method.  It must be Z_DEFLATED in
          539  +   this version of the library.
          540  +
          541  +     The windowBits parameter is the base two logarithm of the window size
          542  +   (the size of the history buffer).  It should be in the range 8..15 for this
          543  +   version of the library.  Larger values of this parameter result in better
          544  +   compression at the expense of memory usage.  The default value is 15 if
          545  +   deflateInit is used instead.
          546  +
          547  +     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
          548  +   determines the window size.  deflate() will then generate raw deflate data
          549  +   with no zlib header or trailer, and will not compute an adler32 check value.
          550  +
          551  +     windowBits can also be greater than 15 for optional gzip encoding.  Add
          552  +   16 to windowBits to write a simple gzip header and trailer around the
          553  +   compressed data instead of a zlib wrapper.  The gzip header will have no
          554  +   file name, no extra data, no comment, no modification time (set to zero), no
          555  +   header crc, and the operating system will be set to 255 (unknown).  If a
          556  +   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
          557  +
          558  +     The memLevel parameter specifies how much memory should be allocated
          559  +   for the internal compression state.  memLevel=1 uses minimum memory but is
          560  +   slow and reduces compression ratio; memLevel=9 uses maximum memory for
          561  +   optimal speed.  The default value is 8.  See zconf.h for total memory usage
          562  +   as a function of windowBits and memLevel.
          563  +
          564  +     The strategy parameter is used to tune the compression algorithm.  Use the
          565  +   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
          566  +   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
          567  +   string match), or Z_RLE to limit match distances to one (run-length
          568  +   encoding).  Filtered data consists mostly of small values with a somewhat
          569  +   random distribution.  In this case, the compression algorithm is tuned to
          570  +   compress them better.  The effect of Z_FILTERED is to force more Huffman
          571  +   coding and less string matching; it is somewhat intermediate between
          572  +   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
          573  +   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
          574  +   strategy parameter only affects the compression ratio but not the
          575  +   correctness of the compressed output even if it is not set appropriately.
          576  +   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
          577  +   decoder for special applications.
          578  +
          579  +     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
          580  +   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
          581  +   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
          582  +   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
          583  +   set to null if there is no error message.  deflateInit2 does not perform any
          584  +   compression: this will be done by deflate().
          585  +*/
          586  +
          587  +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
          588  +                                             const Bytef *dictionary,
          589  +                                             uInt  dictLength));
          590  +/*
          591  +     Initializes the compression dictionary from the given byte sequence
          592  +   without producing any compressed output.  When using the zlib format, this
          593  +   function must be called immediately after deflateInit, deflateInit2 or
          594  +   deflateReset, and before any call of deflate.  When doing raw deflate, this
          595  +   function must be called either before any call of deflate, or immediately
          596  +   after the completion of a deflate block, i.e. after all input has been
          597  +   consumed and all output has been delivered when using any of the flush
          598  +   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
          599  +   compressor and decompressor must use exactly the same dictionary (see
          600  +   inflateSetDictionary).
          601  +
          602  +     The dictionary should consist of strings (byte sequences) that are likely
          603  +   to be encountered later in the data to be compressed, with the most commonly
          604  +   used strings preferably put towards the end of the dictionary.  Using a
          605  +   dictionary is most useful when the data to be compressed is short and can be
          606  +   predicted with good accuracy; the data can then be compressed better than
          607  +   with the default empty dictionary.
          608  +
          609  +     Depending on the size of the compression data structures selected by
          610  +   deflateInit or deflateInit2, a part of the dictionary may in effect be
          611  +   discarded, for example if the dictionary is larger than the window size
          612  +   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
          613  +   useful should be put at the end of the dictionary, not at the front.  In
          614  +   addition, the current implementation of deflate will use at most the window
          615  +   size minus 262 bytes of the provided dictionary.
          616  +
          617  +     Upon return of this function, strm->adler is set to the adler32 value
          618  +   of the dictionary; the decompressor may later use this value to determine
          619  +   which dictionary has been used by the compressor.  (The adler32 value
          620  +   applies to the whole dictionary even if only a subset of the dictionary is
          621  +   actually used by the compressor.) If a raw deflate was requested, then the
          622  +   adler32 value is not computed and strm->adler is not set.
          623  +
          624  +     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
          625  +   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
          626  +   inconsistent (for example if deflate has already been called for this stream
          627  +   or if not at a block boundary for raw deflate).  deflateSetDictionary does
          628  +   not perform any compression: this will be done by deflate().
          629  +*/
          630  +
          631  +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
          632  +                                    z_streamp source));
          633  +/*
          634  +     Sets the destination stream as a complete copy of the source stream.
          635  +
          636  +     This function can be useful when several compression strategies will be
          637  +   tried, for example when there are several ways of pre-processing the input
          638  +   data with a filter.  The streams that will be discarded should then be freed
          639  +   by calling deflateEnd.  Note that deflateCopy duplicates the internal
          640  +   compression state which can be quite large, so this strategy is slow and can
          641  +   consume lots of memory.
          642  +
          643  +     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
          644  +   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
          645  +   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
          646  +   destination.
          647  +*/
          648  +
          649  +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
          650  +/*
          651  +     This function is equivalent to deflateEnd followed by deflateInit,
          652  +   but does not free and reallocate all the internal compression state.  The
          653  +   stream will keep the same compression level and any other attributes that
          654  +   may have been set by deflateInit2.
          655  +
          656  +     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
          657  +   stream state was inconsistent (such as zalloc or state being Z_NULL).
          658  +*/
          659  +
          660  +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
          661  +                                      int level,
          662  +                                      int strategy));
          663  +/*
          664  +     Dynamically update the compression level and compression strategy.  The
          665  +   interpretation of level and strategy is as in deflateInit2.  This can be
          666  +   used to switch between compression and straight copy of the input data, or
          667  +   to switch to a different kind of input data requiring a different strategy.
          668  +   If the compression level is changed, the input available so far is
          669  +   compressed with the old level (and may be flushed); the new level will take
          670  +   effect only at the next call of deflate().
          671  +
          672  +     Before the call of deflateParams, the stream state must be set as for
          673  +   a call of deflate(), since the currently available input may have to be
          674  +   compressed and flushed.  In particular, strm->avail_out must be non-zero.
          675  +
          676  +     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
          677  +   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
          678  +   strm->avail_out was zero.
          679  +*/
          680  +
          681  +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
          682  +                                    int good_length,
          683  +                                    int max_lazy,
          684  +                                    int nice_length,
          685  +                                    int max_chain));
          686  +/*
          687  +     Fine tune deflate's internal compression parameters.  This should only be
          688  +   used by someone who understands the algorithm used by zlib's deflate for
          689  +   searching for the best matching string, and even then only by the most
          690  +   fanatic optimizer trying to squeeze out the last compressed bit for their
          691  +   specific input data.  Read the deflate.c source code for the meaning of the
          692  +   max_lazy, good_length, nice_length, and max_chain parameters.
          693  +
          694  +     deflateTune() can be called after deflateInit() or deflateInit2(), and
          695  +   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
          696  + */
          697  +
          698  +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
          699  +                                       uLong sourceLen));
          700  +/*
          701  +     deflateBound() returns an upper bound on the compressed size after
          702  +   deflation of sourceLen bytes.  It must be called after deflateInit() or
          703  +   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
          704  +   to allocate an output buffer for deflation in a single pass, and so would be
          705  +   called before deflate().  If that first deflate() call is provided the
          706  +   sourceLen input bytes, an output buffer allocated to the size returned by
          707  +   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
          708  +   to return Z_STREAM_END.  Note that it is possible for the compressed size to
          709  +   be larger than the value returned by deflateBound() if flush options other
          710  +   than Z_FINISH or Z_NO_FLUSH are used.
          711  +*/
          712  +
          713  +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
          714  +                                       unsigned *pending,
          715  +                                       int *bits));
          716  +/*
          717  +     deflatePending() returns the number of bytes and bits of output that have
          718  +   been generated, but not yet provided in the available output.  The bytes not
          719  +   provided would be due to the available output space having being consumed.
          720  +   The number of bits of output not provided are between 0 and 7, where they
          721  +   await more bits to join them in order to fill out a full byte.  If pending
          722  +   or bits are Z_NULL, then those values are not set.
          723  +
          724  +     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
          725  +   stream state was inconsistent.
          726  + */
          727  +
          728  +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
          729  +                                     int bits,
          730  +                                     int value));
          731  +/*
          732  +     deflatePrime() inserts bits in the deflate output stream.  The intent
          733  +   is that this function is used to start off the deflate output with the bits
          734  +   leftover from a previous deflate stream when appending to it.  As such, this
          735  +   function can only be used for raw deflate, and must be used before the first
          736  +   deflate() call after a deflateInit2() or deflateReset().  bits must be less
          737  +   than or equal to 16, and that many of the least significant bits of value
          738  +   will be inserted in the output.
          739  +
          740  +     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
          741  +   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
          742  +   source stream state was inconsistent.
          743  +*/
          744  +
          745  +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
          746  +                                         gz_headerp head));
          747  +/*
          748  +     deflateSetHeader() provides gzip header information for when a gzip
          749  +   stream is requested by deflateInit2().  deflateSetHeader() may be called
          750  +   after deflateInit2() or deflateReset() and before the first call of
          751  +   deflate().  The text, time, os, extra field, name, and comment information
          752  +   in the provided gz_header structure are written to the gzip header (xflag is
          753  +   ignored -- the extra flags are set according to the compression level).  The
          754  +   caller must assure that, if not Z_NULL, name and comment are terminated with
          755  +   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
          756  +   available there.  If hcrc is true, a gzip header crc is included.  Note that
          757  +   the current versions of the command-line version of gzip (up through version
          758  +   1.3.x) do not support header crc's, and will report that it is a "multi-part
          759  +   gzip file" and give up.
          760  +
          761  +     If deflateSetHeader is not used, the default gzip header has text false,
          762  +   the time set to zero, and os set to 255, with no extra, name, or comment
          763  +   fields.  The gzip header is returned to the default state by deflateReset().
          764  +
          765  +     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
          766  +   stream state was inconsistent.
          767  +*/
          768  +
          769  +/*
          770  +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
          771  +                                     int  windowBits));
          772  +
          773  +     This is another version of inflateInit with an extra parameter.  The
          774  +   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
          775  +   before by the caller.
          776  +
          777  +     The windowBits parameter is the base two logarithm of the maximum window
          778  +   size (the size of the history buffer).  It should be in the range 8..15 for
          779  +   this version of the library.  The default value is 15 if inflateInit is used
          780  +   instead.  windowBits must be greater than or equal to the windowBits value
          781  +   provided to deflateInit2() while compressing, or it must be equal to 15 if
          782  +   deflateInit2() was not used.  If a compressed stream with a larger window
          783  +   size is given as input, inflate() will return with the error code
          784  +   Z_DATA_ERROR instead of trying to allocate a larger window.
          785  +
          786  +     windowBits can also be zero to request that inflate use the window size in
          787  +   the zlib header of the compressed stream.
          788  +
          789  +     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
          790  +   determines the window size.  inflate() will then process raw deflate data,
          791  +   not looking for a zlib or gzip header, not generating a check value, and not
          792  +   looking for any check values for comparison at the end of the stream.  This
          793  +   is for use with other formats that use the deflate compressed data format
          794  +   such as zip.  Those formats provide their own check values.  If a custom
          795  +   format is developed using the raw deflate format for compressed data, it is
          796  +   recommended that a check value such as an adler32 or a crc32 be applied to
          797  +   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
          798  +   most applications, the zlib format should be used as is.  Note that comments
          799  +   above on the use in deflateInit2() applies to the magnitude of windowBits.
          800  +
          801  +     windowBits can also be greater than 15 for optional gzip decoding.  Add
          802  +   32 to windowBits to enable zlib and gzip decoding with automatic header
          803  +   detection, or add 16 to decode only the gzip format (the zlib format will
          804  +   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
          805  +   crc32 instead of an adler32.
          806  +
          807  +     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
          808  +   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
          809  +   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
          810  +   invalid, such as a null pointer to the structure.  msg is set to null if
          811  +   there is no error message.  inflateInit2 does not perform any decompression
          812  +   apart from possibly reading the zlib header if present: actual decompression
          813  +   will be done by inflate().  (So next_in and avail_in may be modified, but
          814  +   next_out and avail_out are unused and unchanged.) The current implementation
          815  +   of inflateInit2() does not process any header information -- that is
          816  +   deferred until inflate() is called.
          817  +*/
          818  +
          819  +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
          820  +                                             const Bytef *dictionary,
          821  +                                             uInt  dictLength));
          822  +/*
          823  +     Initializes the decompression dictionary from the given uncompressed byte
          824  +   sequence.  This function must be called immediately after a call of inflate,
          825  +   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
          826  +   can be determined from the adler32 value returned by that call of inflate.
          827  +   The compressor and decompressor must use exactly the same dictionary (see
          828  +   deflateSetDictionary).  For raw inflate, this function can be called at any
          829  +   time to set the dictionary.  If the provided dictionary is smaller than the
          830  +   window and there is already data in the window, then the provided dictionary
          831  +   will amend what's there.  The application must insure that the dictionary
          832  +   that was used for compression is provided.
          833  +
          834  +     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
          835  +   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
          836  +   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
          837  +   expected one (incorrect adler32 value).  inflateSetDictionary does not
          838  +   perform any decompression: this will be done by subsequent calls of
          839  +   inflate().
          840  +*/
          841  +
          842  +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
          843  +/*
          844  +     Skips invalid compressed data until a possible full flush point (see above
          845  +   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
          846  +   available input is skipped.  No output is provided.
          847  +
          848  +     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
          849  +   All full flush points have this pattern, but not all occurences of this
          850  +   pattern are full flush points.
          851  +
          852  +     inflateSync returns Z_OK if a possible full flush point has been found,
          853  +   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
          854  +   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
          855  +   In the success case, the application may save the current current value of
          856  +   total_in which indicates where valid compressed data was found.  In the
          857  +   error case, the application may repeatedly call inflateSync, providing more
          858  +   input each time, until success or end of the input data.
          859  +*/
          860  +
          861  +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
          862  +                                    z_streamp source));
          863  +/*
          864  +     Sets the destination stream as a complete copy of the source stream.
          865  +
          866  +     This function can be useful when randomly accessing a large stream.  The
          867  +   first pass through the stream can periodically record the inflate state,
          868  +   allowing restarting inflate at those points when randomly accessing the
          869  +   stream.
          870  +
          871  +     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
          872  +   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
          873  +   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
          874  +   destination.
          875  +*/
          876  +
          877  +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
          878  +/*
          879  +     This function is equivalent to inflateEnd followed by inflateInit,
          880  +   but does not free and reallocate all the internal decompression state.  The
          881  +   stream will keep attributes that may have been set by inflateInit2.
          882  +
          883  +     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
          884  +   stream state was inconsistent (such as zalloc or state being Z_NULL).
          885  +*/
          886  +
          887  +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
          888  +                                      int windowBits));
          889  +/*
          890  +     This function is the same as inflateReset, but it also permits changing
          891  +   the wrap and window size requests.  The windowBits parameter is interpreted
          892  +   the same as it is for inflateInit2.
          893  +
          894  +     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
          895  +   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
          896  +   the windowBits parameter is invalid.
          897  +*/
          898  +
          899  +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
          900  +                                     int bits,
          901  +                                     int value));
          902  +/*
          903  +     This function inserts bits in the inflate input stream.  The intent is
          904  +   that this function is used to start inflating at a bit position in the
          905  +   middle of a byte.  The provided bits will be used before any bytes are used
          906  +   from next_in.  This function should only be used with raw inflate, and
          907  +   should be used before the first inflate() call after inflateInit2() or
          908  +   inflateReset().  bits must be less than or equal to 16, and that many of the
          909  +   least significant bits of value will be inserted in the input.
          910  +
          911  +     If bits is negative, then the input stream bit buffer is emptied.  Then
          912  +   inflatePrime() can be called again to put bits in the buffer.  This is used
          913  +   to clear out bits leftover after feeding inflate a block description prior
          914  +   to feeding inflate codes.
          915  +
          916  +     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
          917  +   stream state was inconsistent.
          918  +*/
          919  +
          920  +ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
          921  +/*
          922  +     This function returns two values, one in the lower 16 bits of the return
          923  +   value, and the other in the remaining upper bits, obtained by shifting the
          924  +   return value down 16 bits.  If the upper value is -1 and the lower value is
          925  +   zero, then inflate() is currently decoding information outside of a block.
          926  +   If the upper value is -1 and the lower value is non-zero, then inflate is in
          927  +   the middle of a stored block, with the lower value equaling the number of
          928  +   bytes from the input remaining to copy.  If the upper value is not -1, then
          929  +   it is the number of bits back from the current bit position in the input of
          930  +   the code (literal or length/distance pair) currently being processed.  In
          931  +   that case the lower value is the number of bytes already emitted for that
          932  +   code.
          933  +
          934  +     A code is being processed if inflate is waiting for more input to complete
          935  +   decoding of the code, or if it has completed decoding but is waiting for
          936  +   more output space to write the literal or match data.
          937  +
          938  +     inflateMark() is used to mark locations in the input data for random
          939  +   access, which may be at bit positions, and to note those cases where the
          940  +   output of a code may span boundaries of random access blocks.  The current
          941  +   location in the input stream can be determined from avail_in and data_type
          942  +   as noted in the description for the Z_BLOCK flush parameter for inflate.
          943  +
          944  +     inflateMark returns the value noted above or -1 << 16 if the provided
          945  +   source stream state was inconsistent.
          946  +*/
          947  +
          948  +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
          949  +                                         gz_headerp head));
          950  +/*
          951  +     inflateGetHeader() requests that gzip header information be stored in the
          952  +   provided gz_header structure.  inflateGetHeader() may be called after
          953  +   inflateInit2() or inflateReset(), and before the first call of inflate().
          954  +   As inflate() processes the gzip stream, head->done is zero until the header
          955  +   is completed, at which time head->done is set to one.  If a zlib stream is
          956  +   being decoded, then head->done is set to -1 to indicate that there will be
          957  +   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
          958  +   used to force inflate() to return immediately after header processing is
          959  +   complete and before any actual data is decompressed.
          960  +
          961  +     The text, time, xflags, and os fields are filled in with the gzip header
          962  +   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
          963  +   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
          964  +   contains the maximum number of bytes to write to extra.  Once done is true,
          965  +   extra_len contains the actual extra field length, and extra contains the
          966  +   extra field, or that field truncated if extra_max is less than extra_len.
          967  +   If name is not Z_NULL, then up to name_max characters are written there,
          968  +   terminated with a zero unless the length is greater than name_max.  If
          969  +   comment is not Z_NULL, then up to comm_max characters are written there,
          970  +   terminated with a zero unless the length is greater than comm_max.  When any
          971  +   of extra, name, or comment are not Z_NULL and the respective field is not
          972  +   present in the header, then that field is set to Z_NULL to signal its
          973  +   absence.  This allows the use of deflateSetHeader() with the returned
          974  +   structure to duplicate the header.  However if those fields are set to
          975  +   allocated memory, then the application will need to save those pointers
          976  +   elsewhere so that they can be eventually freed.
          977  +
          978  +     If inflateGetHeader is not used, then the header information is simply
          979  +   discarded.  The header is always checked for validity, including the header
          980  +   CRC if present.  inflateReset() will reset the process to discard the header
          981  +   information.  The application would need to call inflateGetHeader() again to
          982  +   retrieve the header from the next gzip stream.
          983  +
          984  +     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
          985  +   stream state was inconsistent.
          986  +*/
          987  +
          988  +/*
          989  +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
          990  +                                        unsigned char FAR *window));
          991  +
          992  +     Initialize the internal stream state for decompression using inflateBack()
          993  +   calls.  The fields zalloc, zfree and opaque in strm must be initialized
          994  +   before the call.  If zalloc and zfree are Z_NULL, then the default library-
          995  +   derived memory allocation routines are used.  windowBits is the base two
          996  +   logarithm of the window size, in the range 8..15.  window is a caller
          997  +   supplied buffer of that size.  Except for special applications where it is
          998  +   assured that deflate was used with small window sizes, windowBits must be 15
          999  +   and a 32K byte window must be supplied to be able to decompress general
         1000  +   deflate streams.
         1001  +
         1002  +     See inflateBack() for the usage of these routines.
         1003  +
         1004  +     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
         1005  +   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
         1006  +   allocated, or Z_VERSION_ERROR if the version of the library does not match
         1007  +   the version of the header file.
         1008  +*/
         1009  +
         1010  +typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
         1011  +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
         1012  +
         1013  +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
         1014  +                                    in_func in, void FAR *in_desc,
         1015  +                                    out_func out, void FAR *out_desc));
         1016  +/*
         1017  +     inflateBack() does a raw inflate with a single call using a call-back
         1018  +   interface for input and output.  This is more efficient than inflate() for
         1019  +   file i/o applications in that it avoids copying between the output and the
         1020  +   sliding window by simply making the window itself the output buffer.  This
         1021  +   function trusts the application to not change the output buffer passed by
         1022  +   the output function, at least until inflateBack() returns.
         1023  +
         1024  +     inflateBackInit() must be called first to allocate the internal state
         1025  +   and to initialize the state with the user-provided window buffer.
         1026  +   inflateBack() may then be used multiple times to inflate a complete, raw
         1027  +   deflate stream with each call.  inflateBackEnd() is then called to free the
         1028  +   allocated state.
         1029  +
         1030  +     A raw deflate stream is one with no zlib or gzip header or trailer.
         1031  +   This routine would normally be used in a utility that reads zip or gzip
         1032  +   files and writes out uncompressed files.  The utility would decode the
         1033  +   header and process the trailer on its own, hence this routine expects only
         1034  +   the raw deflate stream to decompress.  This is different from the normal
         1035  +   behavior of inflate(), which expects either a zlib or gzip header and
         1036  +   trailer around the deflate stream.
         1037  +
         1038  +     inflateBack() uses two subroutines supplied by the caller that are then
         1039  +   called by inflateBack() for input and output.  inflateBack() calls those
         1040  +   routines until it reads a complete deflate stream and writes out all of the
         1041  +   uncompressed data, or until it encounters an error.  The function's
         1042  +   parameters and return types are defined above in the in_func and out_func
         1043  +   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
         1044  +   number of bytes of provided input, and a pointer to that input in buf.  If
         1045  +   there is no input available, in() must return zero--buf is ignored in that
         1046  +   case--and inflateBack() will return a buffer error.  inflateBack() will call
         1047  +   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
         1048  +   should return zero on success, or non-zero on failure.  If out() returns
         1049  +   non-zero, inflateBack() will return with an error.  Neither in() nor out()
         1050  +   are permitted to change the contents of the window provided to
         1051  +   inflateBackInit(), which is also the buffer that out() uses to write from.
         1052  +   The length written by out() will be at most the window size.  Any non-zero
         1053  +   amount of input may be provided by in().
         1054  +
         1055  +     For convenience, inflateBack() can be provided input on the first call by
         1056  +   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
         1057  +   in() will be called.  Therefore strm->next_in must be initialized before
         1058  +   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
         1059  +   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
         1060  +   must also be initialized, and then if strm->avail_in is not zero, input will
         1061  +   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
         1062  +
         1063  +     The in_desc and out_desc parameters of inflateBack() is passed as the
         1064  +   first parameter of in() and out() respectively when they are called.  These
         1065  +   descriptors can be optionally used to pass any information that the caller-
         1066  +   supplied in() and out() functions need to do their job.
         1067  +
         1068  +     On return, inflateBack() will set strm->next_in and strm->avail_in to
         1069  +   pass back any unused input that was provided by the last in() call.  The
         1070  +   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
         1071  +   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
         1072  +   in the deflate stream (in which case strm->msg is set to indicate the nature
         1073  +   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
         1074  +   In the case of Z_BUF_ERROR, an input or output error can be distinguished
         1075  +   using strm->next_in which will be Z_NULL only if in() returned an error.  If
         1076  +   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
         1077  +   non-zero.  (in() will always be called before out(), so strm->next_in is
         1078  +   assured to be defined if out() returns non-zero.) Note that inflateBack()
         1079  +   cannot return Z_OK.
         1080  +*/
         1081  +
         1082  +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
         1083  +/*
         1084  +     All memory allocated by inflateBackInit() is freed.
         1085  +
         1086  +     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
         1087  +   state was inconsistent.
         1088  +*/
         1089  +
         1090  +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
         1091  +/* Return flags indicating compile-time options.
         1092  +
         1093  +    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
         1094  +     1.0: size of uInt
         1095  +     3.2: size of uLong
         1096  +     5.4: size of voidpf (pointer)
         1097  +     7.6: size of z_off_t
         1098  +
         1099  +    Compiler, assembler, and debug options:
         1100  +     8: DEBUG
         1101  +     9: ASMV or ASMINF -- use ASM code
         1102  +     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
         1103  +     11: 0 (reserved)
         1104  +
         1105  +    One-time table building (smaller code, but not thread-safe if true):
         1106  +     12: BUILDFIXED -- build static block decoding tables when needed
         1107  +     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
         1108  +     14,15: 0 (reserved)
         1109  +
         1110  +    Library content (indicates missing functionality):
         1111  +     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
         1112  +                          deflate code when not needed)
         1113  +     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
         1114  +                    and decode gzip streams (to avoid linking crc code)
         1115  +     18-19: 0 (reserved)
         1116  +
         1117  +    Operation variations (changes in library functionality):
         1118  +     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
         1119  +     21: FASTEST -- deflate algorithm with only one, lowest compression level
         1120  +     22,23: 0 (reserved)
         1121  +
         1122  +    The sprintf variant used by gzprintf (zero is best):
         1123  +     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
         1124  +     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
         1125  +     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
         1126  +
         1127  +    Remainder:
         1128  +     27-31: 0 (reserved)
         1129  + */
         1130  +
         1131  +#ifndef Z_SOLO
         1132  +
         1133  +                        /* utility functions */
         1134  +
         1135  +/*
         1136  +     The following utility functions are implemented on top of the basic
         1137  +   stream-oriented functions.  To simplify the interface, some default options
         1138  +   are assumed (compression level and memory usage, standard memory allocation
         1139  +   functions).  The source code of these utility functions can be modified if
         1140  +   you need special options.
         1141  +*/
         1142  +
         1143  +ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
         1144  +                                 const Bytef *source, uLong sourceLen));
         1145  +/*
         1146  +     Compresses the source buffer into the destination buffer.  sourceLen is
         1147  +   the byte length of the source buffer.  Upon entry, destLen is the total size
         1148  +   of the destination buffer, which must be at least the value returned by
         1149  +   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
         1150  +   compressed buffer.
         1151  +
         1152  +     compress returns Z_OK if success, Z_MEM_ERROR if there was not
         1153  +   enough memory, Z_BUF_ERROR if there was not enough room in the output
         1154  +   buffer.
         1155  +*/
         1156  +
         1157  +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
         1158  +                                  const Bytef *source, uLong sourceLen,
         1159  +                                  int level));
         1160  +/*
         1161  +     Compresses the source buffer into the destination buffer.  The level
         1162  +   parameter has the same meaning as in deflateInit.  sourceLen is the byte
         1163  +   length of the source buffer.  Upon entry, destLen is the total size of the
         1164  +   destination buffer, which must be at least the value returned by
         1165  +   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
         1166  +   compressed buffer.
         1167  +
         1168  +     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
         1169  +   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
         1170  +   Z_STREAM_ERROR if the level parameter is invalid.
         1171  +*/
         1172  +
         1173  +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
         1174  +/*
         1175  +     compressBound() returns an upper bound on the compressed size after
         1176  +   compress() or compress2() on sourceLen bytes.  It would be used before a
         1177  +   compress() or compress2() call to allocate the destination buffer.
         1178  +*/
         1179  +
         1180  +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
         1181  +                                   const Bytef *source, uLong sourceLen));
         1182  +/*
         1183  +     Decompresses the source buffer into the destination buffer.  sourceLen is
         1184  +   the byte length of the source buffer.  Upon entry, destLen is the total size
         1185  +   of the destination buffer, which must be large enough to hold the entire
         1186  +   uncompressed data.  (The size of the uncompressed data must have been saved
         1187  +   previously by the compressor and transmitted to the decompressor by some
         1188  +   mechanism outside the scope of this compression library.) Upon exit, destLen
         1189  +   is the actual size of the uncompressed buffer.
         1190  +
         1191  +     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
         1192  +   enough memory, Z_BUF_ERROR if there was not enough room in the output
         1193  +   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
         1194  +   the case where there is not enough room, uncompress() will fill the output
         1195  +   buffer with the uncompressed data up to that point.
         1196  +*/
         1197  +
         1198  +                        /* gzip file access functions */
         1199  +
         1200  +/*
         1201  +     This library supports reading and writing files in gzip (.gz) format with
         1202  +   an interface similar to that of stdio, using the functions that start with
         1203  +   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
         1204  +   wrapper, documented in RFC 1952, wrapped around a deflate stream.
         1205  +*/
         1206  +
         1207  +typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
         1208  +
         1209  +/*
         1210  +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
         1211  +
         1212  +     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
         1213  +   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
         1214  +   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
         1215  +   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
         1216  +   for fixed code compression as in "wb9F".  (See the description of
         1217  +   deflateInit2 for more information about the strategy parameter.)  'T' will
         1218  +   request transparent writing or appending with no compression and not using
         1219  +   the gzip format.
         1220  +
         1221  +     "a" can be used instead of "w" to request that the gzip stream that will
         1222  +   be written be appended to the file.  "+" will result in an error, since
         1223  +   reading and writing to the same gzip file is not supported.  The addition of
         1224  +   "x" when writing will create the file exclusively, which fails if the file
         1225  +   already exists.  On systems that support it, the addition of "e" when
         1226  +   reading or writing will set the flag to close the file on an execve() call.
         1227  +
         1228  +     These functions, as well as gzip, will read and decode a sequence of gzip
         1229  +   streams in a file.  The append function of gzopen() can be used to create
         1230  +   such a file.  (Also see gzflush() for another way to do this.)  When
         1231  +   appending, gzopen does not test whether the file begins with a gzip stream,
         1232  +   nor does it look for the end of the gzip streams to begin appending.  gzopen
         1233  +   will simply append a gzip stream to the existing file.
         1234  +
         1235  +     gzopen can be used to read a file which is not in gzip format; in this
         1236  +   case gzread will directly read from the file without decompression.  When
         1237  +   reading, this will be detected automatically by looking for the magic two-
         1238  +   byte gzip header.
         1239  +
         1240  +     gzopen returns NULL if the file could not be opened, if there was
         1241  +   insufficient memory to allocate the gzFile state, or if an invalid mode was
         1242  +   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
         1243  +   errno can be checked to determine if the reason gzopen failed was that the
         1244  +   file could not be opened.
         1245  +*/
         1246  +
         1247  +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
         1248  +/*
         1249  +     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
         1250  +   are obtained from calls like open, dup, creat, pipe or fileno (if the file
         1251  +   has been previously opened with fopen).  The mode parameter is as in gzopen.
         1252  +
         1253  +     The next call of gzclose on the returned gzFile will also close the file
         1254  +   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
         1255  +   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
         1256  +   mode);.  The duplicated descriptor should be saved to avoid a leak, since
         1257  +   gzdopen does not close fd if it fails.  If you are using fileno() to get the
         1258  +   file descriptor from a FILE *, then you will have to use dup() to avoid
         1259  +   double-close()ing the file descriptor.  Both gzclose() and fclose() will
         1260  +   close the associated file descriptor, so they need to have different file
         1261  +   descriptors.
         1262  +
         1263  +     gzdopen returns NULL if there was insufficient memory to allocate the
         1264  +   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
         1265  +   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
         1266  +   used until the next gz* read, write, seek, or close operation, so gzdopen
         1267  +   will not detect if fd is invalid (unless fd is -1).
         1268  +*/
         1269  +
         1270  +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
         1271  +/*
         1272  +     Set the internal buffer size used by this library's functions.  The
         1273  +   default buffer size is 8192 bytes.  This function must be called after
         1274  +   gzopen() or gzdopen(), and before any other calls that read or write the
         1275  +   file.  The buffer memory allocation is always deferred to the first read or
         1276  +   write.  Two buffers are allocated, either both of the specified size when
         1277  +   writing, or one of the specified size and the other twice that size when
         1278  +   reading.  A larger buffer size of, for example, 64K or 128K bytes will
         1279  +   noticeably increase the speed of decompression (reading).
         1280  +
         1281  +     The new buffer size also affects the maximum length for gzprintf().
         1282  +
         1283  +     gzbuffer() returns 0 on success, or -1 on failure, such as being called
         1284  +   too late.
         1285  +*/
         1286  +
         1287  +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
         1288  +/*
         1289  +     Dynamically update the compression level or strategy.  See the description
         1290  +   of deflateInit2 for the meaning of these parameters.
         1291  +
         1292  +     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
         1293  +   opened for writing.
         1294  +*/
         1295  +
         1296  +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
         1297  +/*
         1298  +     Reads the given number of uncompressed bytes from the compressed file.  If
         1299  +   the input file is not in gzip format, gzread copies the given number of
         1300  +   bytes into the buffer directly from the file.
         1301  +
         1302  +     After reaching the end of a gzip stream in the input, gzread will continue
         1303  +   to read, looking for another gzip stream.  Any number of gzip streams may be
         1304  +   concatenated in the input file, and will all be decompressed by gzread().
         1305  +   If something other than a gzip stream is encountered after a gzip stream,
         1306  +   that remaining trailing garbage is ignored (and no error is returned).
         1307  +
         1308  +     gzread can be used to read a gzip file that is being concurrently written.
         1309  +   Upon reaching the end of the input, gzread will return with the available
         1310  +   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
         1311  +   gzclearerr can be used to clear the end of file indicator in order to permit
         1312  +   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
         1313  +   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
         1314  +   middle of a gzip stream.  Note that gzread does not return -1 in the event
         1315  +   of an incomplete gzip stream.  This error is deferred until gzclose(), which
         1316  +   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
         1317  +   stream.  Alternatively, gzerror can be used before gzclose to detect this
         1318  +   case.
         1319  +
         1320  +     gzread returns the number of uncompressed bytes actually read, less than
         1321  +   len for end of file, or -1 for error.
         1322  +*/
         1323  +
         1324  +ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
         1325  +                                voidpc buf, unsigned len));
         1326  +/*
         1327  +     Writes the given number of uncompressed bytes into the compressed file.
         1328  +   gzwrite returns the number of uncompressed bytes written or 0 in case of
         1329  +   error.
         1330  +*/
         1331  +
         1332  +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
         1333  +/*
         1334  +     Converts, formats, and writes the arguments to the compressed file under
         1335  +   control of the format string, as in fprintf.  gzprintf returns the number of
         1336  +   uncompressed bytes actually written, or 0 in case of error.  The number of
         1337  +   uncompressed bytes written is limited to 8191, or one less than the buffer
         1338  +   size given to gzbuffer().  The caller should assure that this limit is not
         1339  +   exceeded.  If it is exceeded, then gzprintf() will return an error (0) with
         1340  +   nothing written.  In this case, there may also be a buffer overflow with
         1341  +   unpredictable consequences, which is possible only if zlib was compiled with
         1342  +   the insecure functions sprintf() or vsprintf() because the secure snprintf()
         1343  +   or vsnprintf() functions were not available.  This can be determined using
         1344  +   zlibCompileFlags().
         1345  +*/
         1346  +
         1347  +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
         1348  +/*
         1349  +     Writes the given null-terminated string to the compressed file, excluding
         1350  +   the terminating null character.
         1351  +
         1352  +     gzputs returns the number of characters written, or -1 in case of error.
         1353  +*/
         1354  +
         1355  +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
         1356  +/*
         1357  +     Reads bytes from the compressed file until len-1 characters are read, or a
         1358  +   newline character is read and transferred to buf, or an end-of-file
         1359  +   condition is encountered.  If any characters are read or if len == 1, the
         1360  +   string is terminated with a null character.  If no characters are read due
         1361  +   to an end-of-file or len < 1, then the buffer is left untouched.
         1362  +
         1363  +     gzgets returns buf which is a null-terminated string, or it returns NULL
         1364  +   for end-of-file or in case of error.  If there was an error, the contents at
         1365  +   buf are indeterminate.
         1366  +*/
         1367  +
         1368  +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
         1369  +/*
         1370  +     Writes c, converted to an unsigned char, into the compressed file.  gzputc
         1371  +   returns the value that was written, or -1 in case of error.
         1372  +*/
         1373  +
         1374  +ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
         1375  +/*
         1376  +     Reads one byte from the compressed file.  gzgetc returns this byte or -1
         1377  +   in case of end of file or error.  This is implemented as a macro for speed.
         1378  +   As such, it does not do all of the checking the other functions do.  I.e.
         1379  +   it does not check to see if file is NULL, nor whether the structure file
         1380  +   points to has been clobbered or not.
         1381  +*/
         1382  +
         1383  +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
         1384  +/*
         1385  +     Push one character back onto the stream to be read as the first character
         1386  +   on the next read.  At least one character of push-back is allowed.
         1387  +   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
         1388  +   fail if c is -1, and may fail if a character has been pushed but not read
         1389  +   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
         1390  +   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
         1391  +   The pushed character will be discarded if the stream is repositioned with
         1392  +   gzseek() or gzrewind().
         1393  +*/
         1394  +
         1395  +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
         1396  +/*
         1397  +     Flushes all pending output into the compressed file.  The parameter flush
         1398  +   is as in the deflate() function.  The return value is the zlib error number
         1399  +   (see function gzerror below).  gzflush is only permitted when writing.
         1400  +
         1401  +     If the flush parameter is Z_FINISH, the remaining data is written and the
         1402  +   gzip stream is completed in the output.  If gzwrite() is called again, a new
         1403  +   gzip stream will be started in the output.  gzread() is able to read such
         1404  +   concatented gzip streams.
         1405  +
         1406  +     gzflush should be called only when strictly necessary because it will
         1407  +   degrade compression if called too often.
         1408  +*/
         1409  +
         1410  +/*
         1411  +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
         1412  +                                   z_off_t offset, int whence));
         1413  +
         1414  +     Sets the starting position for the next gzread or gzwrite on the given
         1415  +   compressed file.  The offset represents a number of bytes in the
         1416  +   uncompressed data stream.  The whence parameter is defined as in lseek(2);
         1417  +   the value SEEK_END is not supported.
         1418  +
         1419  +     If the file is opened for reading, this function is emulated but can be
         1420  +   extremely slow.  If the file is opened for writing, only forward seeks are
         1421  +   supported; gzseek then compresses a sequence of zeroes up to the new
         1422  +   starting position.
         1423  +
         1424  +     gzseek returns the resulting offset location as measured in bytes from
         1425  +   the beginning of the uncompressed stream, or -1 in case of error, in
         1426  +   particular if the file is opened for writing and the new starting position
         1427  +   would be before the current position.
         1428  +*/
         1429  +
         1430  +ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
         1431  +/*
         1432  +     Rewinds the given file. This function is supported only for reading.
         1433  +
         1434  +     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
         1435  +*/
         1436  +
         1437  +/*
         1438  +ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
         1439  +
         1440  +     Returns the starting position for the next gzread or gzwrite on the given
         1441  +   compressed file.  This position represents a number of bytes in the
         1442  +   uncompressed data stream, and is zero when starting, even if appending or
         1443  +   reading a gzip stream from the middle of a file using gzdopen().
         1444  +
         1445  +     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
         1446  +*/
         1447  +
         1448  +/*
         1449  +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
         1450  +
         1451  +     Returns the current offset in the file being read or written.  This offset
         1452  +   includes the count of bytes that precede the gzip stream, for example when
         1453  +   appending or when using gzdopen() for reading.  When reading, the offset
         1454  +   does not include as yet unused buffered input.  This information can be used
         1455  +   for a progress indicator.  On error, gzoffset() returns -1.
         1456  +*/
         1457  +
         1458  +ZEXTERN int ZEXPORT gzeof OF((gzFile file));
         1459  +/*
         1460  +     Returns true (1) if the end-of-file indicator has been set while reading,
         1461  +   false (0) otherwise.  Note that the end-of-file indicator is set only if the
         1462  +   read tried to go past the end of the input, but came up short.  Therefore,
         1463  +   just like feof(), gzeof() may return false even if there is no more data to
         1464  +   read, in the event that the last read request was for the exact number of
         1465  +   bytes remaining in the input file.  This will happen if the input file size
         1466  +   is an exact multiple of the buffer size.
         1467  +
         1468  +     If gzeof() returns true, then the read functions will return no more data,
         1469  +   unless the end-of-file indicator is reset by gzclearerr() and the input file
         1470  +   has grown since the previous end of file was detected.
         1471  +*/
         1472  +
         1473  +ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
         1474  +/*
         1475  +     Returns true (1) if file is being copied directly while reading, or false
         1476  +   (0) if file is a gzip stream being decompressed.
         1477  +
         1478  +     If the input file is empty, gzdirect() will return true, since the input
         1479  +   does not contain a gzip stream.
         1480  +
         1481  +     If gzdirect() is used immediately after gzopen() or gzdopen() it will
         1482  +   cause buffers to be allocated to allow reading the file to determine if it
         1483  +   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
         1484  +   gzdirect().
         1485  +
         1486  +     When writing, gzdirect() returns true (1) if transparent writing was
         1487  +   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
         1488  +   gzdirect() is not needed when writing.  Transparent writing must be
         1489  +   explicitly requested, so the application already knows the answer.  When
         1490  +   linking statically, using gzdirect() will include all of the zlib code for
         1491  +   gzip file reading and decompression, which may not be desired.)
         1492  +*/
         1493  +
         1494  +ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
         1495  +/*
         1496  +     Flushes all pending output if necessary, closes the compressed file and
         1497  +   deallocates the (de)compression state.  Note that once file is closed, you
         1498  +   cannot call gzerror with file, since its structures have been deallocated.
         1499  +   gzclose must not be called more than once on the same file, just as free
         1500  +   must not be called more than once on the same allocation.
         1501  +
         1502  +     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
         1503  +   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
         1504  +   last read ended in the middle of a gzip stream, or Z_OK on success.
         1505  +*/
         1506  +
         1507  +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
         1508  +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
         1509  +/*
         1510  +     Same as gzclose(), but gzclose_r() is only for use when reading, and
         1511  +   gzclose_w() is only for use when writing or appending.  The advantage to
         1512  +   using these instead of gzclose() is that they avoid linking in zlib
         1513  +   compression or decompression code that is not used when only reading or only
         1514  +   writing respectively.  If gzclose() is used, then both compression and
         1515  +   decompression code will be included the application when linking to a static
         1516  +   zlib library.
         1517  +*/
         1518  +
         1519  +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
         1520  +/*
         1521  +     Returns the error message for the last error which occurred on the given
         1522  +   compressed file.  errnum is set to zlib error number.  If an error occurred
         1523  +   in the file system and not in the compression library, errnum is set to
         1524  +   Z_ERRNO and the application may consult errno to get the exact error code.
         1525  +
         1526  +     The application must not modify the returned string.  Future calls to
         1527  +   this function may invalidate the previously returned string.  If file is
         1528  +   closed, then the string previously returned by gzerror will no longer be
         1529  +   available.
         1530  +
         1531  +     gzerror() should be used to distinguish errors from end-of-file for those
         1532  +   functions above that do not distinguish those cases in their return values.
         1533  +*/
         1534  +
         1535  +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
         1536  +/*
         1537  +     Clears the error and end-of-file flags for file.  This is analogous to the
         1538  +   clearerr() function in stdio.  This is useful for continuing to read a gzip
         1539  +   file that is being written concurrently.
         1540  +*/
         1541  +
         1542  +#endif /* !Z_SOLO */
         1543  +
         1544  +                        /* checksum functions */
         1545  +
         1546  +/*
         1547  +     These functions are not related to compression but are exported
         1548  +   anyway because they might be useful in applications using the compression
         1549  +   library.
         1550  +*/
         1551  +
         1552  +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
         1553  +/*
         1554  +     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
         1555  +   return the updated checksum.  If buf is Z_NULL, this function returns the
         1556  +   required initial value for the checksum.
         1557  +
         1558  +     An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
         1559  +   much faster.
         1560  +
         1561  +   Usage example:
         1562  +
         1563  +     uLong adler = adler32(0L, Z_NULL, 0);
         1564  +
         1565  +     while (read_buffer(buffer, length) != EOF) {
         1566  +       adler = adler32(adler, buffer, length);
         1567  +     }
         1568  +     if (adler != original_adler) error();
         1569  +*/
         1570  +
         1571  +/*
         1572  +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
         1573  +                                          z_off_t len2));
         1574  +
         1575  +     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
         1576  +   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
         1577  +   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
         1578  +   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
         1579  +   that the z_off_t type (like off_t) is a signed integer.  If len2 is
         1580  +   negative, the result has no meaning or utility.
         1581  +*/
         1582  +
         1583  +ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
         1584  +/*
         1585  +     Update a running CRC-32 with the bytes buf[0..len-1] and return the
         1586  +   updated CRC-32.  If buf is Z_NULL, this function returns the required
         1587  +   initial value for the crc.  Pre- and post-conditioning (one's complement) is
         1588  +   performed within this function so it shouldn't be done by the application.
         1589  +
         1590  +   Usage example:
         1591  +
         1592  +     uLong crc = crc32(0L, Z_NULL, 0);
         1593  +
         1594  +     while (read_buffer(buffer, length) != EOF) {
         1595  +       crc = crc32(crc, buffer, length);
         1596  +     }
         1597  +     if (crc != original_crc) error();
         1598  +*/
         1599  +
         1600  +/*
         1601  +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
         1602  +
         1603  +     Combine two CRC-32 check values into one.  For two sequences of bytes,
         1604  +   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
         1605  +   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
         1606  +   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
         1607  +   len2.
         1608  +*/
         1609  +
         1610  +
         1611  +                        /* various hacks, don't look :) */
         1612  +
         1613  +/* deflateInit and inflateInit are macros to allow checking the zlib version
         1614  + * and the compiler's view of z_stream:
         1615  + */
         1616  +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
         1617  +                                     const char *version, int stream_size));
         1618  +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
         1619  +                                     const char *version, int stream_size));
         1620  +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
         1621  +                                      int windowBits, int memLevel,
         1622  +                                      int strategy, const char *version,
         1623  +                                      int stream_size));
         1624  +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
         1625  +                                      const char *version, int stream_size));
         1626  +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
         1627  +                                         unsigned char FAR *window,
         1628  +                                         const char *version,
         1629  +                                         int stream_size));
         1630  +#define deflateInit(strm, level) \
         1631  +        deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
         1632  +#define inflateInit(strm) \
         1633  +        inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
         1634  +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
         1635  +        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
         1636  +                      (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
         1637  +#define inflateInit2(strm, windowBits) \
         1638  +        inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
         1639  +                      (int)sizeof(z_stream))
         1640  +#define inflateBackInit(strm, windowBits, window) \
         1641  +        inflateBackInit_((strm), (windowBits), (window), \
         1642  +                      ZLIB_VERSION, (int)sizeof(z_stream))
         1643  +
         1644  +#ifndef Z_SOLO
         1645  +
         1646  +/* gzgetc() macro and its supporting function and exposed data structure.  Note
         1647  + * that the real internal state is much larger than the exposed structure.
         1648  + * This abbreviated structure exposes just enough for the gzgetc() macro.  The
         1649  + * user should not mess with these exposed elements, since their names or
         1650  + * behavior could change in the future, perhaps even capriciously.  They can
         1651  + * only be used by the gzgetc() macro.  You have been warned.
         1652  + */
         1653  +struct gzFile_s {
         1654  +    unsigned have;
         1655  +    unsigned char *next;
         1656  +    z_off64_t pos;
         1657  +};
         1658  +ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
         1659  +#ifdef Z_PREFIX_SET
         1660  +#  undef z_gzgetc
         1661  +#  define z_gzgetc(g) \
         1662  +          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
         1663  +#else
         1664  +#  define gzgetc(g) \
         1665  +          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
         1666  +#endif
         1667  +
         1668  +/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
         1669  + * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
         1670  + * both are true, the application gets the *64 functions, and the regular
         1671  + * functions are changed to 64 bits) -- in case these are set on systems
         1672  + * without large file support, _LFS64_LARGEFILE must also be true
         1673  + */
         1674  +#ifdef Z_LARGE64
         1675  +   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
         1676  +   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
         1677  +   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
         1678  +   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
         1679  +   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
         1680  +   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
         1681  +#endif
         1682  +
         1683  +#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
         1684  +#  ifdef Z_PREFIX_SET
         1685  +#    define z_gzopen z_gzopen64
         1686  +#    define z_gzseek z_gzseek64
         1687  +#    define z_gztell z_gztell64
         1688  +#    define z_gzoffset z_gzoffset64
         1689  +#    define z_adler32_combine z_adler32_combine64
         1690  +#    define z_crc32_combine z_crc32_combine64
         1691  +#  else
         1692  +#    define gzopen gzopen64
         1693  +#    define gzseek gzseek64
         1694  +#    define gztell gztell64
         1695  +#    define gzoffset gzoffset64
         1696  +#    define adler32_combine adler32_combine64
         1697  +#    define crc32_combine crc32_combine64
         1698  +#  endif
         1699  +#  ifndef Z_LARGE64
         1700  +     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
         1701  +     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
         1702  +     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
         1703  +     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
         1704  +     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
         1705  +     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
         1706  +#  endif
         1707  +#else
         1708  +   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
         1709  +   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
         1710  +   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
         1711  +   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
         1712  +   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
         1713  +   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
         1714  +#endif
         1715  +
         1716  +#else /* Z_SOLO */
         1717  +
         1718  +   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
         1719  +   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
         1720  +
         1721  +#endif /* !Z_SOLO */
         1722  +
         1723  +/* hack for buggy compilers */
         1724  +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
         1725  +    struct internal_state {int dummy;};
         1726  +#endif
         1727  +
         1728  +/* undocumented functions */
         1729  +ZEXTERN const char   * ZEXPORT zError           OF((int));
         1730  +ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
         1731  +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table    OF((void));
         1732  +ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
         1733  +ZEXTERN int            ZEXPORT inflateResetKeep OF((z_streamp));
         1734  +ZEXTERN int            ZEXPORT deflateResetKeep OF((z_streamp));
         1735  +#if defined(_WIN32) && !defined(Z_SOLO)
         1736  +ZEXTERN gzFile         ZEXPORT gzopen_w OF((const wchar_t *path,
         1737  +                                            const char *mode));
         1738  +#endif
         1739  +
         1740  +#ifdef __cplusplus
         1741  +}
         1742  +#endif
         1743  +
         1744  +#endif /* ZLIB_H */

Added build/cackey_win64_build/lib/libz.a version [00d2e69dfd].

cannot compute difference between binary files

Added build/cackey_win64_build/lib/winscard.dll version [d8a369cdb6].

cannot compute difference between binary files

Added build/cackey_win64_build/lib/winscard.lib version [a067715b19].

cannot compute difference between binary files