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