Index: asn1-x509.c ================================================================== --- asn1-x509.c +++ asn1-x509.c @@ -364,11 +364,11 @@ *outbuf = '\0'; outbuf_s = outbuf; offset = 0; while (1) { - read_ret = asn1_x509_read_asn1_object(((unsigned char *) whole_thing.contents) + offset, whole_thing.size - offset, ¤t_set, NULL); + read_ret = asn1_x509_read_asn1_object(whole_thing.contents + offset, whole_thing.size - offset, ¤t_set, NULL); if (read_ret != 0) { break; } offset += current_set.size + 2; Index: build/build.sh ================================================================== --- build/build.sh +++ build/build.sh @@ -30,9 +30,8 @@ if [ "${SNAPSHOT}" != "1" ]; then mv build build_delete mkdir build || exit 1 cp -rp build_delete/cackey_win32_build build/ - cp -rp build_delete/cackey_win64_build build/ fi exit 0 Index: build/cackey_osx_build/Template_pmbuild/index.xml.in ================================================================== --- build/cackey_osx_build/Template_pmbuild/index.xml.in +++ build/cackey_osx_build/Template_pmbuild/index.xml.in @@ -47,12 +47,12 @@ Public License (GPL):\ config.guess, config.sub, install-sh\ \ The files in the source directory and the "leakcheck" directory are the intellectual\ property of the United States Government. It is not clear which, if any,\ -license is made on them. In addition, as of 07-JUN-2010 they have not\ -been cleared for public release.\ +license is made on them. In addition, as of 07-JUN-2010 they have not be\ +cleared for public release.\ \ The files in the "pkcs11/" directory are licensed under the terms of the\ following licenses:\ mypkcs11.h : GNU General Public License 2.1.\ pkcs11.h : GNU General Public License 2.1.\ Index: build/cackey_osx_build/build_osx.sh ================================================================== --- build/cackey_osx_build/build_osx.sh +++ build/cackey_osx_build/build_osx.sh @@ -14,11 +14,10 @@ echo "Usage: build_osx.sh " echo Where target is one of: echo " leopard - (Builds Universal 10.5 Library for PPCG4/i386)" echo " snowleopard - (Builds Universal 10.6 Library for i386/x86_64)" echo " lion - (Builds Universal 10.7 Library for i386/x86_64)" - echo " sltoml - (Builds Universal 10.6/10.7/10.8 Library for i386/x86_64)" echo " all - (Builds for all supported targets)" echo " clean - (Cleans up)" echo "Run from CACKey Build Root." exit $? } @@ -43,11 +42,10 @@ if [ ! -d macbuild ]; then mkdir macbuild mkdir macbuild/Leopard mkdir macbuild/Snowleopard mkdir macbuild/Lion - mkdir macbuild/Sltoml mkdir macbuild/pkg fi if [ ! -f config.guess ]; then cp ${LIBTOOLDIR}/config.guess . fi @@ -117,50 +115,10 @@ done libbuild pkgbuild } -# Build function for Snow Leopard/Lion/Mountain Lion -sltoml() { - makedir - HEADERS=/Developer/SDKs/MacOSX10.6.sdk/System/Library/Frameworks/PCSC.framework/Versions/A/Headers/ - LIBRARY=/Developer/SDKs/MacOSX10.6.sdk/System/Library/Frameworks/PCSC.framework/PCSC - LIB="" - ARCHLIST="" - DLIB="" - DARCHLIST="" - OSX=Sltoml - PKTARGETOS=3 - NEXTOSXVER=10.9 - CUROSXVER=10.6 - for HOST in i386-apple-darwin10 x86_64-apple-darwin10; do - genbuild - done - libbuild - pkgbuild -} - -# Build function for Snow Leopard/Lion/Mountain Lion -sltoml() { - makedir - HEADERS=/Developer/SDKs/MacOSX10.6.sdk/System/Library/Frameworks/PCSC.framework/Versions/A/Headers/ - LIBRARY=/Developer/SDKs/MacOSX10.6.sdk/System/Library/Frameworks/PCSC.framework/PCSC - LIB="" - ARCHLIST="" - DLIB="" - DARCHLIST="" - OSX=Sltoml - PKTARGETOS=3 - NEXTOSXVER=10.9 - CUROSXVER=10.6 - for HOST in i386-apple-darwin10 x86_64-apple-darwin10; do - genbuild - done - libbuild - pkgbuild -} - # Generic build function genbuild() { make distclean ARCH=`echo ${HOST} | cut -d "-" -f 1` if [ ${ARCH} == "powerpc" ]; then @@ -170,16 +128,16 @@ ARCH="ppc -mcpu=G3" fi fi if [ "${LIONBUILD}" = 1 ]; then if [ "${ARCH}" == "ppc -mcpu=G4" ]; then - CC=powerpc-apple-darwin11-gcc-4.2.1 CPP=powerpc-apple-darwin11-cpp-4.2.1 CFLAGS="-m32 -I/Developer/Platforms/iPhoneOS.platform/Developer/usr/lib/gcc/powerpc-apple-darwin10/4.2.1/include -isysroot /Developer/SDKs/MacOSX10.5.sdk" CPPFLAGS="-D_LIBC_LIMITS_H_" ./configure --with-pcsc-headers=${HEADERS} --with-pcsc-libs=${LIBRARY} --host=${HOST} --enable-dod-certs-on-hw-slots + CC=powerpc-apple-darwin11-gcc-4.2.1 CPP=powerpc-apple-darwin11-cpp-4.2.1 CFLAGS="-m32 -I/Developer/Platforms/iPhoneOS.platform/Developer/usr/lib/gcc/powerpc-apple-darwin10/4.2.1/include -isysroot /Developer/SDKs/MacOSX10.5.sdk" CPPFLAGS="-D_LIBC_LIMITS_H_" ./configure --with-pcsc-headers=${HEADERS} --with-pcsc-libs=${LIBRARY} --host=${HOST} else - CFLAGS="-arch ${ARCH}" ./configure --with-pcsc-headers=${HEADERS} --with-pcsc-libs=${LIBRARY} --host=${HOST} --enable-dod-certs-on-hw-slots + CFLAGS="-arch ${ARCH}" ./configure --with-pcsc-headers=${HEADERS} --with-pcsc-libs=${LIBRARY} --host=${HOST} fi else - CFLAGS="-arch ${ARCH}" ./configure --with-pcsc-headers=${HEADERS} --with-pcsc-libs=${LIBRARY} --host=${HOST} --enable-dod-certs-on-hw-slots + CFLAGS="-arch ${ARCH}" ./configure --with-pcsc-headers=${HEADERS} --with-pcsc-libs=${LIBRARY} --host=${HOST} fi make cp libcackey.dylib macbuild/${OSX}/libcackey.dylib.`echo ${ARCH} | cut -d ' ' -f 1` cp libcackey_g.dylib macbuild/${OSX}/libcackey_g.dylib.`echo ${ARCH} | cut -d ' ' -f 1` } @@ -236,14 +194,10 @@ EXT=pkg if [ ${OSX} == "Snowleopard" ]; then cat build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml | sed 's|for Mac OS X Snowleopard|for Mac OS X SnowLeopard|g' > build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml.new mv build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml.new build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml fi - if [ ${OSX} == "Sltoml" ]; then - cat build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml | sed 's|for Mac OS X Sltoml|for Mac OS X SLtoML|g' > build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml.new - mv build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml.new build/cackey_osx_build/${OSX}_pmbuild.pmdoc/index.xml - fi /Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker -d build/cackey_osx_build/${OSX}_pmbuild.pmdoc -o macbuild/pkg/CACKey_${CACKEY_VERSION}_${OSX}.${EXT} tar --create --directory macbuild/pkg/ --file macbuild/pkg/CACKey_${CACKEY_VERSION}_${OSX}.${EXT}.tar CACKey_${CACKEY_VERSION}_${OSX}.${EXT} gzip -9 macbuild/pkg/CACKey_${CACKEY_VERSION}_${OSX}.${EXT}.tar rm -rf macbuild/pkg/CACKey_${CACKEY_VERSION}_${OSX}.${EXT} rm -f build/cackey_osx_build/cackey.dylib @@ -273,21 +227,16 @@ "lion") ./autogen.sh lion exit $? ;; - - "sltoml") - ./autogen.sh - sltoml - exit $? - ;; "all") ./autogen.sh leopard - sltoml + snowleopard + lion echo "" echo "All builds complete." exit $? ;; Index: build/cackey_win32_build/build.sh ================================================================== --- build/cackey_win32_build/build.sh +++ build/cackey_win32_build/build.sh @@ -1,9 +1,13 @@ #! /bin/bash make distclean + +cp "./build/cackey_win32_build/lib/winscard.dll" "./build/cackey_win32_build/lib/WinSCard.dll" ./configure --with-pcsc-headers="$(pwd)/build/cackey_win32_build/include" --with-pcsc-libs="-L$(pwd)/build/cackey_win32_build/lib -lwinscard" --host=i586-mingw32msvc CPPFLAGS="-I$(pwd)/build/cackey_win32_build/include" || exit 1 make || exit 1 + +rm -f "./build/cackey_win32_build/lib/WinSCard.dll" exit 0 ADDED build/cackey_win32_build/include/SCardErr.h Index: build/cackey_win32_build/include/SCardErr.h ================================================================== --- /dev/null +++ build/cackey_win32_build/include/SCardErr.h @@ -0,0 +1,655 @@ +/* + scarderr.mc + + Error message codes from the Smart Card Resource Manager + These messages must be reconciled with winerror.w + They exist here to provide error messages on pre-Win2K systems. + +*/ +#ifndef SCARD_S_SUCCESS +// +// ============================= +// Facility SCARD Error Messages +// ============================= +// +#define SCARD_S_SUCCESS NO_ERROR +// +// Values are 32 bit values laid out as follows: +// +// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 +// 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 +// +---+-+-+-----------------------+-------------------------------+ +// |Sev|C|R| Facility | Code | +// +---+-+-+-----------------------+-------------------------------+ +// +// where +// +// Sev - is the severity code +// +// 00 - Success +// 01 - Informational +// 10 - Warning +// 11 - Error +// +// C - is the Customer code flag +// +// R - is a reserved bit +// +// Facility - is the facility code +// +// Code - is the facility's status code +// +// +// Define the facility codes +// +#define FACILITY_SYSTEM 0x0 +#define FACILITY_SCARD 0x10 + + +// +// Define the severity codes +// +#define STATUS_SEVERITY_WARNING 0x2 +#define STATUS_SEVERITY_INFORMATIONAL 0x1 +#define STATUS_SEVERITY_ERROR 0x3 + + +// +// MessageId: SCARD_F_INTERNAL_ERROR +// +// MessageText: +// +// An internal consistency check failed. +// +#define SCARD_F_INTERNAL_ERROR ((DWORD)0x80100001L) + +// +// MessageId: SCARD_E_CANCELLED +// +// MessageText: +// +// The action was cancelled by an SCardCancel request. +// +#define SCARD_E_CANCELLED ((DWORD)0x80100002L) + +// +// MessageId: SCARD_E_INVALID_HANDLE +// +// MessageText: +// +// The supplied handle was invalid. +// +#define SCARD_E_INVALID_HANDLE ((DWORD)0x80100003L) + +// +// MessageId: SCARD_E_INVALID_PARAMETER +// +// MessageText: +// +// One or more of the supplied parameters could not be properly interpreted. +// +#define SCARD_E_INVALID_PARAMETER ((DWORD)0x80100004L) + +// +// MessageId: SCARD_E_INVALID_TARGET +// +// MessageText: +// +// Registry startup information is missing or invalid. +// +#define SCARD_E_INVALID_TARGET ((DWORD)0x80100005L) + +// +// MessageId: SCARD_E_NO_MEMORY +// +// MessageText: +// +// Not enough memory available to complete this command. +// +#define SCARD_E_NO_MEMORY ((DWORD)0x80100006L) + +// +// MessageId: SCARD_F_WAITED_TOO_LONG +// +// MessageText: +// +// An internal consistency timer has expired. +// +#define SCARD_F_WAITED_TOO_LONG ((DWORD)0x80100007L) + +// +// MessageId: SCARD_E_INSUFFICIENT_BUFFER +// +// MessageText: +// +// The data buffer to receive returned data is too small for the returned data. +// +#define SCARD_E_INSUFFICIENT_BUFFER ((DWORD)0x80100008L) + +// +// MessageId: SCARD_E_UNKNOWN_READER +// +// MessageText: +// +// The specified reader name is not recognized. +// +#define SCARD_E_UNKNOWN_READER ((DWORD)0x80100009L) + +// +// MessageId: SCARD_E_TIMEOUT +// +// MessageText: +// +// The user-specified timeout value has expired. +// +#define SCARD_E_TIMEOUT ((DWORD)0x8010000AL) + +// +// MessageId: SCARD_E_SHARING_VIOLATION +// +// MessageText: +// +// The smart card cannot be accessed because of other connections outstanding. +// +#define SCARD_E_SHARING_VIOLATION ((DWORD)0x8010000BL) + +// +// MessageId: SCARD_E_NO_SMARTCARD +// +// MessageText: +// +// The operation requires a Smart Card, but no Smart Card is currently in the device. +// +#define SCARD_E_NO_SMARTCARD ((DWORD)0x8010000CL) + +// +// MessageId: SCARD_E_UNKNOWN_CARD +// +// MessageText: +// +// The specified smart card name is not recognized. +// +#define SCARD_E_UNKNOWN_CARD ((DWORD)0x8010000DL) + +// +// MessageId: SCARD_E_CANT_DISPOSE +// +// MessageText: +// +// The system could not dispose of the media in the requested manner. +// +#define SCARD_E_CANT_DISPOSE ((DWORD)0x8010000EL) + +// +// MessageId: SCARD_E_PROTO_MISMATCH +// +// MessageText: +// +// The requested protocols are incompatible with the protocol currently in use with the smart card. +// +#define SCARD_E_PROTO_MISMATCH ((DWORD)0x8010000FL) + +// +// MessageId: SCARD_E_NOT_READY +// +// MessageText: +// +// The reader or smart card is not ready to accept commands. +// +#define SCARD_E_NOT_READY ((DWORD)0x80100010L) + +// +// MessageId: SCARD_E_INVALID_VALUE +// +// MessageText: +// +// One or more of the supplied parameters values could not be properly interpreted. +// +#define SCARD_E_INVALID_VALUE ((DWORD)0x80100011L) + +// +// MessageId: SCARD_E_SYSTEM_CANCELLED +// +// MessageText: +// +// The action was cancelled by the system, presumably to log off or shut down. +// +#define SCARD_E_SYSTEM_CANCELLED ((DWORD)0x80100012L) + +// +// MessageId: SCARD_F_COMM_ERROR +// +// MessageText: +// +// An internal communications error has been detected. +// +#define SCARD_F_COMM_ERROR ((DWORD)0x80100013L) + +// +// MessageId: SCARD_F_UNKNOWN_ERROR +// +// MessageText: +// +// An internal error has been detected, but the source is unknown. +// +#define SCARD_F_UNKNOWN_ERROR ((DWORD)0x80100014L) + +// +// MessageId: SCARD_E_INVALID_ATR +// +// MessageText: +// +// An ATR obtained from the registry is not a valid ATR string. +// +#define SCARD_E_INVALID_ATR ((DWORD)0x80100015L) + +// +// MessageId: SCARD_E_NOT_TRANSACTED +// +// MessageText: +// +// An attempt was made to end a non-existent transaction. +// +#define SCARD_E_NOT_TRANSACTED ((DWORD)0x80100016L) + +// +// MessageId: SCARD_E_READER_UNAVAILABLE +// +// MessageText: +// +// The specified reader is not currently available for use. +// +#define SCARD_E_READER_UNAVAILABLE ((DWORD)0x80100017L) + +// +// MessageId: SCARD_P_SHUTDOWN +// +// MessageText: +// +// The operation has been aborted to allow the server application to exit. +// +#define SCARD_P_SHUTDOWN ((DWORD)0x80100018L) + +// +// MessageId: SCARD_E_PCI_TOO_SMALL +// +// MessageText: +// +// The PCI Receive buffer was too small. +// +#define SCARD_E_PCI_TOO_SMALL ((DWORD)0x80100019L) + +// +// MessageId: SCARD_E_READER_UNSUPPORTED +// +// MessageText: +// +// The reader driver does not meet minimal requirements for support. +// +#define SCARD_E_READER_UNSUPPORTED ((DWORD)0x8010001AL) + +// +// MessageId: SCARD_E_DUPLICATE_READER +// +// MessageText: +// +// The reader driver did not produce a unique reader name. +// +#define SCARD_E_DUPLICATE_READER ((DWORD)0x8010001BL) + +// +// MessageId: SCARD_E_CARD_UNSUPPORTED +// +// MessageText: +// +// The smart card does not meet minimal requirements for support. +// +#define SCARD_E_CARD_UNSUPPORTED ((DWORD)0x8010001CL) + +// +// MessageId: SCARD_E_NO_SERVICE +// +// MessageText: +// +// The Smart card resource manager is not running. +// +#define SCARD_E_NO_SERVICE ((DWORD)0x8010001DL) + +// +// MessageId: SCARD_E_SERVICE_STOPPED +// +// MessageText: +// +// The Smart card resource manager has shut down. +// +#define SCARD_E_SERVICE_STOPPED ((DWORD)0x8010001EL) + +// +// MessageId: SCARD_E_UNEXPECTED +// +// MessageText: +// +// An unexpected card error has occurred. +// +#define SCARD_E_UNEXPECTED ((DWORD)0x8010001FL) + +// +// MessageId: SCARD_E_ICC_INSTALLATION +// +// MessageText: +// +// No Primary Provider can be found for the smart card. +// +#define SCARD_E_ICC_INSTALLATION ((DWORD)0x80100020L) + +// +// MessageId: SCARD_E_ICC_CREATEORDER +// +// MessageText: +// +// The requested order of object creation is not supported. +// +#define SCARD_E_ICC_CREATEORDER ((DWORD)0x80100021L) + +// +// MessageId: SCARD_E_UNSUPPORTED_FEATURE +// +// MessageText: +// +// This smart card does not support the requested feature. +// +#define SCARD_E_UNSUPPORTED_FEATURE ((DWORD)0x80100022L) + +// +// MessageId: SCARD_E_DIR_NOT_FOUND +// +// MessageText: +// +// The identified directory does not exist in the smart card. +// +#define SCARD_E_DIR_NOT_FOUND ((DWORD)0x80100023L) + +// +// MessageId: SCARD_E_FILE_NOT_FOUND +// +// MessageText: +// +// The identified file does not exist in the smart card. +// +#define SCARD_E_FILE_NOT_FOUND ((DWORD)0x80100024L) + +// +// MessageId: SCARD_E_NO_DIR +// +// MessageText: +// +// The supplied path does not represent a smart card directory. +// +#define SCARD_E_NO_DIR ((DWORD)0x80100025L) + +// +// MessageId: SCARD_E_NO_FILE +// +// MessageText: +// +// The supplied path does not represent a smart card file. +// +#define SCARD_E_NO_FILE ((DWORD)0x80100026L) + +// +// MessageId: SCARD_E_NO_ACCESS +// +// MessageText: +// +// Access is denied to this file. +// +#define SCARD_E_NO_ACCESS ((DWORD)0x80100027L) + +// +// MessageId: SCARD_E_WRITE_TOO_MANY +// +// MessageText: +// +// The smartcard does not have enough memory to store the information. +// +#define SCARD_E_WRITE_TOO_MANY ((DWORD)0x80100028L) + +// +// MessageId: SCARD_E_BAD_SEEK +// +// MessageText: +// +// There was an error trying to set the smart card file object pointer. +// +#define SCARD_E_BAD_SEEK ((DWORD)0x80100029L) + +// +// MessageId: SCARD_E_INVALID_CHV +// +// MessageText: +// +// The supplied PIN is incorrect. +// +#define SCARD_E_INVALID_CHV ((DWORD)0x8010002AL) + +// +// MessageId: SCARD_E_UNKNOWN_RES_MNG +// +// MessageText: +// +// An unrecognized error code was returned from a layered component. +// +#define SCARD_E_UNKNOWN_RES_MNG ((DWORD)0x8010002BL) + +// +// MessageId: SCARD_E_NO_SUCH_CERTIFICATE +// +// MessageText: +// +// The requested certificate does not exist. +// +#define SCARD_E_NO_SUCH_CERTIFICATE ((DWORD)0x8010002CL) + +// +// MessageId: SCARD_E_CERTIFICATE_UNAVAILABLE +// +// MessageText: +// +// The requested certificate could not be obtained. +// +#define SCARD_E_CERTIFICATE_UNAVAILABLE ((DWORD)0x8010002DL) + +// +// MessageId: SCARD_E_NO_READERS_AVAILABLE +// +// MessageText: +// +// Cannot find a smart card reader. +// +#define SCARD_E_NO_READERS_AVAILABLE ((DWORD)0x8010002EL) + +// +// MessageId: SCARD_E_COMM_DATA_LOST +// +// MessageText: +// +// A communications error with the smart card has been detected. Retry the operation. +// +#define SCARD_E_COMM_DATA_LOST ((DWORD)0x8010002FL) + +// +// MessageId: SCARD_E_NO_KEY_CONTAINER +// +// MessageText: +// +// The requested key container does not exist on the smart card. +// +#define SCARD_E_NO_KEY_CONTAINER ((DWORD)0x80100030L) + +// +// MessageId: SCARD_E_SERVER_TOO_BUSY +// +// MessageText: +// +// The Smart card resource manager is too busy to complete this operation. +// +#define SCARD_E_SERVER_TOO_BUSY ((DWORD)0x80100031L) + +// +// MessageId: SCARD_E_PIN_CACHE_EXPIRED +// +// MessageText: +// +// The smart card PIN cache has expired. +// +#define SCARD_E_PIN_CACHE_EXPIRED ((DWORD)0x80100032L) + +// +// MessageId: SCARD_E_NO_PIN_CACHE +// +// MessageText: +// +// The smart card PIN cannot be cached. +// +#define SCARD_E_NO_PIN_CACHE ((DWORD)0x80100033L) + +// +// MessageId: SCARD_E_READ_ONLY_CARD +// +// MessageText: +// +// The smart card is read only and cannot be written to. +// +#define SCARD_E_READ_ONLY_CARD ((DWORD)0x80100034L) + +// +// These are warning codes. +// +// +// MessageId: SCARD_W_UNSUPPORTED_CARD +// +// MessageText: +// +// The reader cannot communicate with the smart card, due to ATR configuration conflicts. +// +#define SCARD_W_UNSUPPORTED_CARD ((DWORD)0x80100065L) + +// +// MessageId: SCARD_W_UNRESPONSIVE_CARD +// +// MessageText: +// +// The smart card is not responding to a reset. +// +#define SCARD_W_UNRESPONSIVE_CARD ((DWORD)0x80100066L) + +// +// MessageId: SCARD_W_UNPOWERED_CARD +// +// MessageText: +// +// Power has been removed from the smart card, so that further communication is not possible. +// +#define SCARD_W_UNPOWERED_CARD ((DWORD)0x80100067L) + +// +// MessageId: SCARD_W_RESET_CARD +// +// MessageText: +// +// The smart card has been reset, so any shared state information is invalid. +// +#define SCARD_W_RESET_CARD ((DWORD)0x80100068L) + +// +// MessageId: SCARD_W_REMOVED_CARD +// +// MessageText: +// +// The smart card has been removed, so that further communication is not possible. +// +#define SCARD_W_REMOVED_CARD ((DWORD)0x80100069L) + +// +// MessageId: SCARD_W_SECURITY_VIOLATION +// +// MessageText: +// +// Access was denied because of a security violation. +// +#define SCARD_W_SECURITY_VIOLATION ((DWORD)0x8010006AL) + +// +// MessageId: SCARD_W_WRONG_CHV +// +// MessageText: +// +// The card cannot be accessed because the wrong PIN was presented. +// +#define SCARD_W_WRONG_CHV ((DWORD)0x8010006BL) + +// +// MessageId: SCARD_W_CHV_BLOCKED +// +// MessageText: +// +// The card cannot be accessed because the maximum number of PIN entry attempts has been reached. +// +#define SCARD_W_CHV_BLOCKED ((DWORD)0x8010006CL) + +// +// MessageId: SCARD_W_EOF +// +// MessageText: +// +// The end of the smart card file has been reached. +// +#define SCARD_W_EOF ((DWORD)0x8010006DL) + +// +// MessageId: SCARD_W_CANCELLED_BY_USER +// +// MessageText: +// +// The action was cancelled by the user. +// +#define SCARD_W_CANCELLED_BY_USER ((DWORD)0x8010006EL) + +// +// MessageId: SCARD_W_CARD_NOT_AUTHENTICATED +// +// MessageText: +// +// No PIN was presented to the smart card. +// +#define SCARD_W_CARD_NOT_AUTHENTICATED ((DWORD)0x8010006FL) + +// +// MessageId: SCARD_W_CACHE_ITEM_NOT_FOUND +// +// MessageText: +// +// The requested item could not be found in the cache. +// +#define SCARD_W_CACHE_ITEM_NOT_FOUND ((DWORD)0x80100070L) + +// +// MessageId: SCARD_W_CACHE_ITEM_STALE +// +// MessageText: +// +// The requested cache item is too old and was deleted from the cache. +// +#define SCARD_W_CACHE_ITEM_STALE ((DWORD)0x80100071L) + +// +// MessageId: SCARD_W_CACHE_ITEM_TOO_BIG +// +// MessageText: +// +// The new cache item exceeds the maximum per-item size defined for the cache. +// +#define SCARD_W_CACHE_ITEM_TOO_BIG ((DWORD)0x80100072L) + +#endif // SCARD_S_SUCCESS + Index: build/cackey_win32_build/include/pcsclite.h ================================================================== --- build/cackey_win32_build/include/pcsclite.h +++ build/cackey_win32_build/include/pcsclite.h @@ -1,2 +1,1 @@ -#define _WIN32_WINNT 0x500 #include ADDED build/cackey_win32_build/include/winscard.h Index: build/cackey_win32_build/include/winscard.h ================================================================== --- /dev/null +++ build/cackey_win32_build/include/winscard.h @@ -0,0 +1,1151 @@ +/*++ + +Copyright (c) 1996 Microsoft Corporation + +Module Name: + + WinSCard + +Abstract: + + This header file provides the definitions and symbols necessary for an + Application or Smart Card Service Provider to access the Smartcard + Subsystem. + +Environment: + + Win32 + +Notes: + +--*/ + +#ifndef _WINSCARD_H_ +#define _WINSCARD_H_ + +#if defined (_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + + +#include +#include +#include +#include "winsmcrd.h" +#ifndef SCARD_S_SUCCESS +#include "SCardErr.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + +#if 1 /* jkm */ +#ifndef __LPCGUID_DEFINED__ +#define __LPCGUID_DEFINED__ +typedef const GUID *LPCGUID; +#endif +#endif + +#ifndef _LPCBYTE_DEFINED +#define _LPCBYTE_DEFINED +typedef const BYTE *LPCBYTE; +#endif +#ifndef _LPCVOID_DEFINED +#define _LPCVOID_DEFINED +typedef const VOID *LPCVOID; +#endif + +#ifndef WINSCARDAPI +#define WINSCARDAPI +#endif +#ifndef WINSCARDDATA +#define WINSCARDDATA __declspec(dllimport) +#endif + +/* In clr:pure we cannot mark data export with dllimport. + * We should add small functions which returns the value of + * the global. + */ +#if !defined(_M_CEE_PURE) +static const SCARD_IO_REQUEST static_g_rgSCardT0Pci = { SCARD_PROTOCOL_T0, 8 }; +static const SCARD_IO_REQUEST static_g_rgSCardT1Pci = { SCARD_PROTOCOL_T1, 8 }; + +WINSCARDDATA extern const SCARD_IO_REQUEST + g_rgSCardT0Pci, + g_rgSCardT1Pci, + g_rgSCardRawPci; +#define SCARD_PCI_T0 (&static_g_rgSCardT0Pci) +#define SCARD_PCI_T1 (&static_g_rgSCardT1Pci) +#define SCARD_PCI_RAW (&g_rgSCardRawPci) +#endif + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Service Manager Access Services +// +// The following services are used to manage user and terminal contexts for +// Smart Cards. +// + +typedef ULONG_PTR SCARDCONTEXT; +typedef SCARDCONTEXT *PSCARDCONTEXT, *LPSCARDCONTEXT; + +typedef ULONG_PTR SCARDHANDLE; +typedef SCARDHANDLE *PSCARDHANDLE, *LPSCARDHANDLE; + +#define SCARD_AUTOALLOCATE (DWORD)(-1) + +#define SCARD_SCOPE_USER 0 // The context is a user context, and any + // database operations are performed within the + // domain of the user. +#define SCARD_SCOPE_TERMINAL 1 // The context is that of the current terminal, + // and any database operations are performed + // within the domain of that terminal. (The + // calling application must have appropriate + // access permissions for any database actions.) +#define SCARD_SCOPE_SYSTEM 2 // The context is the system context, and any + // database operations are performed within the + // domain of the system. (The calling + // application must have appropriate access + // permissions for any database actions.) + +extern WINSCARDAPI LONG WINAPI +SCardEstablishContext( + DWORD dwScope, + LPCVOID pvReserved1, + LPCVOID pvReserved2, + LPSCARDCONTEXT phContext); + +extern WINSCARDAPI LONG WINAPI +SCardReleaseContext( + SCARDCONTEXT hContext); + +extern WINSCARDAPI LONG WINAPI +SCardIsValidContext( + SCARDCONTEXT hContext); + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Smart Card Database Management Services +// +// The following services provide for managing the Smart Card Database. +// + +#define SCARD_ALL_READERS TEXT("SCard$AllReaders\000") +#define SCARD_DEFAULT_READERS TEXT("SCard$DefaultReaders\000") +#define SCARD_LOCAL_READERS TEXT("SCard$LocalReaders\000") +#define SCARD_SYSTEM_READERS TEXT("SCard$SystemReaders\000") + +#define SCARD_PROVIDER_PRIMARY 1 // Primary Provider Id +#define SCARD_PROVIDER_CSP 2 // Crypto Service Provider Id +#define SCARD_PROVIDER_KSP 3 // Key Storage Provider Id + + +// +// Database Reader routines +// + +extern WINSCARDAPI LONG WINAPI +SCardListReaderGroupsA( + SCARDCONTEXT hContext, + LPSTR mszGroups, + LPDWORD pcchGroups); +extern WINSCARDAPI LONG WINAPI +SCardListReaderGroupsW( + SCARDCONTEXT hContext, + LPWSTR mszGroups, + LPDWORD pcchGroups); +#ifdef UNICODE +#define SCardListReaderGroups SCardListReaderGroupsW +#else +#define SCardListReaderGroups SCardListReaderGroupsA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardListReadersA( + SCARDCONTEXT hContext, + LPCSTR mszGroups, + LPSTR mszReaders, + LPDWORD pcchReaders); +extern WINSCARDAPI LONG WINAPI +SCardListReadersW( + SCARDCONTEXT hContext, + LPCWSTR mszGroups, + LPWSTR mszReaders, + LPDWORD pcchReaders); +#ifdef UNICODE +#define SCardListReaders SCardListReadersW +#else +#define SCardListReaders SCardListReadersA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardListCardsA( + SCARDCONTEXT hContext, + LPCBYTE pbAtr, + LPCGUID rgquidInterfaces, + DWORD cguidInterfaceCount, + LPSTR mszCards, + LPDWORD pcchCards); +extern WINSCARDAPI LONG WINAPI +SCardListCardsW( + SCARDCONTEXT hContext, + LPCBYTE pbAtr, + LPCGUID rgquidInterfaces, + DWORD cguidInterfaceCount, + LPWSTR mszCards, + LPDWORD pcchCards); +#ifdef UNICODE +#define SCardListCards SCardListCardsW +#else +#define SCardListCards SCardListCardsA +#endif // !UNICODE +// +// NOTE: The routine SCardListCards name differs from the PC/SC definition. +// It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardListCardTypes( +// SCARDCONTEXT hContext, +// LPCBYTE pbAtr, +// LPCGUID rgquidInterfaces, +// DWORD cguidInterfaceCount, +// LPTSTR mszCards, +// out LPDWORD pcchCards); +// +// Here's a work-around MACRO: +#define SCardListCardTypes SCardListCards + +extern WINSCARDAPI LONG WINAPI +SCardListInterfacesA( + SCARDCONTEXT hContext, + LPCSTR szCard, + LPGUID pguidInterfaces, + LPDWORD pcguidInterfaces); +extern WINSCARDAPI LONG WINAPI +SCardListInterfacesW( + SCARDCONTEXT hContext, + LPCWSTR szCard, + LPGUID pguidInterfaces, + LPDWORD pcguidInterfaces); +#ifdef UNICODE +#define SCardListInterfaces SCardListInterfacesW +#else +#define SCardListInterfaces SCardListInterfacesA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardGetProviderIdA( + SCARDCONTEXT hContext, + LPCSTR szCard, + LPGUID pguidProviderId); +extern WINSCARDAPI LONG WINAPI +SCardGetProviderIdW( + SCARDCONTEXT hContext, + LPCWSTR szCard, + LPGUID pguidProviderId); +#ifdef UNICODE +#define SCardGetProviderId SCardGetProviderIdW +#else +#define SCardGetProviderId SCardGetProviderIdA +#endif // !UNICODE +// +// NOTE: The routine SCardGetProviderId in this implementation uses GUIDs. +// The PC/SC definition uses BYTEs. +// + +extern WINSCARDAPI LONG WINAPI +SCardGetCardTypeProviderNameA( + SCARDCONTEXT hContext, + LPCSTR szCardName, + DWORD dwProviderId, + LPSTR szProvider, + LPDWORD pcchProvider); +extern WINSCARDAPI LONG WINAPI +SCardGetCardTypeProviderNameW( + SCARDCONTEXT hContext, + LPCWSTR szCardName, + DWORD dwProviderId, + LPWSTR szProvider, + LPDWORD pcchProvider); +#ifdef UNICODE +#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameW +#else +#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameA +#endif // !UNICODE +// +// NOTE: This routine is an extension to the PC/SC definitions. +// + + +// +// Database Writer routines +// + +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderGroupA( + SCARDCONTEXT hContext, + LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderGroupW( + SCARDCONTEXT hContext, + LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupW +#else +#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderGroupA( + SCARDCONTEXT hContext, + LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderGroupW( + SCARDCONTEXT hContext, + LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardForgetReaderGroup SCardForgetReaderGroupW +#else +#define SCardForgetReaderGroup SCardForgetReaderGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderA( + SCARDCONTEXT hContext, + LPCSTR szReaderName, + LPCSTR szDeviceName); +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderW( + SCARDCONTEXT hContext, + LPCWSTR szReaderName, + LPCWSTR szDeviceName); +#ifdef UNICODE +#define SCardIntroduceReader SCardIntroduceReaderW +#else +#define SCardIntroduceReader SCardIntroduceReaderA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderA( + SCARDCONTEXT hContext, + LPCSTR szReaderName); +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderW( + SCARDCONTEXT hContext, + LPCWSTR szReaderName); +#ifdef UNICODE +#define SCardForgetReader SCardForgetReaderW +#else +#define SCardForgetReader SCardForgetReaderA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardAddReaderToGroupA( + SCARDCONTEXT hContext, + LPCSTR szReaderName, + LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardAddReaderToGroupW( + SCARDCONTEXT hContext, + LPCWSTR szReaderName, + LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardAddReaderToGroup SCardAddReaderToGroupW +#else +#define SCardAddReaderToGroup SCardAddReaderToGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardRemoveReaderFromGroupA( + SCARDCONTEXT hContext, + LPCSTR szReaderName, + LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardRemoveReaderFromGroupW( + SCARDCONTEXT hContext, + LPCWSTR szReaderName, + LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupW +#else +#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardIntroduceCardTypeA( + SCARDCONTEXT hContext, + LPCSTR szCardName, + LPCGUID pguidPrimaryProvider, + LPCGUID rgguidInterfaces, + DWORD dwInterfaceCount, + LPCBYTE pbAtr, + LPCBYTE pbAtrMask, + DWORD cbAtrLen); +extern WINSCARDAPI LONG WINAPI +SCardIntroduceCardTypeW( + SCARDCONTEXT hContext, + LPCWSTR szCardName, + LPCGUID pguidPrimaryProvider, + LPCGUID rgguidInterfaces, + DWORD dwInterfaceCount, + LPCBYTE pbAtr, + LPCBYTE pbAtrMask, + DWORD cbAtrLen); +#ifdef UNICODE +#define SCardIntroduceCardType SCardIntroduceCardTypeW +#else +#define SCardIntroduceCardType SCardIntroduceCardTypeA +#endif // !UNICODE +// +// NOTE: The routine SCardIntroduceCardType's parameters' order differs from +// the PC/SC definition. It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardIntroduceCardType( +// SCARDCONTEXT hContext, +// LPCTSTR szCardName, +// LPCBYTE pbAtr, +// LPCBYTE pbAtrMask, +// DWORD cbAtrLen, +// LPCGUID pguidPrimaryProvider, +// LPCGUID rgguidInterfaces, +// DWORD dwInterfaceCount); +// +// Here's a work-around MACRO: +#define PCSCardIntroduceCardType(hContext, szCardName, pbAtr, pbAtrMask, cbAtrLen, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount) \ + SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen) + +extern WINSCARDAPI LONG WINAPI +SCardSetCardTypeProviderNameA( + SCARDCONTEXT hContext, + LPCSTR szCardName, + DWORD dwProviderId, + LPCSTR szProvider); +extern WINSCARDAPI LONG WINAPI +SCardSetCardTypeProviderNameW( + SCARDCONTEXT hContext, + LPCWSTR szCardName, + DWORD dwProviderId, + LPCWSTR szProvider); +#ifdef UNICODE +#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameW +#else +#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameA +#endif // !UNICODE +// +// NOTE: This routine is an extention to the PC/SC specifications. +// + +extern WINSCARDAPI LONG WINAPI +SCardForgetCardTypeA( + SCARDCONTEXT hContext, + LPCSTR szCardName); +extern WINSCARDAPI LONG WINAPI +SCardForgetCardTypeW( + SCARDCONTEXT hContext, + LPCWSTR szCardName); +#ifdef UNICODE +#define SCardForgetCardType SCardForgetCardTypeW +#else +#define SCardForgetCardType SCardForgetCardTypeA +#endif // !UNICODE + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Service Manager Support Routines +// +// The following services are supplied to simplify the use of the Service +// Manager API. +// + +extern WINSCARDAPI LONG WINAPI +SCardFreeMemory( + SCARDCONTEXT hContext, + LPCVOID pvMem); + +#if (NTDDI_VERSION >= NTDDI_WINXP) +extern WINSCARDAPI HANDLE WINAPI +SCardAccessStartedEvent(void); + +extern WINSCARDAPI void WINAPI +SCardReleaseStartedEvent(void); +#endif // (NTDDI_VERSION >= NTDDI_WINXP) + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Reader Services +// +// The following services supply means for tracking cards within readers. +// + +typedef struct { + LPCSTR szReader; // reader name + LPVOID pvUserData; // user defined data + DWORD dwCurrentState; // current state of reader at time of call + DWORD dwEventState; // state of reader after state change + DWORD cbAtr; // Number of bytes in the returned ATR. + BYTE rgbAtr[36]; // Atr of inserted card, (extra alignment bytes) +} SCARD_READERSTATEA, *PSCARD_READERSTATEA, *LPSCARD_READERSTATEA; +typedef struct { + LPCWSTR szReader; // reader name + LPVOID pvUserData; // user defined data + DWORD dwCurrentState; // current state of reader at time of call + DWORD dwEventState; // state of reader after state change + DWORD cbAtr; // Number of bytes in the returned ATR. + BYTE rgbAtr[36]; // Atr of inserted card, (extra alignment bytes) +} SCARD_READERSTATEW, *PSCARD_READERSTATEW, *LPSCARD_READERSTATEW; +#ifdef UNICODE +typedef SCARD_READERSTATEW SCARD_READERSTATE; +typedef PSCARD_READERSTATEW PSCARD_READERSTATE; +typedef LPSCARD_READERSTATEW LPSCARD_READERSTATE; +#else +typedef SCARD_READERSTATEA SCARD_READERSTATE; +typedef PSCARD_READERSTATEA PSCARD_READERSTATE; +typedef LPSCARD_READERSTATEA LPSCARD_READERSTATE; +#endif // UNICODE + +// Backwards compatibility macros +#define SCARD_READERSTATE_A SCARD_READERSTATEA +#define SCARD_READERSTATE_W SCARD_READERSTATEW +#define PSCARD_READERSTATE_A PSCARD_READERSTATEA +#define PSCARD_READERSTATE_W PSCARD_READERSTATEW +#define LPSCARD_READERSTATE_A LPSCARD_READERSTATEA +#define LPSCARD_READERSTATE_W LPSCARD_READERSTATEW + +#define SCARD_STATE_UNAWARE 0x00000000 // The application is unaware of the + // current state, and would like to + // know. The use of this value + // results in an immediate return + // from state transition monitoring + // services. This is represented by + // all bits set to zero. +#define SCARD_STATE_IGNORE 0x00000001 // The application requested that + // this reader be ignored. No other + // bits will be set. +#define SCARD_STATE_CHANGED 0x00000002 // This implies that there is a + // difference between the state + // believed by the application, and + // the state known by the Service + // Manager. When this bit is set, + // the application may assume a + // significant state change has + // occurred on this reader. +#define SCARD_STATE_UNKNOWN 0x00000004 // This implies that the given + // reader name is not recognized by + // the Service Manager. If this bit + // is set, then SCARD_STATE_CHANGED + // and SCARD_STATE_IGNORE will also + // be set. +#define SCARD_STATE_UNAVAILABLE 0x00000008 // This implies that the actual + // state of this reader is not + // available. If this bit is set, + // then all the following bits are + // clear. +#define SCARD_STATE_EMPTY 0x00000010 // This implies that there is not + // card in the reader. If this bit + // is set, all the following bits + // will be clear. +#define SCARD_STATE_PRESENT 0x00000020 // This implies that there is a card + // in the reader. +#define SCARD_STATE_ATRMATCH 0x00000040 // This implies that there is a card + // in the reader with an ATR + // matching one of the target cards. + // If this bit is set, + // SCARD_STATE_PRESENT will also be + // set. This bit is only returned + // on the SCardLocateCard() service. +#define SCARD_STATE_EXCLUSIVE 0x00000080 // This implies that the card in the + // reader is allocated for exclusive + // use by another application. If + // this bit is set, + // SCARD_STATE_PRESENT will also be + // set. +#define SCARD_STATE_INUSE 0x00000100 // This implies that the card in the + // reader is in use by one or more + // other applications, but may be + // connected to in shared mode. If + // this bit is set, + // SCARD_STATE_PRESENT will also be + // set. +#define SCARD_STATE_MUTE 0x00000200 // This implies that the card in the + // reader is unresponsive or not + // supported by the reader or + // software. +#define SCARD_STATE_UNPOWERED 0x00000400 // This implies that the card in the + // reader has not been powered up. + +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsA( + SCARDCONTEXT hContext, + LPCSTR mszCards, + LPSCARD_READERSTATEA rgReaderStates, + DWORD cReaders); +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsW( + SCARDCONTEXT hContext, + LPCWSTR mszCards, + LPSCARD_READERSTATEW rgReaderStates, + DWORD cReaders); +#ifdef UNICODE +#define SCardLocateCards SCardLocateCardsW +#else +#define SCardLocateCards SCardLocateCardsA +#endif // !UNICODE + +#if (NTDDI_VERSION >= NTDDI_WINXP) +typedef struct _SCARD_ATRMASK { + DWORD cbAtr; // Number of bytes in the ATR and the mask. + BYTE rgbAtr[36]; // Atr of card (extra alignment bytes) + BYTE rgbMask[36]; // Mask for the Atr (extra alignment bytes) +} SCARD_ATRMASK, *PSCARD_ATRMASK, *LPSCARD_ATRMASK; + + +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsByATRA( + SCARDCONTEXT hContext, + LPSCARD_ATRMASK rgAtrMasks, + DWORD cAtrs, + LPSCARD_READERSTATEA rgReaderStates, + DWORD cReaders); +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsByATRW( + SCARDCONTEXT hContext, + LPSCARD_ATRMASK rgAtrMasks, + DWORD cAtrs, + LPSCARD_READERSTATEW rgReaderStates, + DWORD cReaders); +#ifdef UNICODE +#define SCardLocateCardsByATR SCardLocateCardsByATRW +#else +#define SCardLocateCardsByATR SCardLocateCardsByATRA +#endif // !UNICODE +#endif // (NTDDI_VERSION >= NTDDI_WINXP) + +extern WINSCARDAPI LONG WINAPI +SCardGetStatusChangeA( + SCARDCONTEXT hContext, + DWORD dwTimeout, + LPSCARD_READERSTATEA rgReaderStates, + DWORD cReaders); +extern WINSCARDAPI LONG WINAPI +SCardGetStatusChangeW( + SCARDCONTEXT hContext, + DWORD dwTimeout, + LPSCARD_READERSTATEW rgReaderStates, + DWORD cReaders); +#ifdef UNICODE +#define SCardGetStatusChange SCardGetStatusChangeW +#else +#define SCardGetStatusChange SCardGetStatusChangeA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardCancel( + SCARDCONTEXT hContext); + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Card/Reader Communication Services +// +// The following services provide means for communication with the card. +// + +#define SCARD_SHARE_EXCLUSIVE 1 // This application is not willing to share this + // card with other applications. +#define SCARD_SHARE_SHARED 2 // This application is willing to share this + // card with other applications. +#define SCARD_SHARE_DIRECT 3 // This application demands direct control of + // the reader, so it is not available to other + // applications. + +#define SCARD_LEAVE_CARD 0 // Don't do anything special on close +#define SCARD_RESET_CARD 1 // Reset the card on close +#define SCARD_UNPOWER_CARD 2 // Power down the card on close +#define SCARD_EJECT_CARD 3 // Eject the card on close + +extern WINSCARDAPI LONG WINAPI +SCardConnectA( + SCARDCONTEXT hContext, + LPCSTR szReader, + DWORD dwShareMode, + DWORD dwPreferredProtocols, + LPSCARDHANDLE phCard, + LPDWORD pdwActiveProtocol); +extern WINSCARDAPI LONG WINAPI +SCardConnectW( + SCARDCONTEXT hContext, + LPCWSTR szReader, + DWORD dwShareMode, + DWORD dwPreferredProtocols, + LPSCARDHANDLE phCard, + LPDWORD pdwActiveProtocol); +#ifdef UNICODE +#define SCardConnect SCardConnectW +#else +#define SCardConnect SCardConnectA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardReconnect( + SCARDHANDLE hCard, + DWORD dwShareMode, + DWORD dwPreferredProtocols, + DWORD dwInitialization, + LPDWORD pdwActiveProtocol); + +extern WINSCARDAPI LONG WINAPI +SCardDisconnect( + SCARDHANDLE hCard, + DWORD dwDisposition); + +extern WINSCARDAPI LONG WINAPI +SCardBeginTransaction( + SCARDHANDLE hCard); + +extern WINSCARDAPI LONG WINAPI +SCardEndTransaction( + SCARDHANDLE hCard, + DWORD dwDisposition); + +extern WINSCARDAPI LONG WINAPI +SCardCancelTransaction( + SCARDHANDLE hCard); +// +// NOTE: This call corresponds to the PC/SC SCARDCOMM::Cancel routine, +// terminating a blocked SCardBeginTransaction service. +// + + +extern WINSCARDAPI LONG WINAPI +SCardState( + SCARDHANDLE hCard, + LPDWORD pdwState, + LPDWORD pdwProtocol, + LPBYTE pbAtr, + LPDWORD pcbAtrLen); +// +// NOTE: SCardState is an obsolete routine. PC/SC has replaced it with +// SCardStatus. +// + +extern WINSCARDAPI LONG WINAPI +SCardStatusA( + SCARDHANDLE hCard, + LPSTR mszReaderNames, + LPDWORD pcchReaderLen, + LPDWORD pdwState, + LPDWORD pdwProtocol, + LPBYTE pbAtr, + LPDWORD pcbAtrLen); +extern WINSCARDAPI LONG WINAPI +SCardStatusW( + SCARDHANDLE hCard, + LPWSTR mszReaderNames, + LPDWORD pcchReaderLen, + LPDWORD pdwState, + LPDWORD pdwProtocol, + LPBYTE pbAtr, + LPDWORD pcbAtrLen); +#ifdef UNICODE +#define SCardStatus SCardStatusW +#else +#define SCardStatus SCardStatusA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardTransmit( + SCARDHANDLE hCard, + LPCSCARD_IO_REQUEST pioSendPci, + LPCBYTE pbSendBuffer, + DWORD cbSendLength, + LPSCARD_IO_REQUEST pioRecvPci, + LPBYTE pbRecvBuffer, + LPDWORD pcbRecvLength); + +#if (NTDDI_VERSION >= NTDDI_VISTA) +extern WINSCARDAPI LONG WINAPI +SCardGetTransmitCount( + SCARDHANDLE hCard, + LPDWORD pcTransmitCount); +#endif // (NTDDI_VERSION >= NTDDI_VISTA) + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Reader Control Routines +// +// The following services provide for direct, low-level manipulation of the +// reader by the calling application allowing it control over the +// attributes of the communications with the card. +// + +extern WINSCARDAPI LONG WINAPI +SCardControl( + SCARDHANDLE hCard, + DWORD dwControlCode, + LPCVOID lpInBuffer, + DWORD cbInBufferSize, + LPVOID lpOutBuffer, + DWORD cbOutBufferSize, + LPDWORD lpBytesReturned); + +extern WINSCARDAPI LONG WINAPI +SCardGetAttrib( + SCARDHANDLE hCard, + DWORD dwAttrId, + LPBYTE pbAttr, + LPDWORD pcbAttrLen); +// +// NOTE: The routine SCardGetAttrib's name differs from the PC/SC definition. +// It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardGetReaderCapabilities( +// SCARDHANDLE hCard, +// DWORD dwTag, +// LPBYTE pbAttr, +// out LPDWORD pcbAttrLen); +// +// Here's a work-around MACRO: +#define SCardGetReaderCapabilities SCardGetAttrib + +extern WINSCARDAPI LONG WINAPI +SCardSetAttrib( + SCARDHANDLE hCard, + DWORD dwAttrId, + LPCBYTE pbAttr, + DWORD cbAttrLen); +// +// NOTE: The routine SCardSetAttrib's name differs from the PC/SC definition. +// It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardSetReaderCapabilities( +// SCARDHANDLE hCard, +// DWORD dwTag, +// LPCBYTE pbAttr, +// DWORD cbAttrLen); +// +// Here's a work-around MACRO: +#define SCardSetReaderCapabilities SCardSetAttrib + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Smart Card Dialog definitions +// +// The following section contains structures and exported function +// declarations for the Smart Card Common Dialog dialog. +// + +// Defined constants +// Flags +#define SC_DLG_MINIMAL_UI 0x01 +#define SC_DLG_NO_UI 0x02 +#define SC_DLG_FORCE_UI 0x04 + +#define SCERR_NOCARDNAME 0x4000 +#define SCERR_NOGUIDS 0x8000 + +typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCA) ( SCARDCONTEXT, LPSTR, LPSTR, PVOID); +typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCW) ( SCARDCONTEXT, LPWSTR, LPWSTR, PVOID); +#ifdef UNICODE +#define LPOCNCONNPROC LPOCNCONNPROCW +#else +#define LPOCNCONNPROC LPOCNCONNPROCA +#endif // !UNICODE +typedef BOOL (WINAPI *LPOCNCHKPROC) ( SCARDCONTEXT, SCARDHANDLE, PVOID); +typedef void (WINAPI *LPOCNDSCPROC) ( SCARDCONTEXT, SCARDHANDLE, PVOID); + + +// +// OPENCARD_SEARCH_CRITERIA: In order to specify a user-extended search, +// lpfnCheck must not be NULL. Moreover, the connection to be made to the +// card before performing the callback must be indicated by either providing +// lpfnConnect and lpfnDisconnect OR by setting dwShareMode. +// If both the connection callbacks and dwShareMode are non-NULL, the callbacks +// will be used. +// + +typedef struct { + DWORD dwStructSize; + LPSTR lpstrGroupNames; // OPTIONAL reader groups to include in + DWORD nMaxGroupNames; // search. NULL defaults to + // SCard$DefaultReaders + LPCGUID rgguidInterfaces; // OPTIONAL requested interfaces + DWORD cguidInterfaces; // supported by card's SSP + LPSTR lpstrCardNames; // OPTIONAL requested card names; all cards w/ + DWORD nMaxCardNames; // matching ATRs will be accepted + LPOCNCHKPROC lpfnCheck; // OPTIONAL if NULL no user check will be performed. + LPOCNCONNPROCA lpfnConnect; // OPTIONAL if lpfnConnect is provided, + LPOCNDSCPROC lpfnDisconnect; // lpfnDisconnect must also be set. + LPVOID pvUserData; // OPTIONAL parameter to callbacks + DWORD dwShareMode; // OPTIONAL must be set if lpfnCheck is not null + DWORD dwPreferredProtocols; // OPTIONAL +} OPENCARD_SEARCH_CRITERIAA, *POPENCARD_SEARCH_CRITERIAA, *LPOPENCARD_SEARCH_CRITERIAA; +typedef struct { + DWORD dwStructSize; + LPWSTR lpstrGroupNames; // OPTIONAL reader groups to include in + DWORD nMaxGroupNames; // search. NULL defaults to + // SCard$DefaultReaders + LPCGUID rgguidInterfaces; // OPTIONAL requested interfaces + DWORD cguidInterfaces; // supported by card's SSP + LPWSTR lpstrCardNames; // OPTIONAL requested card names; all cards w/ + DWORD nMaxCardNames; // matching ATRs will be accepted + LPOCNCHKPROC lpfnCheck; // OPTIONAL if NULL no user check will be performed. + LPOCNCONNPROCW lpfnConnect; // OPTIONAL if lpfnConnect is provided, + LPOCNDSCPROC lpfnDisconnect; // lpfnDisconnect must also be set. + LPVOID pvUserData; // OPTIONAL parameter to callbacks + DWORD dwShareMode; // OPTIONAL must be set if lpfnCheck is not null + DWORD dwPreferredProtocols; // OPTIONAL +} OPENCARD_SEARCH_CRITERIAW, *POPENCARD_SEARCH_CRITERIAW, *LPOPENCARD_SEARCH_CRITERIAW; +#ifdef UNICODE +typedef OPENCARD_SEARCH_CRITERIAW OPENCARD_SEARCH_CRITERIA; +typedef POPENCARD_SEARCH_CRITERIAW POPENCARD_SEARCH_CRITERIA; +typedef LPOPENCARD_SEARCH_CRITERIAW LPOPENCARD_SEARCH_CRITERIA; +#else +typedef OPENCARD_SEARCH_CRITERIAA OPENCARD_SEARCH_CRITERIA; +typedef POPENCARD_SEARCH_CRITERIAA POPENCARD_SEARCH_CRITERIA; +typedef LPOPENCARD_SEARCH_CRITERIAA LPOPENCARD_SEARCH_CRITERIA; +#endif // UNICODE + + +// +// OPENCARDNAME_EX: used by SCardUIDlgSelectCard; replaces obsolete OPENCARDNAME +// + +typedef struct { + DWORD dwStructSize; // REQUIRED + SCARDCONTEXT hSCardContext; // REQUIRED + HWND hwndOwner; // OPTIONAL + DWORD dwFlags; // OPTIONAL -- default is SC_DLG_MINIMAL_UI + LPCSTR lpstrTitle; // OPTIONAL + LPCSTR lpstrSearchDesc; // OPTIONAL (eg. "Please insert your smart card.") + HICON hIcon; // OPTIONAL 32x32 icon for your brand insignia + POPENCARD_SEARCH_CRITERIAA pOpenCardSearchCriteria; // OPTIONAL + LPOCNCONNPROCA lpfnConnect; // OPTIONAL - performed on successful selection + LPVOID pvUserData; // OPTIONAL parameter to lpfnConnect + DWORD dwShareMode; // OPTIONAL - if lpfnConnect is NULL, dwShareMode and + DWORD dwPreferredProtocols; // OPTIONAL dwPreferredProtocols will be used to + // connect to the selected card + LPSTR lpstrRdr; // REQUIRED [IN|OUT] Name of selected reader + DWORD nMaxRdr; // REQUIRED [IN|OUT] + LPSTR lpstrCard; // REQUIRED [IN|OUT] Name of selected card + DWORD nMaxCard; // REQUIRED [IN|OUT] + DWORD dwActiveProtocol; // [OUT] set only if dwShareMode not NULL + SCARDHANDLE hCardHandle; // [OUT] set if a card connection was indicated +} OPENCARDNAME_EXA, *POPENCARDNAME_EXA, *LPOPENCARDNAME_EXA; +typedef struct { + DWORD dwStructSize; // REQUIRED + SCARDCONTEXT hSCardContext; // REQUIRED + HWND hwndOwner; // OPTIONAL + DWORD dwFlags; // OPTIONAL -- default is SC_DLG_MINIMAL_UI + LPCWSTR lpstrTitle; // OPTIONAL + LPCWSTR lpstrSearchDesc; // OPTIONAL (eg. "Please insert your smart card.") + HICON hIcon; // OPTIONAL 32x32 icon for your brand insignia + POPENCARD_SEARCH_CRITERIAW pOpenCardSearchCriteria; // OPTIONAL + LPOCNCONNPROCW lpfnConnect; // OPTIONAL - performed on successful selection + LPVOID pvUserData; // OPTIONAL parameter to lpfnConnect + DWORD dwShareMode; // OPTIONAL - if lpfnConnect is NULL, dwShareMode and + DWORD dwPreferredProtocols; // OPTIONAL dwPreferredProtocols will be used to + // connect to the selected card + LPWSTR lpstrRdr; // REQUIRED [IN|OUT] Name of selected reader + DWORD nMaxRdr; // REQUIRED [IN|OUT] + LPWSTR lpstrCard; // REQUIRED [IN|OUT] Name of selected card + DWORD nMaxCard; // REQUIRED [IN|OUT] + DWORD dwActiveProtocol; // [OUT] set only if dwShareMode not NULL + SCARDHANDLE hCardHandle; // [OUT] set if a card connection was indicated +} OPENCARDNAME_EXW, *POPENCARDNAME_EXW, *LPOPENCARDNAME_EXW; +#ifdef UNICODE +typedef OPENCARDNAME_EXW OPENCARDNAME_EX; +typedef POPENCARDNAME_EXW POPENCARDNAME_EX; +typedef LPOPENCARDNAME_EXW LPOPENCARDNAME_EX; +#else +typedef OPENCARDNAME_EXA OPENCARDNAME_EX; +typedef POPENCARDNAME_EXA POPENCARDNAME_EX; +typedef LPOPENCARDNAME_EXA LPOPENCARDNAME_EX; +#endif // UNICODE + +#define OPENCARDNAMEA_EX OPENCARDNAME_EXA +#define OPENCARDNAMEW_EX OPENCARDNAME_EXW +#define POPENCARDNAMEA_EX POPENCARDNAME_EXA +#define POPENCARDNAMEW_EX POPENCARDNAME_EXW +#define LPOPENCARDNAMEA_EX LPOPENCARDNAME_EXA +#define LPOPENCARDNAMEW_EX LPOPENCARDNAME_EXW + + +// +// SCardUIDlgSelectCard replaces GetOpenCardName +// + +extern WINSCARDAPI LONG WINAPI +SCardUIDlgSelectCardA( + LPOPENCARDNAMEA_EX); +extern WINSCARDAPI LONG WINAPI +SCardUIDlgSelectCardW( + LPOPENCARDNAMEW_EX); +#ifdef UNICODE +#define SCardUIDlgSelectCard SCardUIDlgSelectCardW +#else +#define SCardUIDlgSelectCard SCardUIDlgSelectCardA +#endif // !UNICODE + + +// +// "Smart Card Common Dialog" definitions for backwards compatibility +// with the Smart Card Base Services SDK version 1.0 +// + +typedef struct { + DWORD dwStructSize; + HWND hwndOwner; + SCARDCONTEXT hSCardContext; + LPSTR lpstrGroupNames; + DWORD nMaxGroupNames; + LPSTR lpstrCardNames; + DWORD nMaxCardNames; + LPCGUID rgguidInterfaces; + DWORD cguidInterfaces; + LPSTR lpstrRdr; + DWORD nMaxRdr; + LPSTR lpstrCard; + DWORD nMaxCard; + LPCSTR lpstrTitle; + DWORD dwFlags; + LPVOID pvUserData; + DWORD dwShareMode; + DWORD dwPreferredProtocols; + DWORD dwActiveProtocol; + LPOCNCONNPROCA lpfnConnect; + LPOCNCHKPROC lpfnCheck; + LPOCNDSCPROC lpfnDisconnect; + SCARDHANDLE hCardHandle; +} OPENCARDNAMEA, *POPENCARDNAMEA, *LPOPENCARDNAMEA; +typedef struct { + DWORD dwStructSize; + HWND hwndOwner; + SCARDCONTEXT hSCardContext; + LPWSTR lpstrGroupNames; + DWORD nMaxGroupNames; + LPWSTR lpstrCardNames; + DWORD nMaxCardNames; + LPCGUID rgguidInterfaces; + DWORD cguidInterfaces; + LPWSTR lpstrRdr; + DWORD nMaxRdr; + LPWSTR lpstrCard; + DWORD nMaxCard; + LPCWSTR lpstrTitle; + DWORD dwFlags; + LPVOID pvUserData; + DWORD dwShareMode; + DWORD dwPreferredProtocols; + DWORD dwActiveProtocol; + LPOCNCONNPROCW lpfnConnect; + LPOCNCHKPROC lpfnCheck; + LPOCNDSCPROC lpfnDisconnect; + SCARDHANDLE hCardHandle; +} OPENCARDNAMEW, *POPENCARDNAMEW, *LPOPENCARDNAMEW; +#ifdef UNICODE +typedef OPENCARDNAMEW OPENCARDNAME; +typedef POPENCARDNAMEW POPENCARDNAME; +typedef LPOPENCARDNAMEW LPOPENCARDNAME; +#else +typedef OPENCARDNAMEA OPENCARDNAME; +typedef POPENCARDNAMEA POPENCARDNAME; +typedef LPOPENCARDNAMEA LPOPENCARDNAME; +#endif // UNICODE + +// Backwards compatibility macros +#define OPENCARDNAME_A OPENCARDNAMEA +#define OPENCARDNAME_W OPENCARDNAMEW +#define POPENCARDNAME_A POPENCARDNAMEA +#define POPENCARDNAME_W POPENCARDNAMEW +#define LPOPENCARDNAME_A LPOPENCARDNAMEA +#define LPOPENCARDNAME_W LPOPENCARDNAMEW + +extern WINSCARDAPI LONG WINAPI +GetOpenCardNameA( + LPOPENCARDNAMEA); +extern WINSCARDAPI LONG WINAPI +GetOpenCardNameW( + LPOPENCARDNAMEW); +#ifdef UNICODE +#define GetOpenCardName GetOpenCardNameW +#else +#define GetOpenCardName GetOpenCardNameA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardDlgExtendedError (void); + +#if (NTDDI_VERSION >= NTDDI_VISTA) + +// +// Smartcard Caching API +// + +extern WINSCARDAPI LONG WINAPI +SCardReadCacheA( + SCARDCONTEXT hContext, + UUID *CardIdentifier, + DWORD FreshnessCounter, + LPSTR LookupName, + PBYTE Data, + DWORD *DataLen); +extern WINSCARDAPI LONG WINAPI +SCardReadCacheW( + SCARDCONTEXT hContext, + UUID *CardIdentifier, + DWORD FreshnessCounter, + LPWSTR LookupName, + PBYTE Data, + DWORD *DataLen); +#ifdef UNICODE +#define SCardReadCache SCardReadCacheW +#else +#define SCardReadCache SCardReadCacheA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardWriteCacheA( + SCARDCONTEXT hContext, + UUID *CardIdentifier, + DWORD FreshnessCounter, + LPSTR LookupName, + PBYTE Data, + DWORD DataLen); +extern WINSCARDAPI LONG WINAPI +SCardWriteCacheW( + SCARDCONTEXT hContext, + UUID *CardIdentifier, + DWORD FreshnessCounter, + LPWSTR LookupName, + PBYTE Data, + DWORD DataLen); +#ifdef UNICODE +#define SCardWriteCache SCardWriteCacheW +#else +#define SCardWriteCache SCardWriteCacheA +#endif // !UNICODE + +#endif // (NTDDI_VERSION >= NTDDI_VISTA) + +#ifdef __cplusplus +} +#endif +#endif // _WINSCARD_H_ + + ADDED build/cackey_win32_build/include/winsmcrd.h Index: build/cackey_win32_build/include/winsmcrd.h ================================================================== --- /dev/null +++ build/cackey_win32_build/include/winsmcrd.h @@ -0,0 +1,333 @@ +/*++ + +Copyright (c) 1996 Microsoft Corporation + +Module Name: + + winsmcrd.h + +Abstract: + Smart Card class/port IOCTL codes. This file is required for all code + user mode and kernel mode, using Smart Card IOCTL's, defines, + data structures + +Revision History: + +--*/ + + +#ifndef _NTDDSCRD_H2_ +#define _NTDDSCRD_H2_ + +#if defined (_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _WINSCARD_H_ +typedef DWORD ULONG; +typedef WORD UWORD; +typedef BYTE UCHAR; +#else +typedef ULONG DWORD; +// typedef UWORD WORD; +typedef UCHAR BYTE; +#endif + +#ifndef DEVICE_TYPE_SMARTCARD +#ifndef FILE_DEVICE_SMARTCARD +#define FILE_DEVICE_SMARTCARD 0x00000031 +#endif +#else +#if 0x00000031 != FILE_DEVICE_SMARTCARD +#error "Incorrect Smart Card Device Definition" +#endif +#endif + + +// +// Various constants +// + +#define SCARD_ATR_LENGTH 33 // ISO 7816-3 spec. + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Protocol Flag definitions +// + +#define SCARD_PROTOCOL_UNDEFINED 0x00000000 // There is no active protocol. +#define SCARD_PROTOCOL_T0 0x00000001 // T=0 is the active protocol. +#define SCARD_PROTOCOL_T1 0x00000002 // T=1 is the active protocol. +#define SCARD_PROTOCOL_RAW 0x00010000 // Raw is the active protocol. +// +// This is the mask of ISO defined transmission protocols +// +#define SCARD_PROTOCOL_Tx (SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1) +// +// Use the default transmission parameters / card clock freq. +// +#define SCARD_PROTOCOL_DEFAULT 0x80000000 +// +// Use optimal transmission parameters / card clock freq. +// Since using the optimal parameters is the default case no bit is defined to be 1 +// +#define SCARD_PROTOCOL_OPTIMAL 0x00000000 + + +// +// Ioctl parameters 1 for IOCTL_SMARTCARD_POWER +// +#define SCARD_POWER_DOWN 0 // Power down the card. +#define SCARD_COLD_RESET 1 // Cycle power and reset the card. +#define SCARD_WARM_RESET 2 // Force a reset on the card. + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Reader Action IOCTLs +// + +#define SCARD_CTL_CODE(code) CTL_CODE(FILE_DEVICE_SMARTCARD, \ + (code), \ + METHOD_BUFFERED, \ + FILE_ANY_ACCESS) + +#define IOCTL_SMARTCARD_POWER SCARD_CTL_CODE( 1) +#define IOCTL_SMARTCARD_GET_ATTRIBUTE SCARD_CTL_CODE( 2) +#define IOCTL_SMARTCARD_SET_ATTRIBUTE SCARD_CTL_CODE( 3) +#define IOCTL_SMARTCARD_CONFISCATE SCARD_CTL_CODE( 4) +#define IOCTL_SMARTCARD_TRANSMIT SCARD_CTL_CODE( 5) +#define IOCTL_SMARTCARD_EJECT SCARD_CTL_CODE( 6) +#define IOCTL_SMARTCARD_SWALLOW SCARD_CTL_CODE( 7) +// #define IOCTL_SMARTCARD_READ SCARD_CTL_CODE( 8) obsolete +// #define IOCTL_SMARTCARD_WRITE SCARD_CTL_CODE( 9) obsolete +#define IOCTL_SMARTCARD_IS_PRESENT SCARD_CTL_CODE(10) +#define IOCTL_SMARTCARD_IS_ABSENT SCARD_CTL_CODE(11) +#define IOCTL_SMARTCARD_SET_PROTOCOL SCARD_CTL_CODE(12) +#define IOCTL_SMARTCARD_GET_STATE SCARD_CTL_CODE(14) +#define IOCTL_SMARTCARD_GET_LAST_ERROR SCARD_CTL_CODE(15) +#define IOCTL_SMARTCARD_GET_PERF_CNTR SCARD_CTL_CODE(16) + + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Tags for requesting card and reader attributes +// + +#define MAXIMUM_ATTR_STRING_LENGTH 32 // Nothing bigger than this from getAttr +#define MAXIMUM_SMARTCARD_READERS 10 // Limit the readers on the system + +#define SCARD_ATTR_VALUE(Class, Tag) ((((ULONG)(Class)) << 16) | ((ULONG)(Tag))) + +#define SCARD_CLASS_VENDOR_INFO 1 // Vendor information definitions +#define SCARD_CLASS_COMMUNICATIONS 2 // Communication definitions +#define SCARD_CLASS_PROTOCOL 3 // Protocol definitions +#define SCARD_CLASS_POWER_MGMT 4 // Power Management definitions +#define SCARD_CLASS_SECURITY 5 // Security Assurance definitions +#define SCARD_CLASS_MECHANICAL 6 // Mechanical characteristic definitions +#define SCARD_CLASS_VENDOR_DEFINED 7 // Vendor specific definitions +#define SCARD_CLASS_IFD_PROTOCOL 8 // Interface Device Protocol options +#define SCARD_CLASS_ICC_STATE 9 // ICC State specific definitions +#define SCARD_CLASS_PERF 0x7ffe // performace counters +#define SCARD_CLASS_SYSTEM 0x7fff // System-specific definitions + +#define SCARD_ATTR_VENDOR_NAME SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0100) +#define SCARD_ATTR_VENDOR_IFD_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0101) +#define SCARD_ATTR_VENDOR_IFD_VERSION SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0102) +#define SCARD_ATTR_VENDOR_IFD_SERIAL_NO SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0103) +#define SCARD_ATTR_CHANNEL_ID SCARD_ATTR_VALUE(SCARD_CLASS_COMMUNICATIONS, 0x0110) +#define SCARD_ATTR_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120) +// #define SCARD_ATTR_ASYNC_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120) +#define SCARD_ATTR_DEFAULT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0121) +#define SCARD_ATTR_MAX_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0122) +#define SCARD_ATTR_DEFAULT_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0123) +#define SCARD_ATTR_MAX_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0124) +#define SCARD_ATTR_MAX_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0125) +// #define SCARD_ATTR_SYNC_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0126) +#define SCARD_ATTR_POWER_MGMT_SUPPORT SCARD_ATTR_VALUE(SCARD_CLASS_POWER_MGMT, 0x0131) +#define SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0140) +#define SCARD_ATTR_USER_AUTH_INPUT_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0142) +#define SCARD_ATTR_CHARACTERISTICS SCARD_ATTR_VALUE(SCARD_CLASS_MECHANICAL, 0x0150) + +#define SCARD_ATTR_CURRENT_PROTOCOL_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0201) +#define SCARD_ATTR_CURRENT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0202) +#define SCARD_ATTR_CURRENT_F SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0203) +#define SCARD_ATTR_CURRENT_D SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0204) +#define SCARD_ATTR_CURRENT_N SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0205) +#define SCARD_ATTR_CURRENT_W SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0206) +#define SCARD_ATTR_CURRENT_IFSC SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0207) +#define SCARD_ATTR_CURRENT_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0208) +#define SCARD_ATTR_CURRENT_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0209) +#define SCARD_ATTR_CURRENT_CWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020a) +#define SCARD_ATTR_CURRENT_EBC_ENCODING SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020b) +#define SCARD_ATTR_EXTENDED_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020c) + +#define SCARD_ATTR_ICC_PRESENCE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0300) +#define SCARD_ATTR_ICC_INTERFACE_STATUS SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0301) +#define SCARD_ATTR_CURRENT_IO_STATE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0302) +#define SCARD_ATTR_ATR_STRING SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0303) +#define SCARD_ATTR_ICC_TYPE_PER_ATR SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0304) + +#define SCARD_ATTR_ESC_RESET SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA000) +#define SCARD_ATTR_ESC_CANCEL SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA003) +#define SCARD_ATTR_ESC_AUTHREQUEST SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA005) +#define SCARD_ATTR_MAXINPUT SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA007) + +#define SCARD_ATTR_DEVICE_UNIT SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0001) +#define SCARD_ATTR_DEVICE_IN_USE SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0002) +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0003) +#define SCARD_ATTR_DEVICE_SYSTEM_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0004) +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0005) +#define SCARD_ATTR_DEVICE_SYSTEM_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0006) +#define SCARD_ATTR_SUPRESS_T1_IFS_REQUEST SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0007) + +#define SCARD_PERF_NUM_TRANSMISSIONS SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0001) +#define SCARD_PERF_BYTES_TRANSMITTED SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0002) +#define SCARD_PERF_TRANSMISSION_TIME SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0003) + +#ifdef UNICODE +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_W +#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_W +#else +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_A +#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_A +#endif + + +// +// T=0 Protocol Defines +// + +#define SCARD_T0_HEADER_LENGTH 7 +#define SCARD_T0_CMD_LENGTH 5 + + +// +// T=1 Protocol Defines +// + +#define SCARD_T1_PROLOGUE_LENGTH 3 +#define SCARD_T1_EPILOGUE_LENGTH 2 +#define SCARD_T1_MAX_IFS 254 + + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Reader states +// + +#define SCARD_UNKNOWN 0 // This value implies the driver is unaware + // of the current state of the reader. +#define SCARD_ABSENT 1 // This value implies there is no card in + // the reader. +#define SCARD_PRESENT 2 // This value implies there is a card is + // present in the reader, but that it has + // not been moved into position for use. +#define SCARD_SWALLOWED 3 // This value implies there is a card in the + // reader in position for use. The card is + // not powered. +#define SCARD_POWERED 4 // This value implies there is power is + // being provided to the card, but the + // Reader Driver is unaware of the mode of + // the card. +#define SCARD_NEGOTIABLE 5 // This value implies the card has been + // reset and is awaiting PTS negotiation. +#define SCARD_SPECIFIC 6 // This value implies the card has been + // reset and specific communication + // protocols have been established. + +//////////////////////////////////////////////////////////////////////////////// +// +// I/O Services +// +// The following services provide access to the I/O capabilities of the +// reader drivers. Services of the Smart Card are requested by placing the +// following structure into the protocol buffer: +// + + +typedef struct _SCARD_IO_REQUEST{ + DWORD dwProtocol; // Protocol identifier + DWORD cbPciLength; // Protocol Control Information Length +} SCARD_IO_REQUEST, *PSCARD_IO_REQUEST, *LPSCARD_IO_REQUEST; +typedef const SCARD_IO_REQUEST *LPCSCARD_IO_REQUEST; + + +// +// T=0 protocol services. +// + +typedef struct { + BYTE + bCla, // The instruction class + bIns, // The instruction code within the instruction class + bP1, + bP2, // Parameters to the instruction + bP3; // Size of I/O Transfer +} SCARD_T0_COMMAND, *LPSCARD_T0_COMMAND; + +typedef struct { + SCARD_IO_REQUEST ioRequest; + BYTE + bSw1, + bSw2; // Return codes from the instruction + union + { + SCARD_T0_COMMAND CmdBytes; + BYTE rgbHeader[5]; + } DUMMYUNIONNAME; +} SCARD_T0_REQUEST; + +typedef SCARD_T0_REQUEST *PSCARD_T0_REQUEST, *LPSCARD_T0_REQUEST; + + +// +// T=1 Protocol Services +// + +typedef struct { + SCARD_IO_REQUEST ioRequest; +} SCARD_T1_REQUEST; +typedef SCARD_T1_REQUEST *PSCARD_T1_REQUEST, *LPSCARD_T1_REQUEST; + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Driver attribute flags +// + +#define SCARD_READER_SWALLOWS 0x00000001 // Reader has a card swallowing + // mechanism. +#define SCARD_READER_EJECTS 0x00000002 // Reader has a card ejection + // mechanism. +#define SCARD_READER_CONFISCATES 0x00000004 // Reader has a card capture + // mechanism. + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Type of reader +// +#define SCARD_READER_TYPE_SERIAL 0x01 +#define SCARD_READER_TYPE_PARALELL 0x02 +#define SCARD_READER_TYPE_KEYBOARD 0x04 +#define SCARD_READER_TYPE_SCSI 0x08 +#define SCARD_READER_TYPE_IDE 0x10 +#define SCARD_READER_TYPE_USB 0x20 +#define SCARD_READER_TYPE_PCMCIA 0x40 +#define SCARD_READER_TYPE_VENDOR 0xF0 + +#ifdef __cplusplus +} +#endif +#endif + + ADDED build/cackey_win32_build/lib/winscard.dll Index: build/cackey_win32_build/lib/winscard.dll ================================================================== --- /dev/null +++ build/cackey_win32_build/lib/winscard.dll cannot compute difference between binary files ADDED build/cackey_win32_build/lib/winscard.lib Index: build/cackey_win32_build/lib/winscard.lib ================================================================== --- /dev/null +++ build/cackey_win32_build/lib/winscard.lib cannot compute difference between binary files Index: build/cackey_win64_build/build.sh ================================================================== --- build/cackey_win64_build/build.sh +++ build/cackey_win64_build/build.sh @@ -1,9 +1,13 @@ #! /bin/bash make distclean -./configure --with-pcsc-headers="$(pwd)/build/cackey_win64_build/include" --with-pcsc-libs="-L$(pwd)/build/cackey_win64_build/lib -lwinscard" --host=x86_64-w64-mingw32 CPPFLAGS="-I$(pwd)/build/cackey_win64_build/include" || exit 1 +cp "./build/cackey_win64_build/lib/winscard.dll" "./build/cackey_win64_build/lib/WinSCard.dll" + +./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 make || exit 1 + +rm -f "./build/cackey_win64_build/lib/WinSCard.dll" exit 0 ADDED build/cackey_win64_build/include/SCardErr.h Index: build/cackey_win64_build/include/SCardErr.h ================================================================== --- /dev/null +++ build/cackey_win64_build/include/SCardErr.h @@ -0,0 +1,655 @@ +/* + scarderr.mc + + Error message codes from the Smart Card Resource Manager + These messages must be reconciled with winerror.w + They exist here to provide error messages on pre-Win2K systems. + +*/ +#ifndef SCARD_S_SUCCESS +// +// ============================= +// Facility SCARD Error Messages +// ============================= +// +#define SCARD_S_SUCCESS NO_ERROR +// +// Values are 32 bit values laid out as follows: +// +// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 +// 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 +// +---+-+-+-----------------------+-------------------------------+ +// |Sev|C|R| Facility | Code | +// +---+-+-+-----------------------+-------------------------------+ +// +// where +// +// Sev - is the severity code +// +// 00 - Success +// 01 - Informational +// 10 - Warning +// 11 - Error +// +// C - is the Customer code flag +// +// R - is a reserved bit +// +// Facility - is the facility code +// +// Code - is the facility's status code +// +// +// Define the facility codes +// +#define FACILITY_SYSTEM 0x0 +#define FACILITY_SCARD 0x10 + + +// +// Define the severity codes +// +#define STATUS_SEVERITY_WARNING 0x2 +#define STATUS_SEVERITY_INFORMATIONAL 0x1 +#define STATUS_SEVERITY_ERROR 0x3 + + +// +// MessageId: SCARD_F_INTERNAL_ERROR +// +// MessageText: +// +// An internal consistency check failed. +// +#define SCARD_F_INTERNAL_ERROR ((DWORD)0x80100001L) + +// +// MessageId: SCARD_E_CANCELLED +// +// MessageText: +// +// The action was cancelled by an SCardCancel request. +// +#define SCARD_E_CANCELLED ((DWORD)0x80100002L) + +// +// MessageId: SCARD_E_INVALID_HANDLE +// +// MessageText: +// +// The supplied handle was invalid. +// +#define SCARD_E_INVALID_HANDLE ((DWORD)0x80100003L) + +// +// MessageId: SCARD_E_INVALID_PARAMETER +// +// MessageText: +// +// One or more of the supplied parameters could not be properly interpreted. +// +#define SCARD_E_INVALID_PARAMETER ((DWORD)0x80100004L) + +// +// MessageId: SCARD_E_INVALID_TARGET +// +// MessageText: +// +// Registry startup information is missing or invalid. +// +#define SCARD_E_INVALID_TARGET ((DWORD)0x80100005L) + +// +// MessageId: SCARD_E_NO_MEMORY +// +// MessageText: +// +// Not enough memory available to complete this command. +// +#define SCARD_E_NO_MEMORY ((DWORD)0x80100006L) + +// +// MessageId: SCARD_F_WAITED_TOO_LONG +// +// MessageText: +// +// An internal consistency timer has expired. +// +#define SCARD_F_WAITED_TOO_LONG ((DWORD)0x80100007L) + +// +// MessageId: SCARD_E_INSUFFICIENT_BUFFER +// +// MessageText: +// +// The data buffer to receive returned data is too small for the returned data. +// +#define SCARD_E_INSUFFICIENT_BUFFER ((DWORD)0x80100008L) + +// +// MessageId: SCARD_E_UNKNOWN_READER +// +// MessageText: +// +// The specified reader name is not recognized. +// +#define SCARD_E_UNKNOWN_READER ((DWORD)0x80100009L) + +// +// MessageId: SCARD_E_TIMEOUT +// +// MessageText: +// +// The user-specified timeout value has expired. +// +#define SCARD_E_TIMEOUT ((DWORD)0x8010000AL) + +// +// MessageId: SCARD_E_SHARING_VIOLATION +// +// MessageText: +// +// The smart card cannot be accessed because of other connections outstanding. +// +#define SCARD_E_SHARING_VIOLATION ((DWORD)0x8010000BL) + +// +// MessageId: SCARD_E_NO_SMARTCARD +// +// MessageText: +// +// The operation requires a Smart Card, but no Smart Card is currently in the device. +// +#define SCARD_E_NO_SMARTCARD ((DWORD)0x8010000CL) + +// +// MessageId: SCARD_E_UNKNOWN_CARD +// +// MessageText: +// +// The specified smart card name is not recognized. +// +#define SCARD_E_UNKNOWN_CARD ((DWORD)0x8010000DL) + +// +// MessageId: SCARD_E_CANT_DISPOSE +// +// MessageText: +// +// The system could not dispose of the media in the requested manner. +// +#define SCARD_E_CANT_DISPOSE ((DWORD)0x8010000EL) + +// +// MessageId: SCARD_E_PROTO_MISMATCH +// +// MessageText: +// +// The requested protocols are incompatible with the protocol currently in use with the smart card. +// +#define SCARD_E_PROTO_MISMATCH ((DWORD)0x8010000FL) + +// +// MessageId: SCARD_E_NOT_READY +// +// MessageText: +// +// The reader or smart card is not ready to accept commands. +// +#define SCARD_E_NOT_READY ((DWORD)0x80100010L) + +// +// MessageId: SCARD_E_INVALID_VALUE +// +// MessageText: +// +// One or more of the supplied parameters values could not be properly interpreted. +// +#define SCARD_E_INVALID_VALUE ((DWORD)0x80100011L) + +// +// MessageId: SCARD_E_SYSTEM_CANCELLED +// +// MessageText: +// +// The action was cancelled by the system, presumably to log off or shut down. +// +#define SCARD_E_SYSTEM_CANCELLED ((DWORD)0x80100012L) + +// +// MessageId: SCARD_F_COMM_ERROR +// +// MessageText: +// +// An internal communications error has been detected. +// +#define SCARD_F_COMM_ERROR ((DWORD)0x80100013L) + +// +// MessageId: SCARD_F_UNKNOWN_ERROR +// +// MessageText: +// +// An internal error has been detected, but the source is unknown. +// +#define SCARD_F_UNKNOWN_ERROR ((DWORD)0x80100014L) + +// +// MessageId: SCARD_E_INVALID_ATR +// +// MessageText: +// +// An ATR obtained from the registry is not a valid ATR string. +// +#define SCARD_E_INVALID_ATR ((DWORD)0x80100015L) + +// +// MessageId: SCARD_E_NOT_TRANSACTED +// +// MessageText: +// +// An attempt was made to end a non-existent transaction. +// +#define SCARD_E_NOT_TRANSACTED ((DWORD)0x80100016L) + +// +// MessageId: SCARD_E_READER_UNAVAILABLE +// +// MessageText: +// +// The specified reader is not currently available for use. +// +#define SCARD_E_READER_UNAVAILABLE ((DWORD)0x80100017L) + +// +// MessageId: SCARD_P_SHUTDOWN +// +// MessageText: +// +// The operation has been aborted to allow the server application to exit. +// +#define SCARD_P_SHUTDOWN ((DWORD)0x80100018L) + +// +// MessageId: SCARD_E_PCI_TOO_SMALL +// +// MessageText: +// +// The PCI Receive buffer was too small. +// +#define SCARD_E_PCI_TOO_SMALL ((DWORD)0x80100019L) + +// +// MessageId: SCARD_E_READER_UNSUPPORTED +// +// MessageText: +// +// The reader driver does not meet minimal requirements for support. +// +#define SCARD_E_READER_UNSUPPORTED ((DWORD)0x8010001AL) + +// +// MessageId: SCARD_E_DUPLICATE_READER +// +// MessageText: +// +// The reader driver did not produce a unique reader name. +// +#define SCARD_E_DUPLICATE_READER ((DWORD)0x8010001BL) + +// +// MessageId: SCARD_E_CARD_UNSUPPORTED +// +// MessageText: +// +// The smart card does not meet minimal requirements for support. +// +#define SCARD_E_CARD_UNSUPPORTED ((DWORD)0x8010001CL) + +// +// MessageId: SCARD_E_NO_SERVICE +// +// MessageText: +// +// The Smart card resource manager is not running. +// +#define SCARD_E_NO_SERVICE ((DWORD)0x8010001DL) + +// +// MessageId: SCARD_E_SERVICE_STOPPED +// +// MessageText: +// +// The Smart card resource manager has shut down. +// +#define SCARD_E_SERVICE_STOPPED ((DWORD)0x8010001EL) + +// +// MessageId: SCARD_E_UNEXPECTED +// +// MessageText: +// +// An unexpected card error has occurred. +// +#define SCARD_E_UNEXPECTED ((DWORD)0x8010001FL) + +// +// MessageId: SCARD_E_ICC_INSTALLATION +// +// MessageText: +// +// No Primary Provider can be found for the smart card. +// +#define SCARD_E_ICC_INSTALLATION ((DWORD)0x80100020L) + +// +// MessageId: SCARD_E_ICC_CREATEORDER +// +// MessageText: +// +// The requested order of object creation is not supported. +// +#define SCARD_E_ICC_CREATEORDER ((DWORD)0x80100021L) + +// +// MessageId: SCARD_E_UNSUPPORTED_FEATURE +// +// MessageText: +// +// This smart card does not support the requested feature. +// +#define SCARD_E_UNSUPPORTED_FEATURE ((DWORD)0x80100022L) + +// +// MessageId: SCARD_E_DIR_NOT_FOUND +// +// MessageText: +// +// The identified directory does not exist in the smart card. +// +#define SCARD_E_DIR_NOT_FOUND ((DWORD)0x80100023L) + +// +// MessageId: SCARD_E_FILE_NOT_FOUND +// +// MessageText: +// +// The identified file does not exist in the smart card. +// +#define SCARD_E_FILE_NOT_FOUND ((DWORD)0x80100024L) + +// +// MessageId: SCARD_E_NO_DIR +// +// MessageText: +// +// The supplied path does not represent a smart card directory. +// +#define SCARD_E_NO_DIR ((DWORD)0x80100025L) + +// +// MessageId: SCARD_E_NO_FILE +// +// MessageText: +// +// The supplied path does not represent a smart card file. +// +#define SCARD_E_NO_FILE ((DWORD)0x80100026L) + +// +// MessageId: SCARD_E_NO_ACCESS +// +// MessageText: +// +// Access is denied to this file. +// +#define SCARD_E_NO_ACCESS ((DWORD)0x80100027L) + +// +// MessageId: SCARD_E_WRITE_TOO_MANY +// +// MessageText: +// +// The smartcard does not have enough memory to store the information. +// +#define SCARD_E_WRITE_TOO_MANY ((DWORD)0x80100028L) + +// +// MessageId: SCARD_E_BAD_SEEK +// +// MessageText: +// +// There was an error trying to set the smart card file object pointer. +// +#define SCARD_E_BAD_SEEK ((DWORD)0x80100029L) + +// +// MessageId: SCARD_E_INVALID_CHV +// +// MessageText: +// +// The supplied PIN is incorrect. +// +#define SCARD_E_INVALID_CHV ((DWORD)0x8010002AL) + +// +// MessageId: SCARD_E_UNKNOWN_RES_MNG +// +// MessageText: +// +// An unrecognized error code was returned from a layered component. +// +#define SCARD_E_UNKNOWN_RES_MNG ((DWORD)0x8010002BL) + +// +// MessageId: SCARD_E_NO_SUCH_CERTIFICATE +// +// MessageText: +// +// The requested certificate does not exist. +// +#define SCARD_E_NO_SUCH_CERTIFICATE ((DWORD)0x8010002CL) + +// +// MessageId: SCARD_E_CERTIFICATE_UNAVAILABLE +// +// MessageText: +// +// The requested certificate could not be obtained. +// +#define SCARD_E_CERTIFICATE_UNAVAILABLE ((DWORD)0x8010002DL) + +// +// MessageId: SCARD_E_NO_READERS_AVAILABLE +// +// MessageText: +// +// Cannot find a smart card reader. +// +#define SCARD_E_NO_READERS_AVAILABLE ((DWORD)0x8010002EL) + +// +// MessageId: SCARD_E_COMM_DATA_LOST +// +// MessageText: +// +// A communications error with the smart card has been detected. Retry the operation. +// +#define SCARD_E_COMM_DATA_LOST ((DWORD)0x8010002FL) + +// +// MessageId: SCARD_E_NO_KEY_CONTAINER +// +// MessageText: +// +// The requested key container does not exist on the smart card. +// +#define SCARD_E_NO_KEY_CONTAINER ((DWORD)0x80100030L) + +// +// MessageId: SCARD_E_SERVER_TOO_BUSY +// +// MessageText: +// +// The Smart card resource manager is too busy to complete this operation. +// +#define SCARD_E_SERVER_TOO_BUSY ((DWORD)0x80100031L) + +// +// MessageId: SCARD_E_PIN_CACHE_EXPIRED +// +// MessageText: +// +// The smart card PIN cache has expired. +// +#define SCARD_E_PIN_CACHE_EXPIRED ((DWORD)0x80100032L) + +// +// MessageId: SCARD_E_NO_PIN_CACHE +// +// MessageText: +// +// The smart card PIN cannot be cached. +// +#define SCARD_E_NO_PIN_CACHE ((DWORD)0x80100033L) + +// +// MessageId: SCARD_E_READ_ONLY_CARD +// +// MessageText: +// +// The smart card is read only and cannot be written to. +// +#define SCARD_E_READ_ONLY_CARD ((DWORD)0x80100034L) + +// +// These are warning codes. +// +// +// MessageId: SCARD_W_UNSUPPORTED_CARD +// +// MessageText: +// +// The reader cannot communicate with the smart card, due to ATR configuration conflicts. +// +#define SCARD_W_UNSUPPORTED_CARD ((DWORD)0x80100065L) + +// +// MessageId: SCARD_W_UNRESPONSIVE_CARD +// +// MessageText: +// +// The smart card is not responding to a reset. +// +#define SCARD_W_UNRESPONSIVE_CARD ((DWORD)0x80100066L) + +// +// MessageId: SCARD_W_UNPOWERED_CARD +// +// MessageText: +// +// Power has been removed from the smart card, so that further communication is not possible. +// +#define SCARD_W_UNPOWERED_CARD ((DWORD)0x80100067L) + +// +// MessageId: SCARD_W_RESET_CARD +// +// MessageText: +// +// The smart card has been reset, so any shared state information is invalid. +// +#define SCARD_W_RESET_CARD ((DWORD)0x80100068L) + +// +// MessageId: SCARD_W_REMOVED_CARD +// +// MessageText: +// +// The smart card has been removed, so that further communication is not possible. +// +#define SCARD_W_REMOVED_CARD ((DWORD)0x80100069L) + +// +// MessageId: SCARD_W_SECURITY_VIOLATION +// +// MessageText: +// +// Access was denied because of a security violation. +// +#define SCARD_W_SECURITY_VIOLATION ((DWORD)0x8010006AL) + +// +// MessageId: SCARD_W_WRONG_CHV +// +// MessageText: +// +// The card cannot be accessed because the wrong PIN was presented. +// +#define SCARD_W_WRONG_CHV ((DWORD)0x8010006BL) + +// +// MessageId: SCARD_W_CHV_BLOCKED +// +// MessageText: +// +// The card cannot be accessed because the maximum number of PIN entry attempts has been reached. +// +#define SCARD_W_CHV_BLOCKED ((DWORD)0x8010006CL) + +// +// MessageId: SCARD_W_EOF +// +// MessageText: +// +// The end of the smart card file has been reached. +// +#define SCARD_W_EOF ((DWORD)0x8010006DL) + +// +// MessageId: SCARD_W_CANCELLED_BY_USER +// +// MessageText: +// +// The action was cancelled by the user. +// +#define SCARD_W_CANCELLED_BY_USER ((DWORD)0x8010006EL) + +// +// MessageId: SCARD_W_CARD_NOT_AUTHENTICATED +// +// MessageText: +// +// No PIN was presented to the smart card. +// +#define SCARD_W_CARD_NOT_AUTHENTICATED ((DWORD)0x8010006FL) + +// +// MessageId: SCARD_W_CACHE_ITEM_NOT_FOUND +// +// MessageText: +// +// The requested item could not be found in the cache. +// +#define SCARD_W_CACHE_ITEM_NOT_FOUND ((DWORD)0x80100070L) + +// +// MessageId: SCARD_W_CACHE_ITEM_STALE +// +// MessageText: +// +// The requested cache item is too old and was deleted from the cache. +// +#define SCARD_W_CACHE_ITEM_STALE ((DWORD)0x80100071L) + +// +// MessageId: SCARD_W_CACHE_ITEM_TOO_BIG +// +// MessageText: +// +// The new cache item exceeds the maximum per-item size defined for the cache. +// +#define SCARD_W_CACHE_ITEM_TOO_BIG ((DWORD)0x80100072L) + +#endif // SCARD_S_SUCCESS + Index: build/cackey_win64_build/include/pcsclite.h ================================================================== --- build/cackey_win64_build/include/pcsclite.h +++ build/cackey_win64_build/include/pcsclite.h @@ -1,2 +1,1 @@ -#define _WIN32_WINNT 0x500 #include DELETED build/cackey_win64_build/include/pthread.h Index: build/cackey_win64_build/include/pthread.h ================================================================== --- build/cackey_win64_build/include/pthread.h +++ /dev/null @@ -1,53 +0,0 @@ -/* Thread_emulation.h */ -/* Author: Johnson M. Hart */ -/* Emulate the Pthreads model for the Win32 platform */ -/* The emulation is not complete, but it does provide a subset */ -/* required for a first project */ -/* Source: http://world.std.com/~jmhart/opensource.htm */ -/* The emulation is not complete, but it does provide a subset */ -/* that will work with many well-behaved programs */ -/* IF YOU ARE REALLY SERIOUS ABOUT THIS, USE THE OPEN SOURCE */ -/* PTHREAD LIBRARY. YOU'LL FIND IT ON THE RED HAT SITE */ - -#ifndef _THREAD_EMULATION -# define _THREAD_EMULATION - -/* Thread management macros */ -# ifdef _WIN32 -# define _WIN32_WINNT 0x500 /* WINBASE.H - Enable SignalObjectAndWait */ -# include -# include -# define THREAD_FUNCTION_PROTO THREAD_FUNCTION_RETURN (__stdcall *) (void *) -# define THREAD_FUNCTION_RETURN unsigned int -# define THREAD_SPECIFIC_INDEX DWORD -# define pthread_t HANDLE -# define pthread_attr_t DWORD -# define pthread_create(thhandle, attr, thfunc, tharg) ((int) ((*thhandle = (HANDLE) _beginthreadex(NULL, 0, (THREAD_FUNCTION_PROTO) thfunc, tharg, 0, NULL)) == NULL)) -# define pthread_join(thread, result) ((WaitForSingleObject((thread), INFINITE) != WAIT_OBJECT_0) || !CloseHandle(thread)) -# define pthread_detach(thread) { if (((void *) thread) != NULL) { CloseHandle((void *) thread); }} -# define thread_sleep(nms) Sleep(nms) -# define pthread_cancel(thread) TerminateThread(thread, 0) -# define ts_key_create(ts_key, destructor) {ts_key = TlsAlloc();} -# define pthread_getspecific(ts_key) TlsGetValue(ts_key) -# define pthread_setspecific(ts_key, value) TlsSetValue(ts_key, (void *)value) -# define pthread_self() GetCurrentThreadId() -# else -# include -# define THREAD_FUNCTION_RETURN void * -# endif - -/* Syncrhronization macros: Win32->pthread */ -# ifdef _WIN32 -# define pthread_mutex_t HANDLE -# define pthread_cond_t HANDLE -# define pthread_mutex_lock(pobject) WaitForSingleObject(*pobject, INFINITE) -# define pthread_mutex_unlock(pobject) (!ReleaseMutex(*pobject)) -# define pthread_mutex_init(pobject,pattr) ((*pobject=CreateMutex(NULL, FALSE, NULL)) == NULL) -# define pthread_cond_init(pobject,pattr) (*pobject=CreateEvent(NULL, FALSE, FALSE, NULL)) -# define pthread_mutex_destroy(pobject) CloseHandle(*pobject) -# define pthread_cond_destroy(pobject) CloseHandle(*pobject) -# define pthread_cond_wait(pcv,pmutex) { SignalObjectAndWait(*pmutex, *pcv, INFINITE, FALSE); WaitForSingleObject(*pmutex, INFINITE); } -# define pthread_cond_signal(pcv) SetEvent(*pcv) -# endif - -#endif ADDED build/cackey_win64_build/include/winscard.h Index: build/cackey_win64_build/include/winscard.h ================================================================== --- /dev/null +++ build/cackey_win64_build/include/winscard.h @@ -0,0 +1,1138 @@ +/*++ + +Copyright (c) 1996 Microsoft Corporation + +Module Name: + + WinSCard + +Abstract: + + This header file provides the definitions and symbols necessary for an + Application or Smart Card Service Provider to access the Smartcard + Subsystem. + +Environment: + + Win32 + +Notes: + +--*/ + +#ifndef _WINSCARD_H_ +#define _WINSCARD_H_ + +#if defined (_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#include +#include +#include "winsmcrd.h" +#ifndef SCARD_S_SUCCESS +#include "SCardErr.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _LPCBYTE_DEFINED +#define _LPCBYTE_DEFINED +typedef const BYTE *LPCBYTE; +#endif +#ifndef _LPCVOID_DEFINED +#define _LPCVOID_DEFINED +typedef const VOID *LPCVOID; +#endif + +#ifndef WINSCARDAPI +#define WINSCARDAPI +#endif +#ifndef WINSCARDDATA +#define WINSCARDDATA __declspec(dllimport) +#endif + +/* In clr:pure we cannot mark data export with dllimport. + * We should add small functions which returns the value of + * the global. + */ +#if !defined(_M_CEE_PURE) +WINSCARDDATA extern const SCARD_IO_REQUEST + g_rgSCardT0Pci, + g_rgSCardT1Pci, + g_rgSCardRawPci; +#define SCARD_PCI_T0 (&g_rgSCardT0Pci) +#define SCARD_PCI_T1 (&g_rgSCardT1Pci) +#define SCARD_PCI_RAW (&g_rgSCardRawPci) +#endif + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Service Manager Access Services +// +// The following services are used to manage user and terminal contexts for +// Smart Cards. +// + +typedef ULONG_PTR SCARDCONTEXT; +typedef SCARDCONTEXT *PSCARDCONTEXT, *LPSCARDCONTEXT; + +typedef ULONG_PTR SCARDHANDLE; +typedef SCARDHANDLE *PSCARDHANDLE, *LPSCARDHANDLE; + +#define SCARD_AUTOALLOCATE (DWORD)(-1) + +#define SCARD_SCOPE_USER 0 // The context is a user context, and any + // database operations are performed within the + // domain of the user. +#define SCARD_SCOPE_TERMINAL 1 // The context is that of the current terminal, + // and any database operations are performed + // within the domain of that terminal. (The + // calling application must have appropriate + // access permissions for any database actions.) +#define SCARD_SCOPE_SYSTEM 2 // The context is the system context, and any + // database operations are performed within the + // domain of the system. (The calling + // application must have appropriate access + // permissions for any database actions.) + +extern WINSCARDAPI LONG WINAPI +SCardEstablishContext( + __in DWORD dwScope, + __reserved LPCVOID pvReserved1, + __reserved LPCVOID pvReserved2, + __out LPSCARDCONTEXT phContext); + +extern WINSCARDAPI LONG WINAPI +SCardReleaseContext( + __in SCARDCONTEXT hContext); + +extern WINSCARDAPI LONG WINAPI +SCardIsValidContext( + __in SCARDCONTEXT hContext); + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Smart Card Database Management Services +// +// The following services provide for managing the Smart Card Database. +// + +#define SCARD_ALL_READERS TEXT("SCard$AllReaders\000") +#define SCARD_DEFAULT_READERS TEXT("SCard$DefaultReaders\000") +#define SCARD_LOCAL_READERS TEXT("SCard$LocalReaders\000") +#define SCARD_SYSTEM_READERS TEXT("SCard$SystemReaders\000") + +#define SCARD_PROVIDER_PRIMARY 1 // Primary Provider Id +#define SCARD_PROVIDER_CSP 2 // Crypto Service Provider Id +#define SCARD_PROVIDER_KSP 3 // Key Storage Provider Id + + +// +// Database Reader routines +// + +extern WINSCARDAPI LONG WINAPI +SCardListReaderGroupsA( + __in SCARDCONTEXT hContext, + __nullnullterminated __out_ecount_opt(*pcchGroups) LPSTR mszGroups, + __inout LPDWORD pcchGroups); +extern WINSCARDAPI LONG WINAPI +SCardListReaderGroupsW( + __in SCARDCONTEXT hContext, + __nullnullterminated __out_ecount_opt(*pcchGroups) LPWSTR mszGroups, + __inout LPDWORD pcchGroups); +#ifdef UNICODE +#define SCardListReaderGroups SCardListReaderGroupsW +#else +#define SCardListReaderGroups SCardListReaderGroupsA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardListReadersA( + __in SCARDCONTEXT hContext, + __in_opt LPCSTR mszGroups, + __nullnullterminated __out_ecount_opt(*pcchReaders) LPSTR mszReaders, + __inout LPDWORD pcchReaders); +extern WINSCARDAPI LONG WINAPI +SCardListReadersW( + __in SCARDCONTEXT hContext, + __in_opt LPCWSTR mszGroups, + __nullnullterminated __out_ecount_opt(*pcchReaders) LPWSTR mszReaders, + __inout LPDWORD pcchReaders); +#ifdef UNICODE +#define SCardListReaders SCardListReadersW +#else +#define SCardListReaders SCardListReadersA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardListCardsA( + __in SCARDCONTEXT hContext, + __in_opt LPCBYTE pbAtr, + __in_ecount_opt(cguidInterfaceCount) LPCGUID rgquidInterfaces, + __in DWORD cguidInterfaceCount, + __nullnullterminated __out_ecount_opt(*pcchCards) LPSTR mszCards, + __inout LPDWORD pcchCards); +extern WINSCARDAPI LONG WINAPI +SCardListCardsW( + __in SCARDCONTEXT hContext, + __in_opt LPCBYTE pbAtr, + __in_ecount_opt(cguidInterfaceCount) LPCGUID rgquidInterfaces, + __in DWORD cguidInterfaceCount, + __nullnullterminated __out_ecount_opt(*pcchCards) LPWSTR mszCards, + __inout LPDWORD pcchCards); +#ifdef UNICODE +#define SCardListCards SCardListCardsW +#else +#define SCardListCards SCardListCardsA +#endif // !UNICODE +// +// NOTE: The routine SCardListCards name differs from the PC/SC definition. +// It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardListCardTypes( +// __in SCARDCONTEXT hContext, +// __in_opt LPCBYTE pbAtr, +// __in_opt LPCGUID rgquidInterfaces, +// __in DWORD cguidInterfaceCount, +// __out_opt LPTSTR mszCards, +// __inout LPDWORD pcchCards); +// +// Here's a work-around MACRO: +#define SCardListCardTypes SCardListCards + +extern WINSCARDAPI LONG WINAPI +SCardListInterfacesA( + __in SCARDCONTEXT hContext, + __in LPCSTR szCard, + __out LPGUID pguidInterfaces, + __inout LPDWORD pcguidInterfaces); +extern WINSCARDAPI LONG WINAPI +SCardListInterfacesW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szCard, + __out LPGUID pguidInterfaces, + __inout LPDWORD pcguidInterfaces); +#ifdef UNICODE +#define SCardListInterfaces SCardListInterfacesW +#else +#define SCardListInterfaces SCardListInterfacesA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardGetProviderIdA( + __in SCARDCONTEXT hContext, + __in LPCSTR szCard, + __out LPGUID pguidProviderId); +extern WINSCARDAPI LONG WINAPI +SCardGetProviderIdW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szCard, + __out LPGUID pguidProviderId); +#ifdef UNICODE +#define SCardGetProviderId SCardGetProviderIdW +#else +#define SCardGetProviderId SCardGetProviderIdA +#endif // !UNICODE +// +// NOTE: The routine SCardGetProviderId in this implementation uses GUIDs. +// The PC/SC definition uses BYTEs. +// + +extern WINSCARDAPI LONG WINAPI +SCardGetCardTypeProviderNameA( + __in SCARDCONTEXT hContext, + __in LPCSTR szCardName, + __in DWORD dwProviderId, + __out_ecount_opt(*pcchProvider) LPSTR szProvider, + __inout LPDWORD pcchProvider); +extern WINSCARDAPI LONG WINAPI +SCardGetCardTypeProviderNameW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szCardName, + __in DWORD dwProviderId, + __out_ecount_opt(*pcchProvider) LPWSTR szProvider, + __inout LPDWORD pcchProvider); +#ifdef UNICODE +#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameW +#else +#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameA +#endif // !UNICODE +// +// NOTE: This routine is an extension to the PC/SC definitions. +// + + +// +// Database Writer routines +// + +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderGroupA( + __in SCARDCONTEXT hContext, + __in LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderGroupW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupW +#else +#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderGroupA( + __in SCARDCONTEXT hContext, + __in LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderGroupW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardForgetReaderGroup SCardForgetReaderGroupW +#else +#define SCardForgetReaderGroup SCardForgetReaderGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderA( + __in SCARDCONTEXT hContext, + __in LPCSTR szReaderName, + __in LPCSTR szDeviceName); +extern WINSCARDAPI LONG WINAPI +SCardIntroduceReaderW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szReaderName, + __in LPCWSTR szDeviceName); +#ifdef UNICODE +#define SCardIntroduceReader SCardIntroduceReaderW +#else +#define SCardIntroduceReader SCardIntroduceReaderA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderA( + __in SCARDCONTEXT hContext, + __in LPCSTR szReaderName); +extern WINSCARDAPI LONG WINAPI +SCardForgetReaderW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szReaderName); +#ifdef UNICODE +#define SCardForgetReader SCardForgetReaderW +#else +#define SCardForgetReader SCardForgetReaderA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardAddReaderToGroupA( + __in SCARDCONTEXT hContext, + __in LPCSTR szReaderName, + __in LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardAddReaderToGroupW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szReaderName, + __in LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardAddReaderToGroup SCardAddReaderToGroupW +#else +#define SCardAddReaderToGroup SCardAddReaderToGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardRemoveReaderFromGroupA( + __in SCARDCONTEXT hContext, + __in LPCSTR szReaderName, + __in LPCSTR szGroupName); +extern WINSCARDAPI LONG WINAPI +SCardRemoveReaderFromGroupW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szReaderName, + __in LPCWSTR szGroupName); +#ifdef UNICODE +#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupW +#else +#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardIntroduceCardTypeA( + __in SCARDCONTEXT hContext, + __in LPCSTR szCardName, + __in_opt LPCGUID pguidPrimaryProvider, + __in_opt LPCGUID rgguidInterfaces, + __in DWORD dwInterfaceCount, + __in LPCBYTE pbAtr, + __in LPCBYTE pbAtrMask, + __in DWORD cbAtrLen); +extern WINSCARDAPI LONG WINAPI +SCardIntroduceCardTypeW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szCardName, + __in_opt LPCGUID pguidPrimaryProvider, + __in_opt LPCGUID rgguidInterfaces, + __in DWORD dwInterfaceCount, + __in LPCBYTE pbAtr, + __in LPCBYTE pbAtrMask, + __in DWORD cbAtrLen); +#ifdef UNICODE +#define SCardIntroduceCardType SCardIntroduceCardTypeW +#else +#define SCardIntroduceCardType SCardIntroduceCardTypeA +#endif // !UNICODE +// +// NOTE: The routine SCardIntroduceCardType's parameters' order differs from +// the PC/SC definition. It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardIntroduceCardType( +// __in SCARDCONTEXT hContext, +// __in LPCTSTR szCardName, +// __in LPCBYTE pbAtr, +// __in LPCBYTE pbAtrMask, +// __in DWORD cbAtrLen, +// __in_opt LPCGUID pguidPrimaryProvider, +// __in_opt LPCGUID rgguidInterfaces, +// __in DWORD dwInterfaceCount); +// +// Here's a work-around MACRO: +#define PCSCardIntroduceCardType(hContext, szCardName, pbAtr, pbAtrMask, cbAtrLen, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount) \ + SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen) + +extern WINSCARDAPI LONG WINAPI +SCardSetCardTypeProviderNameA( + __in SCARDCONTEXT hContext, + __in LPCSTR szCardName, + __in DWORD dwProviderId, + __in LPCSTR szProvider); +extern WINSCARDAPI LONG WINAPI +SCardSetCardTypeProviderNameW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szCardName, + __in DWORD dwProviderId, + __in LPCWSTR szProvider); +#ifdef UNICODE +#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameW +#else +#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameA +#endif // !UNICODE +// +// NOTE: This routine is an extention to the PC/SC specifications. +// + +extern WINSCARDAPI LONG WINAPI +SCardForgetCardTypeA( + __in SCARDCONTEXT hContext, + __in LPCSTR szCardName); +extern WINSCARDAPI LONG WINAPI +SCardForgetCardTypeW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szCardName); +#ifdef UNICODE +#define SCardForgetCardType SCardForgetCardTypeW +#else +#define SCardForgetCardType SCardForgetCardTypeA +#endif // !UNICODE + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Service Manager Support Routines +// +// The following services are supplied to simplify the use of the Service +// Manager API. +// + +extern WINSCARDAPI LONG WINAPI +SCardFreeMemory( + __in SCARDCONTEXT hContext, + __in LPCVOID pvMem); + +#if (NTDDI_VERSION >= NTDDI_WINXP) +extern WINSCARDAPI HANDLE WINAPI +SCardAccessStartedEvent(void); + +extern WINSCARDAPI void WINAPI +SCardReleaseStartedEvent(void); +#endif // (NTDDI_VERSION >= NTDDI_WINXP) + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Reader Services +// +// The following services supply means for tracking cards within readers. +// + +typedef struct { + LPCSTR szReader; // reader name + LPVOID pvUserData; // user defined data + DWORD dwCurrentState; // current state of reader at time of call + DWORD dwEventState; // state of reader after state change + DWORD cbAtr; // Number of bytes in the returned ATR. + BYTE rgbAtr[36]; // Atr of inserted card, (extra alignment bytes) +} SCARD_READERSTATEA, *PSCARD_READERSTATEA, *LPSCARD_READERSTATEA; +typedef struct { + LPCWSTR szReader; // reader name + LPVOID pvUserData; // user defined data + DWORD dwCurrentState; // current state of reader at time of call + DWORD dwEventState; // state of reader after state change + DWORD cbAtr; // Number of bytes in the returned ATR. + BYTE rgbAtr[36]; // Atr of inserted card, (extra alignment bytes) +} SCARD_READERSTATEW, *PSCARD_READERSTATEW, *LPSCARD_READERSTATEW; +#ifdef UNICODE +typedef SCARD_READERSTATEW SCARD_READERSTATE; +typedef PSCARD_READERSTATEW PSCARD_READERSTATE; +typedef LPSCARD_READERSTATEW LPSCARD_READERSTATE; +#else +typedef SCARD_READERSTATEA SCARD_READERSTATE; +typedef PSCARD_READERSTATEA PSCARD_READERSTATE; +typedef LPSCARD_READERSTATEA LPSCARD_READERSTATE; +#endif // UNICODE + +// Backwards compatibility macros +#define SCARD_READERSTATE_A SCARD_READERSTATEA +#define SCARD_READERSTATE_W SCARD_READERSTATEW +#define PSCARD_READERSTATE_A PSCARD_READERSTATEA +#define PSCARD_READERSTATE_W PSCARD_READERSTATEW +#define LPSCARD_READERSTATE_A LPSCARD_READERSTATEA +#define LPSCARD_READERSTATE_W LPSCARD_READERSTATEW + +#define SCARD_STATE_UNAWARE 0x00000000 // The application is unaware of the + // current state, and would like to + // know. The use of this value + // results in an immediate return + // from state transition monitoring + // services. This is represented by + // all bits set to zero. +#define SCARD_STATE_IGNORE 0x00000001 // The application requested that + // this reader be ignored. No other + // bits will be set. +#define SCARD_STATE_CHANGED 0x00000002 // This implies that there is a + // difference between the state + // believed by the application, and + // the state known by the Service + // Manager. When this bit is set, + // the application may assume a + // significant state change has + // occurred on this reader. +#define SCARD_STATE_UNKNOWN 0x00000004 // This implies that the given + // reader name is not recognized by + // the Service Manager. If this bit + // is set, then SCARD_STATE_CHANGED + // and SCARD_STATE_IGNORE will also + // be set. +#define SCARD_STATE_UNAVAILABLE 0x00000008 // This implies that the actual + // state of this reader is not + // available. If this bit is set, + // then all the following bits are + // clear. +#define SCARD_STATE_EMPTY 0x00000010 // This implies that there is not + // card in the reader. If this bit + // is set, all the following bits + // will be clear. +#define SCARD_STATE_PRESENT 0x00000020 // This implies that there is a card + // in the reader. +#define SCARD_STATE_ATRMATCH 0x00000040 // This implies that there is a card + // in the reader with an ATR + // matching one of the target cards. + // If this bit is set, + // SCARD_STATE_PRESENT will also be + // set. This bit is only returned + // on the SCardLocateCard() service. +#define SCARD_STATE_EXCLUSIVE 0x00000080 // This implies that the card in the + // reader is allocated for exclusive + // use by another application. If + // this bit is set, + // SCARD_STATE_PRESENT will also be + // set. +#define SCARD_STATE_INUSE 0x00000100 // This implies that the card in the + // reader is in use by one or more + // other applications, but may be + // connected to in shared mode. If + // this bit is set, + // SCARD_STATE_PRESENT will also be + // set. +#define SCARD_STATE_MUTE 0x00000200 // This implies that the card in the + // reader is unresponsive or not + // supported by the reader or + // software. +#define SCARD_STATE_UNPOWERED 0x00000400 // This implies that the card in the + // reader has not been powered up. + +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsA( + __in SCARDCONTEXT hContext, + __in LPCSTR mszCards, + __inout LPSCARD_READERSTATEA rgReaderStates, + __in DWORD cReaders); +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsW( + __in SCARDCONTEXT hContext, + __in LPCWSTR mszCards, + __inout LPSCARD_READERSTATEW rgReaderStates, + __in DWORD cReaders); +#ifdef UNICODE +#define SCardLocateCards SCardLocateCardsW +#else +#define SCardLocateCards SCardLocateCardsA +#endif // !UNICODE + +#if (NTDDI_VERSION >= NTDDI_WINXP) +typedef struct _SCARD_ATRMASK { + DWORD cbAtr; // Number of bytes in the ATR and the mask. + BYTE rgbAtr[36]; // Atr of card (extra alignment bytes) + BYTE rgbMask[36]; // Mask for the Atr (extra alignment bytes) +} SCARD_ATRMASK, *PSCARD_ATRMASK, *LPSCARD_ATRMASK; + + +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsByATRA( + __in SCARDCONTEXT hContext, + __in LPSCARD_ATRMASK rgAtrMasks, + __in DWORD cAtrs, + __inout LPSCARD_READERSTATEA rgReaderStates, + __in DWORD cReaders); +extern WINSCARDAPI LONG WINAPI +SCardLocateCardsByATRW( + __in SCARDCONTEXT hContext, + __in LPSCARD_ATRMASK rgAtrMasks, + __in DWORD cAtrs, + __inout LPSCARD_READERSTATEW rgReaderStates, + __in DWORD cReaders); +#ifdef UNICODE +#define SCardLocateCardsByATR SCardLocateCardsByATRW +#else +#define SCardLocateCardsByATR SCardLocateCardsByATRA +#endif // !UNICODE +#endif // (NTDDI_VERSION >= NTDDI_WINXP) + +extern WINSCARDAPI LONG WINAPI +SCardGetStatusChangeA( + __in SCARDCONTEXT hContext, + __in DWORD dwTimeout, + __inout LPSCARD_READERSTATEA rgReaderStates, + __in DWORD cReaders); +extern WINSCARDAPI LONG WINAPI +SCardGetStatusChangeW( + __in SCARDCONTEXT hContext, + __in DWORD dwTimeout, + __inout LPSCARD_READERSTATEW rgReaderStates, + __in DWORD cReaders); +#ifdef UNICODE +#define SCardGetStatusChange SCardGetStatusChangeW +#else +#define SCardGetStatusChange SCardGetStatusChangeA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardCancel( + __in SCARDCONTEXT hContext); + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Card/Reader Communication Services +// +// The following services provide means for communication with the card. +// + +#define SCARD_SHARE_EXCLUSIVE 1 // This application is not willing to share this + // card with other applications. +#define SCARD_SHARE_SHARED 2 // This application is willing to share this + // card with other applications. +#define SCARD_SHARE_DIRECT 3 // This application demands direct control of + // the reader, so it is not available to other + // applications. + +#define SCARD_LEAVE_CARD 0 // Don't do anything special on close +#define SCARD_RESET_CARD 1 // Reset the card on close +#define SCARD_UNPOWER_CARD 2 // Power down the card on close +#define SCARD_EJECT_CARD 3 // Eject the card on close + +extern WINSCARDAPI LONG WINAPI +SCardConnectA( + __in SCARDCONTEXT hContext, + __in LPCSTR szReader, + __in DWORD dwShareMode, + __in DWORD dwPreferredProtocols, + __out LPSCARDHANDLE phCard, + __out LPDWORD pdwActiveProtocol); +extern WINSCARDAPI LONG WINAPI +SCardConnectW( + __in SCARDCONTEXT hContext, + __in LPCWSTR szReader, + __in DWORD dwShareMode, + __in DWORD dwPreferredProtocols, + __out LPSCARDHANDLE phCard, + __out LPDWORD pdwActiveProtocol); +#ifdef UNICODE +#define SCardConnect SCardConnectW +#else +#define SCardConnect SCardConnectA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardReconnect( + __in SCARDHANDLE hCard, + __in DWORD dwShareMode, + __in DWORD dwPreferredProtocols, + __in DWORD dwInitialization, + __out_opt LPDWORD pdwActiveProtocol); + +extern WINSCARDAPI LONG WINAPI +SCardDisconnect( + __in SCARDHANDLE hCard, + __in DWORD dwDisposition); + +extern WINSCARDAPI LONG WINAPI +SCardBeginTransaction( + __in SCARDHANDLE hCard); + +extern WINSCARDAPI LONG WINAPI +SCardEndTransaction( + __in SCARDHANDLE hCard, + __in DWORD dwDisposition); + +extern WINSCARDAPI LONG WINAPI +SCardCancelTransaction( + __in SCARDHANDLE hCard); +// +// NOTE: This call corresponds to the PC/SC SCARDCOMM::Cancel routine, +// terminating a blocked SCardBeginTransaction service. +// + + +extern WINSCARDAPI LONG WINAPI +SCardState( + __in SCARDHANDLE hCard, + __out LPDWORD pdwState, + __out LPDWORD pdwProtocol, + __out_bcount(*pcbAtrLen) LPBYTE pbAtr, + __inout LPDWORD pcbAtrLen); +// +// NOTE: SCardState is an obsolete routine. PC/SC has replaced it with +// SCardStatus. +// + +extern WINSCARDAPI LONG WINAPI +SCardStatusA( + __in SCARDHANDLE hCard, + __nullnullterminated __out_ecount_opt(*pcchReaderLen) LPSTR mszReaderNames, + __inout_opt LPDWORD pcchReaderLen, + __out_opt LPDWORD pdwState, + __out_opt LPDWORD pdwProtocol, + __out_ecount_opt(*pcbAtrLen) LPBYTE pbAtr, + __inout_opt LPDWORD pcbAtrLen); +extern WINSCARDAPI LONG WINAPI +SCardStatusW( + __in SCARDHANDLE hCard, + __nullnullterminated __out_ecount_opt(*pcchReaderLen) LPWSTR mszReaderNames, + __inout_opt LPDWORD pcchReaderLen, + __out_opt LPDWORD pdwState, + __out_opt LPDWORD pdwProtocol, + __out_ecount_opt(*pcbAtrLen) LPBYTE pbAtr, + __inout_opt LPDWORD pcbAtrLen); +#ifdef UNICODE +#define SCardStatus SCardStatusW +#else +#define SCardStatus SCardStatusA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardTransmit( + __in SCARDHANDLE hCard, + __in LPCSCARD_IO_REQUEST pioSendPci, + __in_bcount(cbSendLength) LPCBYTE pbSendBuffer, + __in DWORD cbSendLength, + __inout_opt LPSCARD_IO_REQUEST pioRecvPci, + __out_bcount(*pcbRecvLength) LPBYTE pbRecvBuffer, + __inout LPDWORD pcbRecvLength); + +#if (NTDDI_VERSION >= NTDDI_VISTA) +extern WINSCARDAPI LONG WINAPI +SCardGetTransmitCount( + __in SCARDHANDLE hCard, + __out LPDWORD pcTransmitCount); +#endif // (NTDDI_VERSION >= NTDDI_VISTA) + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Reader Control Routines +// +// The following services provide for direct, low-level manipulation of the +// reader by the calling application allowing it control over the +// attributes of the communications with the card. +// + +extern WINSCARDAPI LONG WINAPI +SCardControl( + __in SCARDHANDLE hCard, + __in DWORD dwControlCode, + __in_bcount(cbInBufferSize) LPCVOID lpInBuffer, + __in DWORD cbInBufferSize, + __out_bcount(cbOutBufferSize) LPVOID lpOutBuffer, + __in DWORD cbOutBufferSize, + __out LPDWORD lpBytesReturned); + +extern WINSCARDAPI LONG WINAPI +SCardGetAttrib( + __in SCARDHANDLE hCard, + __in DWORD dwAttrId, + __out_bcount_opt(*pcbAttrLen) LPBYTE pbAttr, + __inout LPDWORD pcbAttrLen); +// +// NOTE: The routine SCardGetAttrib's name differs from the PC/SC definition. +// It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardGetReaderCapabilities( +// __in SCARDHANDLE hCard, +// __in DWORD dwTag, +// __out LPBYTE pbAttr, +// __inout LPDWORD pcbAttrLen); +// +// Here's a work-around MACRO: +#define SCardGetReaderCapabilities SCardGetAttrib + +extern WINSCARDAPI LONG WINAPI +SCardSetAttrib( + __in SCARDHANDLE hCard, + __in DWORD dwAttrId, + __in_bcount(cbAttrLen) LPCBYTE pbAttr, + __in DWORD cbAttrLen); +// +// NOTE: The routine SCardSetAttrib's name differs from the PC/SC definition. +// It should be: +// +// extern WINSCARDAPI LONG WINAPI +// SCardSetReaderCapabilities( +// __in SCARDHANDLE hCard, +// __in DWORD dwTag, +// __in LPCBYTE pbAttr, +// __in DWORD cbAttrLen); +// +// Here's a work-around MACRO: +#define SCardSetReaderCapabilities SCardSetAttrib + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Smart Card Dialog definitions +// +// The following section contains structures and exported function +// declarations for the Smart Card Common Dialog dialog. +// + +// Defined constants +// Flags +#define SC_DLG_MINIMAL_UI 0x01 +#define SC_DLG_NO_UI 0x02 +#define SC_DLG_FORCE_UI 0x04 + +#define SCERR_NOCARDNAME 0x4000 +#define SCERR_NOGUIDS 0x8000 + +typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCA) (__in SCARDCONTEXT, __in LPSTR, __in LPSTR, __in PVOID); +typedef SCARDHANDLE (WINAPI *LPOCNCONNPROCW) (__in SCARDCONTEXT, __in LPWSTR, __in LPWSTR, __in PVOID); +#ifdef UNICODE +#define LPOCNCONNPROC LPOCNCONNPROCW +#else +#define LPOCNCONNPROC LPOCNCONNPROCA +#endif // !UNICODE +typedef BOOL (WINAPI *LPOCNCHKPROC) (__in SCARDCONTEXT, __in SCARDHANDLE, __in PVOID); +typedef void (WINAPI *LPOCNDSCPROC) (__in SCARDCONTEXT, __in SCARDHANDLE, __in PVOID); + + +// +// OPENCARD_SEARCH_CRITERIA: In order to specify a user-extended search, +// lpfnCheck must not be NULL. Moreover, the connection to be made to the +// card before performing the callback must be indicated by either providing +// lpfnConnect and lpfnDisconnect OR by setting dwShareMode. +// If both the connection callbacks and dwShareMode are non-NULL, the callbacks +// will be used. +// + +typedef struct { + DWORD dwStructSize; + LPSTR lpstrGroupNames; // OPTIONAL reader groups to include in + DWORD nMaxGroupNames; // search. NULL defaults to + // SCard$DefaultReaders + LPCGUID rgguidInterfaces; // OPTIONAL requested interfaces + DWORD cguidInterfaces; // supported by card's SSP + LPSTR lpstrCardNames; // OPTIONAL requested card names; all cards w/ + DWORD nMaxCardNames; // matching ATRs will be accepted + LPOCNCHKPROC lpfnCheck; // OPTIONAL if NULL no user check will be performed. + LPOCNCONNPROCA lpfnConnect; // OPTIONAL if lpfnConnect is provided, + LPOCNDSCPROC lpfnDisconnect; // lpfnDisconnect must also be set. + LPVOID pvUserData; // OPTIONAL parameter to callbacks + DWORD dwShareMode; // OPTIONAL must be set if lpfnCheck is not null + DWORD dwPreferredProtocols; // OPTIONAL +} OPENCARD_SEARCH_CRITERIAA, *POPENCARD_SEARCH_CRITERIAA, *LPOPENCARD_SEARCH_CRITERIAA; +typedef struct { + DWORD dwStructSize; + LPWSTR lpstrGroupNames; // OPTIONAL reader groups to include in + DWORD nMaxGroupNames; // search. NULL defaults to + // SCard$DefaultReaders + LPCGUID rgguidInterfaces; // OPTIONAL requested interfaces + DWORD cguidInterfaces; // supported by card's SSP + LPWSTR lpstrCardNames; // OPTIONAL requested card names; all cards w/ + DWORD nMaxCardNames; // matching ATRs will be accepted + LPOCNCHKPROC lpfnCheck; // OPTIONAL if NULL no user check will be performed. + LPOCNCONNPROCW lpfnConnect; // OPTIONAL if lpfnConnect is provided, + LPOCNDSCPROC lpfnDisconnect; // lpfnDisconnect must also be set. + LPVOID pvUserData; // OPTIONAL parameter to callbacks + DWORD dwShareMode; // OPTIONAL must be set if lpfnCheck is not null + DWORD dwPreferredProtocols; // OPTIONAL +} OPENCARD_SEARCH_CRITERIAW, *POPENCARD_SEARCH_CRITERIAW, *LPOPENCARD_SEARCH_CRITERIAW; +#ifdef UNICODE +typedef OPENCARD_SEARCH_CRITERIAW OPENCARD_SEARCH_CRITERIA; +typedef POPENCARD_SEARCH_CRITERIAW POPENCARD_SEARCH_CRITERIA; +typedef LPOPENCARD_SEARCH_CRITERIAW LPOPENCARD_SEARCH_CRITERIA; +#else +typedef OPENCARD_SEARCH_CRITERIAA OPENCARD_SEARCH_CRITERIA; +typedef POPENCARD_SEARCH_CRITERIAA POPENCARD_SEARCH_CRITERIA; +typedef LPOPENCARD_SEARCH_CRITERIAA LPOPENCARD_SEARCH_CRITERIA; +#endif // UNICODE + + +// +// OPENCARDNAME_EX: used by SCardUIDlgSelectCard; replaces obsolete OPENCARDNAME +// + +typedef struct { + DWORD dwStructSize; // REQUIRED + SCARDCONTEXT hSCardContext; // REQUIRED + HWND hwndOwner; // OPTIONAL + DWORD dwFlags; // OPTIONAL -- default is SC_DLG_MINIMAL_UI + LPCSTR lpstrTitle; // OPTIONAL + LPCSTR lpstrSearchDesc; // OPTIONAL (eg. "Please insert your smart card.") + HICON hIcon; // OPTIONAL 32x32 icon for your brand insignia + POPENCARD_SEARCH_CRITERIAA pOpenCardSearchCriteria; // OPTIONAL + LPOCNCONNPROCA lpfnConnect; // OPTIONAL - performed on successful selection + LPVOID pvUserData; // OPTIONAL parameter to lpfnConnect + DWORD dwShareMode; // OPTIONAL - if lpfnConnect is NULL, dwShareMode and + DWORD dwPreferredProtocols; // OPTIONAL dwPreferredProtocols will be used to + // connect to the selected card + LPSTR lpstrRdr; // REQUIRED [IN|OUT] Name of selected reader + DWORD nMaxRdr; // REQUIRED [IN|OUT] + LPSTR lpstrCard; // REQUIRED [IN|OUT] Name of selected card + DWORD nMaxCard; // REQUIRED [IN|OUT] + DWORD dwActiveProtocol; // [OUT] set only if dwShareMode not NULL + SCARDHANDLE hCardHandle; // [OUT] set if a card connection was indicated +} OPENCARDNAME_EXA, *POPENCARDNAME_EXA, *LPOPENCARDNAME_EXA; +typedef struct { + DWORD dwStructSize; // REQUIRED + SCARDCONTEXT hSCardContext; // REQUIRED + HWND hwndOwner; // OPTIONAL + DWORD dwFlags; // OPTIONAL -- default is SC_DLG_MINIMAL_UI + LPCWSTR lpstrTitle; // OPTIONAL + LPCWSTR lpstrSearchDesc; // OPTIONAL (eg. "Please insert your smart card.") + HICON hIcon; // OPTIONAL 32x32 icon for your brand insignia + POPENCARD_SEARCH_CRITERIAW pOpenCardSearchCriteria; // OPTIONAL + LPOCNCONNPROCW lpfnConnect; // OPTIONAL - performed on successful selection + LPVOID pvUserData; // OPTIONAL parameter to lpfnConnect + DWORD dwShareMode; // OPTIONAL - if lpfnConnect is NULL, dwShareMode and + DWORD dwPreferredProtocols; // OPTIONAL dwPreferredProtocols will be used to + // connect to the selected card + LPWSTR lpstrRdr; // REQUIRED [IN|OUT] Name of selected reader + DWORD nMaxRdr; // REQUIRED [IN|OUT] + LPWSTR lpstrCard; // REQUIRED [IN|OUT] Name of selected card + DWORD nMaxCard; // REQUIRED [IN|OUT] + DWORD dwActiveProtocol; // [OUT] set only if dwShareMode not NULL + SCARDHANDLE hCardHandle; // [OUT] set if a card connection was indicated +} OPENCARDNAME_EXW, *POPENCARDNAME_EXW, *LPOPENCARDNAME_EXW; +#ifdef UNICODE +typedef OPENCARDNAME_EXW OPENCARDNAME_EX; +typedef POPENCARDNAME_EXW POPENCARDNAME_EX; +typedef LPOPENCARDNAME_EXW LPOPENCARDNAME_EX; +#else +typedef OPENCARDNAME_EXA OPENCARDNAME_EX; +typedef POPENCARDNAME_EXA POPENCARDNAME_EX; +typedef LPOPENCARDNAME_EXA LPOPENCARDNAME_EX; +#endif // UNICODE + +#define OPENCARDNAMEA_EX OPENCARDNAME_EXA +#define OPENCARDNAMEW_EX OPENCARDNAME_EXW +#define POPENCARDNAMEA_EX POPENCARDNAME_EXA +#define POPENCARDNAMEW_EX POPENCARDNAME_EXW +#define LPOPENCARDNAMEA_EX LPOPENCARDNAME_EXA +#define LPOPENCARDNAMEW_EX LPOPENCARDNAME_EXW + + +// +// SCardUIDlgSelectCard replaces GetOpenCardName +// + +extern WINSCARDAPI LONG WINAPI +SCardUIDlgSelectCardA( + LPOPENCARDNAMEA_EX); +extern WINSCARDAPI LONG WINAPI +SCardUIDlgSelectCardW( + LPOPENCARDNAMEW_EX); +#ifdef UNICODE +#define SCardUIDlgSelectCard SCardUIDlgSelectCardW +#else +#define SCardUIDlgSelectCard SCardUIDlgSelectCardA +#endif // !UNICODE + + +// +// "Smart Card Common Dialog" definitions for backwards compatibility +// with the Smart Card Base Services SDK version 1.0 +// + +typedef struct { + DWORD dwStructSize; + HWND hwndOwner; + SCARDCONTEXT hSCardContext; + LPSTR lpstrGroupNames; + DWORD nMaxGroupNames; + LPSTR lpstrCardNames; + DWORD nMaxCardNames; + LPCGUID rgguidInterfaces; + DWORD cguidInterfaces; + LPSTR lpstrRdr; + DWORD nMaxRdr; + LPSTR lpstrCard; + DWORD nMaxCard; + LPCSTR lpstrTitle; + DWORD dwFlags; + LPVOID pvUserData; + DWORD dwShareMode; + DWORD dwPreferredProtocols; + DWORD dwActiveProtocol; + LPOCNCONNPROCA lpfnConnect; + LPOCNCHKPROC lpfnCheck; + LPOCNDSCPROC lpfnDisconnect; + SCARDHANDLE hCardHandle; +} OPENCARDNAMEA, *POPENCARDNAMEA, *LPOPENCARDNAMEA; +typedef struct { + DWORD dwStructSize; + HWND hwndOwner; + SCARDCONTEXT hSCardContext; + LPWSTR lpstrGroupNames; + DWORD nMaxGroupNames; + LPWSTR lpstrCardNames; + DWORD nMaxCardNames; + LPCGUID rgguidInterfaces; + DWORD cguidInterfaces; + LPWSTR lpstrRdr; + DWORD nMaxRdr; + LPWSTR lpstrCard; + DWORD nMaxCard; + LPCWSTR lpstrTitle; + DWORD dwFlags; + LPVOID pvUserData; + DWORD dwShareMode; + DWORD dwPreferredProtocols; + DWORD dwActiveProtocol; + LPOCNCONNPROCW lpfnConnect; + LPOCNCHKPROC lpfnCheck; + LPOCNDSCPROC lpfnDisconnect; + SCARDHANDLE hCardHandle; +} OPENCARDNAMEW, *POPENCARDNAMEW, *LPOPENCARDNAMEW; +#ifdef UNICODE +typedef OPENCARDNAMEW OPENCARDNAME; +typedef POPENCARDNAMEW POPENCARDNAME; +typedef LPOPENCARDNAMEW LPOPENCARDNAME; +#else +typedef OPENCARDNAMEA OPENCARDNAME; +typedef POPENCARDNAMEA POPENCARDNAME; +typedef LPOPENCARDNAMEA LPOPENCARDNAME; +#endif // UNICODE + +// Backwards compatibility macros +#define OPENCARDNAME_A OPENCARDNAMEA +#define OPENCARDNAME_W OPENCARDNAMEW +#define POPENCARDNAME_A POPENCARDNAMEA +#define POPENCARDNAME_W POPENCARDNAMEW +#define LPOPENCARDNAME_A LPOPENCARDNAMEA +#define LPOPENCARDNAME_W LPOPENCARDNAMEW + +extern WINSCARDAPI LONG WINAPI +GetOpenCardNameA( + LPOPENCARDNAMEA); +extern WINSCARDAPI LONG WINAPI +GetOpenCardNameW( + LPOPENCARDNAMEW); +#ifdef UNICODE +#define GetOpenCardName GetOpenCardNameW +#else +#define GetOpenCardName GetOpenCardNameA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardDlgExtendedError (void); + +#if (NTDDI_VERSION >= NTDDI_VISTA) + +// +// Smartcard Caching API +// + +extern WINSCARDAPI LONG WINAPI +SCardReadCacheA( + __in SCARDCONTEXT hContext, + __in UUID *CardIdentifier, + __in DWORD FreshnessCounter, + __in LPSTR LookupName, + __out_bcount(*DataLen) PBYTE Data, + __out DWORD *DataLen); +extern WINSCARDAPI LONG WINAPI +SCardReadCacheW( + __in SCARDCONTEXT hContext, + __in UUID *CardIdentifier, + __in DWORD FreshnessCounter, + __in LPWSTR LookupName, + __out_bcount(*DataLen) PBYTE Data, + __out DWORD *DataLen); +#ifdef UNICODE +#define SCardReadCache SCardReadCacheW +#else +#define SCardReadCache SCardReadCacheA +#endif // !UNICODE + +extern WINSCARDAPI LONG WINAPI +SCardWriteCacheA( + __in SCARDCONTEXT hContext, + __in UUID *CardIdentifier, + __in DWORD FreshnessCounter, + __in LPSTR LookupName, + __in_bcount(DataLen) PBYTE Data, + __in DWORD DataLen); +extern WINSCARDAPI LONG WINAPI +SCardWriteCacheW( + __in SCARDCONTEXT hContext, + __in UUID *CardIdentifier, + __in DWORD FreshnessCounter, + __in LPWSTR LookupName, + __in_bcount(DataLen) PBYTE Data, + __in DWORD DataLen); +#ifdef UNICODE +#define SCardWriteCache SCardWriteCacheW +#else +#define SCardWriteCache SCardWriteCacheA +#endif // !UNICODE + +#endif // (NTDDI_VERSION >= NTDDI_VISTA) + +#ifdef __cplusplus +} +#endif +#endif // _WINSCARD_H_ + + ADDED build/cackey_win64_build/include/winsmcrd.h Index: build/cackey_win64_build/include/winsmcrd.h ================================================================== --- /dev/null +++ build/cackey_win64_build/include/winsmcrd.h @@ -0,0 +1,331 @@ +/*++ + +Copyright (c) 1996 Microsoft Corporation + +Module Name: + + winsmcrd.h + +Abstract: + Smart Card class/port IOCTL codes. This file is required for all code + user mode and kernel mode, using Smart Card IOCTL's, defines, + data structures + +Revision History: + +--*/ + + +#ifndef _NTDDSCRD_H2_ +#define _NTDDSCRD_H2_ + +#if defined (_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _WINSCARD_H_ +typedef DWORD ULONG; +typedef WORD UWORD; +typedef BYTE UCHAR; +#else +typedef ULONG DWORD; +// typedef UWORD WORD; +typedef UCHAR BYTE; +#endif + +#ifndef DEVICE_TYPE_SMARTCARD +#define FILE_DEVICE_SMARTCARD 0x00000031 +#else +#if 0x00000031 != FILE_DEVICE_SMARTCARD +#error "Incorrect Smart Card Device Definition" +#endif +#endif + + +// +// Various constants +// + +#define SCARD_ATR_LENGTH 33 // ISO 7816-3 spec. + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Protocol Flag definitions +// + +#define SCARD_PROTOCOL_UNDEFINED 0x00000000 // There is no active protocol. +#define SCARD_PROTOCOL_T0 0x00000001 // T=0 is the active protocol. +#define SCARD_PROTOCOL_T1 0x00000002 // T=1 is the active protocol. +#define SCARD_PROTOCOL_RAW 0x00010000 // Raw is the active protocol. +// +// This is the mask of ISO defined transmission protocols +// +#define SCARD_PROTOCOL_Tx (SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1) +// +// Use the default transmission parameters / card clock freq. +// +#define SCARD_PROTOCOL_DEFAULT 0x80000000 +// +// Use optimal transmission parameters / card clock freq. +// Since using the optimal parameters is the default case no bit is defined to be 1 +// +#define SCARD_PROTOCOL_OPTIMAL 0x00000000 + + +// +// Ioctl parameters 1 for IOCTL_SMARTCARD_POWER +// +#define SCARD_POWER_DOWN 0 // Power down the card. +#define SCARD_COLD_RESET 1 // Cycle power and reset the card. +#define SCARD_WARM_RESET 2 // Force a reset on the card. + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Reader Action IOCTLs +// + +#define SCARD_CTL_CODE(code) CTL_CODE(FILE_DEVICE_SMARTCARD, \ + (code), \ + METHOD_BUFFERED, \ + FILE_ANY_ACCESS) + +#define IOCTL_SMARTCARD_POWER SCARD_CTL_CODE( 1) +#define IOCTL_SMARTCARD_GET_ATTRIBUTE SCARD_CTL_CODE( 2) +#define IOCTL_SMARTCARD_SET_ATTRIBUTE SCARD_CTL_CODE( 3) +#define IOCTL_SMARTCARD_CONFISCATE SCARD_CTL_CODE( 4) +#define IOCTL_SMARTCARD_TRANSMIT SCARD_CTL_CODE( 5) +#define IOCTL_SMARTCARD_EJECT SCARD_CTL_CODE( 6) +#define IOCTL_SMARTCARD_SWALLOW SCARD_CTL_CODE( 7) +// #define IOCTL_SMARTCARD_READ SCARD_CTL_CODE( 8) obsolete +// #define IOCTL_SMARTCARD_WRITE SCARD_CTL_CODE( 9) obsolete +#define IOCTL_SMARTCARD_IS_PRESENT SCARD_CTL_CODE(10) +#define IOCTL_SMARTCARD_IS_ABSENT SCARD_CTL_CODE(11) +#define IOCTL_SMARTCARD_SET_PROTOCOL SCARD_CTL_CODE(12) +#define IOCTL_SMARTCARD_GET_STATE SCARD_CTL_CODE(14) +#define IOCTL_SMARTCARD_GET_LAST_ERROR SCARD_CTL_CODE(15) +#define IOCTL_SMARTCARD_GET_PERF_CNTR SCARD_CTL_CODE(16) + + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Tags for requesting card and reader attributes +// + +#define MAXIMUM_ATTR_STRING_LENGTH 32 // Nothing bigger than this from getAttr +#define MAXIMUM_SMARTCARD_READERS 10 // Limit the readers on the system + +#define SCARD_ATTR_VALUE(Class, Tag) ((((ULONG)(Class)) << 16) | ((ULONG)(Tag))) + +#define SCARD_CLASS_VENDOR_INFO 1 // Vendor information definitions +#define SCARD_CLASS_COMMUNICATIONS 2 // Communication definitions +#define SCARD_CLASS_PROTOCOL 3 // Protocol definitions +#define SCARD_CLASS_POWER_MGMT 4 // Power Management definitions +#define SCARD_CLASS_SECURITY 5 // Security Assurance definitions +#define SCARD_CLASS_MECHANICAL 6 // Mechanical characteristic definitions +#define SCARD_CLASS_VENDOR_DEFINED 7 // Vendor specific definitions +#define SCARD_CLASS_IFD_PROTOCOL 8 // Interface Device Protocol options +#define SCARD_CLASS_ICC_STATE 9 // ICC State specific definitions +#define SCARD_CLASS_PERF 0x7ffe // performace counters +#define SCARD_CLASS_SYSTEM 0x7fff // System-specific definitions + +#define SCARD_ATTR_VENDOR_NAME SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0100) +#define SCARD_ATTR_VENDOR_IFD_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0101) +#define SCARD_ATTR_VENDOR_IFD_VERSION SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0102) +#define SCARD_ATTR_VENDOR_IFD_SERIAL_NO SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0103) +#define SCARD_ATTR_CHANNEL_ID SCARD_ATTR_VALUE(SCARD_CLASS_COMMUNICATIONS, 0x0110) +#define SCARD_ATTR_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120) +// #define SCARD_ATTR_ASYNC_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120) +#define SCARD_ATTR_DEFAULT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0121) +#define SCARD_ATTR_MAX_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0122) +#define SCARD_ATTR_DEFAULT_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0123) +#define SCARD_ATTR_MAX_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0124) +#define SCARD_ATTR_MAX_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0125) +// #define SCARD_ATTR_SYNC_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0126) +#define SCARD_ATTR_POWER_MGMT_SUPPORT SCARD_ATTR_VALUE(SCARD_CLASS_POWER_MGMT, 0x0131) +#define SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0140) +#define SCARD_ATTR_USER_AUTH_INPUT_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0142) +#define SCARD_ATTR_CHARACTERISTICS SCARD_ATTR_VALUE(SCARD_CLASS_MECHANICAL, 0x0150) + +#define SCARD_ATTR_CURRENT_PROTOCOL_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0201) +#define SCARD_ATTR_CURRENT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0202) +#define SCARD_ATTR_CURRENT_F SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0203) +#define SCARD_ATTR_CURRENT_D SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0204) +#define SCARD_ATTR_CURRENT_N SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0205) +#define SCARD_ATTR_CURRENT_W SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0206) +#define SCARD_ATTR_CURRENT_IFSC SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0207) +#define SCARD_ATTR_CURRENT_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0208) +#define SCARD_ATTR_CURRENT_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0209) +#define SCARD_ATTR_CURRENT_CWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020a) +#define SCARD_ATTR_CURRENT_EBC_ENCODING SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020b) +#define SCARD_ATTR_EXTENDED_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020c) + +#define SCARD_ATTR_ICC_PRESENCE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0300) +#define SCARD_ATTR_ICC_INTERFACE_STATUS SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0301) +#define SCARD_ATTR_CURRENT_IO_STATE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0302) +#define SCARD_ATTR_ATR_STRING SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0303) +#define SCARD_ATTR_ICC_TYPE_PER_ATR SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0304) + +#define SCARD_ATTR_ESC_RESET SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA000) +#define SCARD_ATTR_ESC_CANCEL SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA003) +#define SCARD_ATTR_ESC_AUTHREQUEST SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA005) +#define SCARD_ATTR_MAXINPUT SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA007) + +#define SCARD_ATTR_DEVICE_UNIT SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0001) +#define SCARD_ATTR_DEVICE_IN_USE SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0002) +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0003) +#define SCARD_ATTR_DEVICE_SYSTEM_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0004) +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0005) +#define SCARD_ATTR_DEVICE_SYSTEM_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0006) +#define SCARD_ATTR_SUPRESS_T1_IFS_REQUEST SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0007) + +#define SCARD_PERF_NUM_TRANSMISSIONS SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0001) +#define SCARD_PERF_BYTES_TRANSMITTED SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0002) +#define SCARD_PERF_TRANSMISSION_TIME SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0003) + +#ifdef UNICODE +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_W +#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_W +#else +#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_A +#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_A +#endif + + +// +// T=0 Protocol Defines +// + +#define SCARD_T0_HEADER_LENGTH 7 +#define SCARD_T0_CMD_LENGTH 5 + + +// +// T=1 Protocol Defines +// + +#define SCARD_T1_PROLOGUE_LENGTH 3 +#define SCARD_T1_EPILOGUE_LENGTH 2 +#define SCARD_T1_MAX_IFS 254 + + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Reader states +// + +#define SCARD_UNKNOWN 0 // This value implies the driver is unaware + // of the current state of the reader. +#define SCARD_ABSENT 1 // This value implies there is no card in + // the reader. +#define SCARD_PRESENT 2 // This value implies there is a card is + // present in the reader, but that it has + // not been moved into position for use. +#define SCARD_SWALLOWED 3 // This value implies there is a card in the + // reader in position for use. The card is + // not powered. +#define SCARD_POWERED 4 // This value implies there is power is + // being provided to the card, but the + // Reader Driver is unaware of the mode of + // the card. +#define SCARD_NEGOTIABLE 5 // This value implies the card has been + // reset and is awaiting PTS negotiation. +#define SCARD_SPECIFIC 6 // This value implies the card has been + // reset and specific communication + // protocols have been established. + +//////////////////////////////////////////////////////////////////////////////// +// +// I/O Services +// +// The following services provide access to the I/O capabilities of the +// reader drivers. Services of the Smart Card are requested by placing the +// following structure into the protocol buffer: +// + + +typedef struct _SCARD_IO_REQUEST{ + DWORD dwProtocol; // Protocol identifier + DWORD cbPciLength; // Protocol Control Information Length +} SCARD_IO_REQUEST, *PSCARD_IO_REQUEST, *LPSCARD_IO_REQUEST; +typedef const SCARD_IO_REQUEST *LPCSCARD_IO_REQUEST; + + +// +// T=0 protocol services. +// + +typedef struct { + BYTE + bCla, // The instruction class + bIns, // The instruction code within the instruction class + bP1, + bP2, // Parameters to the instruction + bP3; // Size of I/O Transfer +} SCARD_T0_COMMAND, *LPSCARD_T0_COMMAND; + +typedef struct { + SCARD_IO_REQUEST ioRequest; + BYTE + bSw1, + bSw2; // Return codes from the instruction + union + { + SCARD_T0_COMMAND CmdBytes; + BYTE rgbHeader[5]; + } DUMMYUNIONNAME; +} SCARD_T0_REQUEST; + +typedef SCARD_T0_REQUEST *PSCARD_T0_REQUEST, *LPSCARD_T0_REQUEST; + + +// +// T=1 Protocol Services +// + +typedef struct { + SCARD_IO_REQUEST ioRequest; +} SCARD_T1_REQUEST; +typedef SCARD_T1_REQUEST *PSCARD_T1_REQUEST, *LPSCARD_T1_REQUEST; + + +// +//////////////////////////////////////////////////////////////////////////////// +// +// Driver attribute flags +// + +#define SCARD_READER_SWALLOWS 0x00000001 // Reader has a card swallowing + // mechanism. +#define SCARD_READER_EJECTS 0x00000002 // Reader has a card ejection + // mechanism. +#define SCARD_READER_CONFISCATES 0x00000004 // Reader has a card capture + // mechanism. + +// +/////////////////////////////////////////////////////////////////////////////// +// +// Type of reader +// +#define SCARD_READER_TYPE_SERIAL 0x01 +#define SCARD_READER_TYPE_PARALELL 0x02 +#define SCARD_READER_TYPE_KEYBOARD 0x04 +#define SCARD_READER_TYPE_SCSI 0x08 +#define SCARD_READER_TYPE_IDE 0x10 +#define SCARD_READER_TYPE_USB 0x20 +#define SCARD_READER_TYPE_PCMCIA 0x40 +#define SCARD_READER_TYPE_VENDOR 0xF0 + +#ifdef __cplusplus +} +#endif +#endif + + Index: build/cackey_win64_build/include/zconf.h ================================================================== --- build/cackey_win64_build/include/zconf.h +++ build/cackey_win64_build/include/zconf.h @@ -409,11 +409,11 @@ typedef Z_U4 z_crc_t; #else typedef unsigned long z_crc_t; #endif -#if 1 /* was set to #if 1 by ./configure */ +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ # define Z_HAVE_UNISTD_H #endif #if 1 /* was set to #if 1 by ./configure */ # define Z_HAVE_STDARG_H Index: build/cackey_win64_build/lib/libz.a ================================================================== --- build/cackey_win64_build/lib/libz.a +++ build/cackey_win64_build/lib/libz.a cannot compute difference between binary files ADDED build/cackey_win64_build/lib/winscard.dll Index: build/cackey_win64_build/lib/winscard.dll ================================================================== --- /dev/null +++ build/cackey_win64_build/lib/winscard.dll cannot compute difference between binary files ADDED build/cackey_win64_build/lib/winscard.lib Index: build/cackey_win64_build/lib/winscard.lib ================================================================== --- /dev/null +++ build/cackey_win64_build/lib/winscard.lib cannot compute difference between binary files Index: cackey.c ================================================================== --- cackey.c +++ cackey.c @@ -42,13 +42,10 @@ #else # ifdef HAVE_LIBZ # undef HAVE_LIBZ # endif #endif -#ifdef CACKEY_DEBUG_SEARCH_SPEEDTEST -# include -#endif #define CK_PTR * #define CK_DEFINE_FUNCTION(returnType, name) returnType name #define CK_DECLARE_FUNCTION(returnType, name) returnType name #define CK_DECLARE_FUNCTION_POINTER(returnType, name) returnType (* name) @@ -175,75 +172,30 @@ #ifdef CACKEY_DEBUG # ifdef HAVE_TIME_H # include static time_t cackey_debug_start_time = 0; -# define CACKEY_DEBUG_PRINTTIME { if (cackey_debug_start_time == 0) { cackey_debug_start_time = time(NULL); }; fprintf(cackey_debug_fd(), "[%lu]: ", (unsigned long) (time(NULL) - cackey_debug_start_time)); } +# define CACKEY_DEBUG_PRINTTIME { if (cackey_debug_start_time == 0) { cackey_debug_start_time = time(NULL); }; fprintf(stderr, "[%lu]: ", (unsigned long) (time(NULL) - cackey_debug_start_time)); } # else # define CACKEY_DEBUG_PRINTTIME /**/ # endif -# define CACKEY_DEBUG_PRINTF(x...) { CACKEY_DEBUG_PRINTTIME; fprintf(cackey_debug_fd(), "%s():%i: ", __func__, __LINE__); fprintf(cackey_debug_fd(), x); fprintf(cackey_debug_fd(), "\n"); fflush(cackey_debug_fd()); } -# define CACKEY_DEBUG_PRINTBUF(f, x, y) { unsigned char *TMPBUF; unsigned long idx; TMPBUF = (unsigned char *) (x); CACKEY_DEBUG_PRINTTIME; fprintf(cackey_debug_fd(), "%s():%i: %s (%s/%lu = {%02x", __func__, __LINE__, f, #x, (unsigned long) (y), TMPBUF[0]); for (idx = 1; idx < (y); idx++) { fprintf(cackey_debug_fd(), ", %02x", TMPBUF[idx]); }; fprintf(cackey_debug_fd(), "})\n"); fflush(cackey_debug_fd()); } -# define CACKEY_DEBUG_PERROR(x) { fprintf(cackey_debug_fd(), "%s():%i: ", __func__, __LINE__); CACKEY_DEBUG_PRINTTIME; perror(x); fflush(cackey_debug_fd()); } -# define free(x) { CACKEY_DEBUG_PRINTF("FREE(%p) (%s)", (void *) x, #x); free(x); } - -static FILE *cackey_debug_fd(void) { - static FILE *fd = NULL; - char *logfile; - - if (fd != NULL) { - return(fd); - } - - /* - * Log to stderr initially so we can use debugging within - * this function without getting into an infinite loop - */ - fd = stderr; - - logfile = getenv("CACKEY_DEBUG_LOGFILE"); - if (logfile != NULL) { - CACKEY_DEBUG_PRINTF("Found environment variable: %s", logfile); - - logfile = strchr(logfile, '='); - if (logfile == NULL) { - logfile = getenv("CACKEY_DEBUG_LOGFILE"); - } else { - logfile++; - } - } - - if (logfile != NULL) { - CACKEY_DEBUG_PRINTF("Found log file: %s", logfile); - - fd = fopen(logfile, "a"); - } - - if (fd == NULL) { - fd = stderr; - } - - if (fd == stderr) { - CACKEY_DEBUG_PRINTF("Returning stderr"); - } else { - CACKEY_DEBUG_PRINTF("Returning %p", (void *) fd); - } - - return(fd); -} +# define CACKEY_DEBUG_PRINTF(x...) { CACKEY_DEBUG_PRINTTIME; fprintf(stderr, "%s():%i: ", __func__, __LINE__); fprintf(stderr, x); fprintf(stderr, "\n"); fflush(stderr); } +# define CACKEY_DEBUG_PRINTBUF(f, x, y) { unsigned char *TMPBUF; unsigned long idx; TMPBUF = (unsigned char *) (x); CACKEY_DEBUG_PRINTTIME; fprintf(stderr, "%s():%i: %s (%s/%lu = {%02x", __func__, __LINE__, f, #x, (unsigned long) (y), TMPBUF[0]); for (idx = 1; idx < (y); idx++) { fprintf(stderr, ", %02x", TMPBUF[idx]); }; fprintf(stderr, "})\n"); fflush(stderr); } +# define CACKEY_DEBUG_PERROR(x) { fprintf(stderr, "%s():%i: ", __func__, __LINE__); CACKEY_DEBUG_PRINTTIME; perror(x); fflush(stderr); } +# define free(x) { CACKEY_DEBUG_PRINTF("FREE(%p) (%s)", x, #x); free(x); } static void *CACKEY_DEBUG_FUNC_MALLOC(size_t size, const char *func, int line) { void *retval; retval = malloc(size); CACKEY_DEBUG_PRINTTIME; - fprintf(cackey_debug_fd(), "%s():%i: ", func, line); - fprintf(cackey_debug_fd(), "MALLOC() = %p", retval); - fprintf(cackey_debug_fd(), "\n"); - fflush(cackey_debug_fd()); + fprintf(stderr, "%s():%i: ", func, line); + fprintf(stderr, "MALLOC() = %p", retval); + fprintf(stderr, "\n"); + fflush(stderr); return(retval); } static void *CACKEY_DEBUG_FUNC_REALLOC(void *ptr, size_t size, const char *func, int line) { @@ -251,14 +203,14 @@ retval = realloc(ptr, size); if (retval != ptr) { CACKEY_DEBUG_PRINTTIME; - fprintf(cackey_debug_fd(), "%s():%i: ", func, line); - fprintf(cackey_debug_fd(), "REALLOC(%p) = %p", ptr, retval); - fprintf(cackey_debug_fd(), "\n"); - fflush(cackey_debug_fd()); + fprintf(stderr, "%s():%i: ", func, line); + fprintf(stderr, "REALLOC(%p) = %p", ptr, retval); + fprintf(stderr, "\n"); + fflush(stderr); } if (retval == NULL) { CACKEY_DEBUG_PRINTF(" *** ERROR *** realloc returned NULL (size = %lu)", (unsigned long) size); } @@ -270,14 +222,14 @@ char *retval; retval = strdup(ptr); CACKEY_DEBUG_PRINTTIME; - fprintf(cackey_debug_fd(), "%s():%i: ", func, line); - fprintf(cackey_debug_fd(), "STRDUP_MALLOC() = %p", retval); - fprintf(cackey_debug_fd(), "\n"); - fflush(cackey_debug_fd()); + fprintf(stderr, "%s():%i: ", func, line); + fprintf(stderr, "STRDUP_MALLOC() = %p", retval); + fprintf(stderr, "\n"); + fflush(stderr); return(retval); } static const char *CACKEY_DEBUG_FUNC_TAG_TO_STR(unsigned char tag) { @@ -714,11 +666,10 @@ struct cackey_identity *decrypt_identity; }; struct cackey_slot { int active; - int internal; char *pcsc_reader; int pcsc_card_connected; SCARDHANDLE pcsc_card; @@ -731,13 +682,10 @@ CK_FLAGS token_flags; unsigned char *label; DWORD protocol; - - unsigned int cached_certs_count; - struct cackey_pcsc_identity *cached_certs; }; typedef enum { CACKEY_TLV_APP_GENERIC = 0x01, CACKEY_TLV_APP_SKI = 0x02, @@ -862,15 +810,10 @@ uint32_t idx; CACKEY_DEBUG_PRINTF("Called."); for (idx = 0; idx < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); idx++) { - if (cackey_slots[idx].internal) { - /* Skip internal slots */ - continue; - } - if (cackey_slots[idx].pcsc_card_connected) { CACKEY_DEBUG_PRINTF("SCardDisconnect(%lu) called", (unsigned long) idx); SCardDisconnect(cackey_slots[idx].pcsc_card, SCARD_LEAVE_CARD); } @@ -2091,34 +2034,10 @@ } return; } -static struct cackey_pcsc_identity *cackey_copy_certs(struct cackey_pcsc_identity *dest, struct cackey_pcsc_identity *start, size_t count) { - size_t idx; - - if (start == NULL) { - return(NULL); - } - - if (dest == NULL) { - dest = malloc(sizeof(*dest) * count); - } - - for (idx = 0; idx < count; idx++) { - memcpy(dest[idx].applet, start[idx].applet, sizeof(dest[idx].applet)); - dest[idx].file = start[idx].file; - dest[idx].certificate_len = start[idx].certificate_len; - dest[idx].keysize = start[idx].keysize; - - dest[idx].certificate = malloc(dest[idx].certificate_len); - memcpy(dest[idx].certificate, start[idx].certificate, dest[idx].certificate_len); - } - - return(dest); -} - /* * SYNPOSIS * ... * * ARGUMENTS @@ -2155,34 +2074,10 @@ return(certs); } } - if (!slot->slot_reset) { - if (slot->cached_certs) { - if (certs == NULL) { - certs = malloc(sizeof(*certs) * slot->cached_certs_count); - *count = slot->cached_certs_count; - - } else { - if (*count > slot->cached_certs_count) { - *count = slot->cached_certs_count; - } - } - - cackey_copy_certs(certs, slot->cached_certs, *count); - - return(certs); - } - } - - if (slot->cached_certs) { - cackey_free_certs(slot->cached_certs, slot->cached_certs_count, 1); - - slot->cached_certs = NULL; - } - /* Begin a SmartCard transaction */ transaction_ret = cackey_begin_transaction(slot); if (transaction_ret != CACKEY_PCSC_S_OK) { CACKEY_DEBUG_PRINTF("Unable begin transaction, returning in failure"); @@ -2300,13 +2195,10 @@ if (certs_resizable) { certs = realloc(certs, sizeof(*certs) * (*count)); } - slot->cached_certs = cackey_copy_certs(NULL, certs, *count); - slot->cached_certs_count = *count; - /* Terminate SmartCard Transaction */ cackey_end_transaction(slot); return(certs); } @@ -2468,10 +2360,11 @@ if (send_ret == CACKEY_PCSC_E_TOKENABSENT) { CACKEY_DEBUG_PRINTF("Token absent. Returning TOKENABSENT"); cackey_mark_slot_reset(slot); + slot->token_flags = CKF_LOGIN_REQUIRED; return(CACKEY_PCSC_E_TOKENABSENT); } return(-1); @@ -2661,22 +2554,16 @@ * ... * */ static cackey_ret cackey_token_present(struct cackey_slot *slot) { cackey_ret pcsc_connect_ret; - DWORD reader_len = 0, state = 0, protocol = 0, atr_len; + DWORD reader_len, state, protocol, atr_len; BYTE atr[MAX_ATR_SIZE]; LONG status_ret, scard_reconn_ret; CACKEY_DEBUG_PRINTF("Called."); - if (slot->internal) { - CACKEY_DEBUG_PRINTF("Returning token present (internal token)"); - - return(CACKEY_PCSC_S_TOKENPRESENT); - } - pcsc_connect_ret = cackey_connect_card(slot); if (pcsc_connect_ret != CACKEY_PCSC_S_OK) { CACKEY_DEBUG_PRINTF("Unable to connect to card, returning token absent"); return(CACKEY_PCSC_E_TOKENABSENT); @@ -2762,11 +2649,11 @@ * ... * */ static ssize_t cackey_pcsc_identity_to_label(struct cackey_pcsc_identity *identity, unsigned char *label_buf, unsigned long label_buf_len) { unsigned long certificate_len; - void *label_asn1; + char *label_asn1; void *certificate; int x509_read_ret; certificate = identity->certificate; certificate_len = identity->certificate_len; @@ -3433,11 +3320,11 @@ retval = NULL; } *pulCount = numattrs; - CACKEY_DEBUG_PRINTF("Returning %lu objects (%p).", numattrs, (void *) retval); + CACKEY_DEBUG_PRINTF("Returning %lu objects (%p).", numattrs, retval); return(retval); } static void cackey_free_identities(struct cackey_identity *identities, unsigned long identities_count) { @@ -3467,91 +3354,44 @@ } free(identities); } -static unsigned long cackey_read_dod_identities(struct cackey_identity *identities, unsigned long num_dod_certs) { - unsigned long cert_idx, id_idx = 0; - - if (identities == NULL) { - return(num_dod_certs * 3); - } - - for (cert_idx = 0; cert_idx < num_dod_certs; cert_idx++) { - identities[id_idx].pcsc_identity = NULL; - identities[id_idx].attributes = cackey_get_attributes(CKO_CERTIFICATE, &extra_certs[cert_idx], 0xf000 | cert_idx, &identities[id_idx].attributes_count); - id_idx++; - - identities[id_idx].pcsc_identity = NULL; - identities[id_idx].attributes = cackey_get_attributes(CKO_PUBLIC_KEY, &extra_certs[cert_idx], 0xf000 | cert_idx, &identities[id_idx].attributes_count); - id_idx++; - - identities[id_idx].pcsc_identity = NULL; - identities[id_idx].attributes = cackey_get_attributes(CKO_NETSCAPE_TRUST, &extra_certs[cert_idx], 0xf000 | cert_idx, &identities[id_idx].attributes_count); - id_idx++; - } - - return(id_idx); -} - static struct cackey_identity *cackey_read_identities(struct cackey_slot *slot, unsigned long *ids_found) { struct cackey_pcsc_identity *pcsc_identities; struct cackey_identity *identities; unsigned long num_ids, id_idx, curr_id_type; - unsigned long num_certs, num_dod_certs, cert_idx; - int include_extra_certs = 0; + unsigned long num_certs, num_extra_certs, cert_idx; + int include_extra_certs = 1; CACKEY_DEBUG_PRINTF("Called."); + + if (getenv("CACKEY_NO_EXTRA_CERTS") != NULL) { + CACKEY_DEBUG_PRINTF("Asked not to include extra (DoD) certificates"); + + include_extra_certs = 0; + } + + if (include_extra_certs) { + num_extra_certs = sizeof(extra_certs) / sizeof(extra_certs[0]); + + CACKEY_DEBUG_PRINTF("Including %i DoD Certificates as objects on this token", num_extra_certs); + } else { + num_extra_certs = 0; + } if (ids_found == NULL) { CACKEY_DEBUG_PRINTF("Error. ids_found is NULL"); return(NULL); } -#ifdef CACKEY_CARD_SLOT_INCLUDE_EXTRA_CERTS - include_extra_certs = 1; -#endif - - if (getenv("CACKEY_DOD_CERTS_ON_HW_SLOTS") != NULL) { - include_extra_certs = 1; - } - - if (getenv("CACKEY_NO_DOD_CERTS_ON_HW_SLOTS") != NULL) { - include_extra_certs = 0; - } - - if (getenv("CACKEY_NO_EXTRA_CERTS") != NULL) { - num_dod_certs = 0; - } else { - num_dod_certs = sizeof(extra_certs) / sizeof(extra_certs[0]); - } - - if (slot->internal) { - num_ids = cackey_read_dod_identities(NULL, num_dod_certs); - - if (num_ids != 0) { - identities = malloc(num_ids * sizeof(*identities)); - - cackey_read_dod_identities(identities, num_dod_certs); - } else { - identities = NULL; - } - - *ids_found = num_ids; - - return(identities); - } - pcsc_identities = cackey_read_certs(slot, NULL, &num_certs); if (pcsc_identities != NULL) { /* Convert number of Certs to number of objects */ num_ids = (CKO_PRIVATE_KEY - CKO_CERTIFICATE + 1) * num_certs; - - if (include_extra_certs) { - num_ids += cackey_read_dod_identities(NULL, num_dod_certs); - } + num_ids += num_extra_certs * 3; identities = malloc(num_ids * sizeof(*identities)); /* Add certificates, public keys, and private keys from the smartcard */ id_idx = 0; @@ -3567,31 +3407,38 @@ id_idx++; } } - if (include_extra_certs) { - CACKEY_DEBUG_PRINTF("Including DoD Certificates on hardware slot"); - - cackey_read_dod_identities(identities + id_idx, num_dod_certs); - } - cackey_free_certs(pcsc_identities, num_certs, 1); + + /* Add DoD Certificates and Netscape Trust Objects */ + for (cert_idx = 0; cert_idx < num_extra_certs; cert_idx++) { + identities[id_idx].pcsc_identity = NULL; + identities[id_idx].attributes = cackey_get_attributes(CKO_CERTIFICATE, &extra_certs[cert_idx], 0xf000 | cert_idx, &identities[id_idx].attributes_count); + id_idx++; + + identities[id_idx].pcsc_identity = NULL; + identities[id_idx].attributes = cackey_get_attributes(CKO_PUBLIC_KEY, &extra_certs[cert_idx], 0xf000 | cert_idx, &identities[id_idx].attributes_count); + id_idx++; + + identities[id_idx].pcsc_identity = NULL; + identities[id_idx].attributes = cackey_get_attributes(CKO_NETSCAPE_TRUST, &extra_certs[cert_idx], 0xf000 | cert_idx, &identities[id_idx].attributes_count); + id_idx++; + } *ids_found = num_ids; - return(identities); } - *ids_found = 0; return(NULL); } CK_DEFINE_FUNCTION(CK_RV, C_Initialize)(CK_VOID_PTR pInitArgs) { CK_C_INITIALIZE_ARGS CK_PTR args; - uint32_t idx, highest_slot; + uint32_t idx; int mutex_init_ret; CACKEY_DEBUG_PRINTF("Called."); if (cackey_initialized) { @@ -3629,25 +3476,10 @@ cackey_slots[idx].transaction_depth = 0; cackey_slots[idx].transaction_need_hw_lock = 0; cackey_slots[idx].slot_reset = 0; cackey_slots[idx].token_flags = 0; cackey_slots[idx].label = NULL; - cackey_slots[idx].internal = 0; - } - - if (getenv("CACKEY_NO_EXTRA_CERTS") != NULL) { - CACKEY_DEBUG_PRINTF("Asked not to include DoD certificates"); - } else { - highest_slot = (sizeof(cackey_slots) / sizeof(cackey_slots[0])) - 1; - - CACKEY_DEBUG_PRINTF("Including DoD certs in slot %lu", (unsigned long) highest_slot); - - cackey_slots[highest_slot].active = 1; - cackey_slots[highest_slot].internal = 1; - cackey_slots[highest_slot].label = (unsigned char *) "DoD Certificates"; - cackey_slots[highest_slot].pcsc_reader = "CACKey"; - cackey_slots[highest_slot].token_flags = 0; } cackey_initialized = 1; if (!cackey_biglock_init) { @@ -3691,23 +3523,13 @@ } cackey_slots_disconnect_all(); for (idx = 0; idx < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); idx++) { - if (cackey_slots[idx].internal) { - continue; - } - if (cackey_slots[idx].pcsc_reader) { free(cackey_slots[idx].pcsc_reader); } - - if (cackey_slots[idx].cached_certs) { - cackey_free_certs(cackey_slots[idx].cached_certs, cackey_slots[idx].cached_certs_count, 1); - - cackey_slots[idx].cached_certs = NULL; - } } cackey_pcsc_disconnect(); cackey_initialized = 0; @@ -3756,19 +3578,17 @@ /* * Process list of readers, and create mapping between reader name and slot ID */ CK_DEFINE_FUNCTION(CK_RV, C_GetSlotList)(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount) { - static int first_call = 1; int mutex_retval; int pcsc_connect_ret; - CK_ULONG count, slot_count = 0, currslot, slot_idx; + CK_ULONG count, slot_count = 0, currslot; char *pcsc_readers, *pcsc_readers_s, *pcsc_readers_e; DWORD pcsc_readers_len; LONG scard_listreaders_ret; size_t curr_reader_len; - int slot_reset; CACKEY_DEBUG_PRINTF("Called."); if (pulCount == NULL) { CACKEY_DEBUG_PRINTF("Error. pulCount is NULL."); @@ -3788,62 +3608,30 @@ return(CKR_GENERAL_ERROR); } /* Clear list of slots */ - slot_reset = 0; - if (pSlotList) { - if (first_call) { - first_call = 0; - - slot_reset = 1; - } - - /* If any of the slots have been reset then purge all information and check again */ - for (currslot = 0; currslot < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); currslot++) { - if (cackey_slots[currslot].internal) { - continue; - } - - if (!cackey_slots[currslot].active) { - continue; - } - - if (cackey_slots[currslot].slot_reset) { - slot_reset = 1; - - break; - } - } - - if (slot_reset) { - CACKEY_DEBUG_PRINTF("Purging all slot information."); - - /* Only update the list of slots if we are actually being supply the slot information */ - cackey_slots_disconnect_all(); - - for (currslot = 0; currslot < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); currslot++) { - if (cackey_slots[currslot].internal) { - continue; - } - - if (cackey_slots[currslot].pcsc_reader) { - free(cackey_slots[currslot].pcsc_reader); - - cackey_slots[currslot].pcsc_reader = NULL; - } - - if (cackey_slots[currslot].label) { - free(cackey_slots[currslot].label); - - cackey_slots[currslot].label = NULL; - } - - cackey_slots[currslot].active = 0; - } - } else { - + if (pSlotList) { + CACKEY_DEBUG_PRINTF("Purging all slot information."); + + /* Only update the list of slots if we are actually being supply the slot information */ + cackey_slots_disconnect_all(); + + for (currslot = 0; currslot < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); currslot++) { + if (cackey_slots[currslot].pcsc_reader) { + free(cackey_slots[currslot].pcsc_reader); + + cackey_slots[currslot].pcsc_reader = NULL; + } + + if (cackey_slots[currslot].label) { + free(cackey_slots[currslot].label); + + cackey_slots[currslot].label = NULL; + } + + cackey_slots[currslot].active = 0; } } /* Determine list of readers */ pcsc_connect_ret = cackey_pcsc_connect(); @@ -3875,19 +3663,11 @@ pcsc_readers_e = pcsc_readers + pcsc_readers_len; /* Start with Slot ID 1, to avoid a bug in GDM on RHEL */ /* Bug 594911: https://bugzilla.redhat.com/show_bug.cgi?id=594911 */ currslot = 1; - slot_count = 0; while (pcsc_readers < pcsc_readers_e) { - /* Find next available slot */ - for (; currslot < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); currslot++) { - if (!cackey_slots[currslot].active) { - break; - } - } - curr_reader_len = strlen(pcsc_readers); if ((pcsc_readers + curr_reader_len) > pcsc_readers_e) { break; } @@ -3904,37 +3684,32 @@ CACKEY_DEBUG_PRINTF("Found reader: %s", pcsc_readers); /* Only update the list of slots if we are actually being asked supply the slot information */ if (pSlotList) { - if (slot_reset) { - cackey_slots[currslot].active = 1; - cackey_slots[currslot].internal = 0; - cackey_slots[currslot].pcsc_reader = strdup(pcsc_readers); - cackey_slots[currslot].pcsc_card_connected = 0; - cackey_slots[currslot].transaction_depth = 0; - cackey_slots[currslot].transaction_need_hw_lock = 0; - cackey_slots[currslot].token_flags = CKF_LOGIN_REQUIRED; - cackey_slots[currslot].label = NULL; - - cackey_mark_slot_reset(&cackey_slots[currslot]); - } - } else { - /* Artificially increase the number of active slots by what will become active */ - slot_count++; + cackey_slots[currslot].active = 1; + cackey_slots[currslot].pcsc_reader = strdup(pcsc_readers); + cackey_slots[currslot].pcsc_card_connected = 0; + cackey_slots[currslot].transaction_depth = 0; + cackey_slots[currslot].transaction_need_hw_lock = 0; + cackey_slots[currslot].slot_reset = 1; + cackey_slots[currslot].token_flags = CKF_LOGIN_REQUIRED; + cackey_slots[currslot].label = NULL; + + cackey_mark_slot_reset(&cackey_slots[currslot]); } currslot++; pcsc_readers += curr_reader_len + 1; } - for (currslot = 0; currslot < (sizeof(cackey_slots) / sizeof(cackey_slots[0])); currslot++) { - if (cackey_slots[currslot].active) { - CACKEY_DEBUG_PRINTF("Found active slot %lu", (unsigned long) currslot); - - slot_count++; - } + /* Start with Slot ID 1, to avoid a bug in GDM on RHEL */ + /* Bug 594911: https://bugzilla.redhat.com/show_bug.cgi?id=594911 */ + if (currslot > 1) { + /* Start with Slot ID 1, to avoid a bug in GDM on RHEL */ + /* Bug 594911: https://bugzilla.redhat.com/show_bug.cgi?id=594911 */ + slot_count = currslot - 1; } } else { CACKEY_DEBUG_PRINTF("Second call to SCardListReaders failed, return %s/%li", CACKEY_DEBUG_FUNC_SCARDERR_TO_STR(scard_listreaders_ret), (long) scard_listreaders_ret); } @@ -3961,43 +3736,17 @@ count = *pulCount; if (count < slot_count) { CACKEY_DEBUG_PRINTF("Error. User allocated %lu entries, but we have %lu entries.", count, slot_count); - CACKEY_DEBUG_PRINTF("Returning CKR_BUFFER_TOO_SMALL"); - return(CKR_BUFFER_TOO_SMALL); } - mutex_retval = cackey_mutex_lock(cackey_biglock); - if (mutex_retval != 0) { - CACKEY_DEBUG_PRINTF("Error. Locking failed."); - - return(CKR_GENERAL_ERROR); - } - - slot_idx = 0; - for (currslot = 0; (currslot < (sizeof(cackey_slots) / sizeof(cackey_slots[0]))); currslot++) { - if (!cackey_slots[currslot].active) { - continue; - } - - if (slot_idx >= count) { - CACKEY_DEBUG_PRINTF("Error. User allocated %lu entries, but we just tried to write to the %lu index -- ignoring", count, slot_idx); - - continue; - } - - pSlotList[slot_idx] = currslot; - slot_idx++; - } - - mutex_retval = cackey_mutex_unlock(cackey_biglock); - if (mutex_retval != 0) { - CACKEY_DEBUG_PRINTF("Error. Unlocking failed."); - - return(CKR_GENERAL_ERROR); + for (currslot = 0; currslot < slot_count; currslot++) { + /* Start with Slot ID 1, to avoid a bug in GDM on RHEL */ + /* Bug 594911: https://bugzilla.redhat.com/show_bug.cgi?id=594911 */ + pSlotList[currslot] = currslot + 1; } *pulCount = slot_count; CACKEY_DEBUG_PRINTF("Returning CKR_OK (%i). Found %lu readers.", CKR_OK, (unsigned long) slot_count); @@ -4045,15 +3794,11 @@ cackey_mutex_unlock(cackey_biglock); return(CKR_SLOT_ID_INVALID); } - pInfo->flags = CKF_HW_SLOT; - - if (!cackey_slots[slotID].internal) { - pInfo->flags |= CKF_REMOVABLE_DEVICE; - } + pInfo->flags = CKF_REMOVABLE_DEVICE | CKF_HW_SLOT; if (cackey_token_present(&cackey_slots[slotID]) == CACKEY_PCSC_S_TOKENPRESENT) { pInfo->flags |= CKF_TOKEN_PRESENT; } @@ -5215,14 +4960,10 @@ struct cackey_identity *curr_id; CK_ATTRIBUTE *curr_attr; CK_ULONG curr_id_idx, curr_out_id_idx, curr_attr_idx, sess_attr_idx; CK_ULONG matched_count, prev_matched_count; int mutex_retval; -#ifdef CACKEY_DEBUG_SEARCH_SPEEDTEST - struct timeval start, end; - uint64_t start_int, end_int; -#endif CACKEY_DEBUG_PRINTF("Called."); if (!cackey_initialized) { CACKEY_DEBUG_PRINTF("Error. Not initialized."); @@ -5284,14 +5025,10 @@ CACKEY_DEBUG_PRINTF("Error. Search not active."); return(CKR_OPERATION_NOT_INITIALIZED); } -#ifdef CACKEY_DEBUG_SEARCH_SPEEDTEST - gettimeofday(&start, NULL); -#endif - curr_out_id_idx = 0; for (curr_id_idx = cackey_sessions[hSession].search_curr_id; curr_id_idx < cackey_sessions[hSession].identities_count && ulMaxObjectCount; curr_id_idx++) { curr_id = &cackey_sessions[hSession].identities[curr_id_idx]; CACKEY_DEBUG_PRINTF("Processing identity:%lu", (unsigned long) curr_id_idx); @@ -5333,17 +5070,10 @@ } } cackey_sessions[hSession].search_curr_id = curr_id_idx; *pulObjectCount = curr_out_id_idx; -#ifdef CACKEY_DEBUG_SEARCH_SPEEDTEST - gettimeofday(&end, NULL); - start_int = (start.tv_sec * 1000000) + start.tv_usec; - end_int = (end.tv_sec * 1000000) + end.tv_usec; - fprintf(stderr, "Search took %lu microseconds\n", (unsigned long) (end_int - start_int)); -#endif - mutex_retval = cackey_mutex_unlock(cackey_biglock); if (mutex_retval != 0) { CACKEY_DEBUG_PRINTF("Error. Unlocking failed."); return(CKR_GENERAL_ERROR); @@ -5973,11 +5703,11 @@ cackey_sessions[hSession].sign_buflen = 128; cackey_sessions[hSession].sign_bufused = 0; cackey_sessions[hSession].sign_buf = malloc(sizeof(*cackey_sessions[hSession].sign_buf) * cackey_sessions[hSession].sign_buflen); - CACKEY_DEBUG_PRINTF("Session %lu sign_identity is %p (identity #%lu)", (unsigned long) hSession, (void *) &cackey_sessions[hSession].identities[hKey], (unsigned long) hKey); + CACKEY_DEBUG_PRINTF("Session %lu sign_identity is %p (identity #%lu)", (unsigned long) hSession, &cackey_sessions[hSession].identities[hKey], (unsigned long) hKey); cackey_sessions[hSession].sign_identity = &cackey_sessions[hSession].identities[hKey]; mutex_retval = cackey_mutex_unlock(cackey_biglock); if (mutex_retval != 0) { CACKEY_DEBUG_PRINTF("Error. Unlocking failed."); @@ -6235,11 +5965,11 @@ } switch (cackey_sessions[hSession].sign_mechanism) { case CKM_RSA_PKCS: /* Ask card to sign */ - CACKEY_DEBUG_PRINTF("Asking to sign from identity %p in session %lu", (void *) cackey_sessions[hSession].sign_identity, (unsigned long) hSession); + CACKEY_DEBUG_PRINTF("Asking to sign from identity %p in session %lu", cackey_sessions[hSession].sign_identity, (unsigned long) hSession); sigbuflen = cackey_signdecrypt(&cackey_slots[slotID], cackey_sessions[hSession].sign_identity, cackey_sessions[hSession].sign_buf, cackey_sessions[hSession].sign_bufused, sigbuf, sizeof(sigbuf), 1, 0); if (sigbuflen < 0) { /* Signing failed. */ if (sigbuflen == CACKEY_PCSC_E_NEEDLOGIN) { Index: configure.ac ================================================================== --- configure.ac +++ configure.ac @@ -1,6 +1,6 @@ -AC_INIT(cackey, 0.6.8) +AC_INIT(cackey, 0.6.6) AC_CONFIG_HEADERS(config.h) dnl Locate standard tools AC_PROG_CC AC_PROG_MAKE_SET @@ -130,32 +130,20 @@ DWORD dwActiveProtocol; LONG scard_conn_ret, scard_est_context_ret; scard_est_context_ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext); - hCard = NULL; - scard_conn_ret = SCardConnect(hContext, "Reader X", SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, hCard, &dwActiveProtocol); + scard_conn_ret = SCardConnect(hContext, "Reader X", SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &hCard, &dwActiveProtocol); ]]), [ AC_MSG_RESULT(okay) ], [ AC_MSG_RESULT(failed) AC_MSG_FAILURE([simple PC/SC program failed]) ] ) -dnl Option to enable DoD certs on hardware slot -AC_ARG_ENABLE(dod-certs-on-hw-slots, AC_HELP_STRING([--enable-dod-certs-on-hw-slots], [Specify that DoD certificates should be made available on hardware token slots]), [ - dodcertsonhwslots=$enableval -], [ - dodcertsonhwslots=no -]) - -if ! test "${dodcertsonhwslots}" = 'no'; then - AC_DEFINE(CACKEY_CARD_SLOT_INCLUDE_EXTRA_CERTS, [1], [Specify that DoD certificates should be made available on hardware token slots]) -fi - dnl Set version script, to limit the scope of symbols DC_SETVERSIONSCRIPT(libcackey.vers, libcackey.syms) dnl Upate LDFLAGS to include setting the run-time linker path to the same as our compile-time linker DC_SYNC_RPATH Index: test.c ================================================================== --- test.c +++ test.c @@ -236,11 +236,10 @@ chk_rv = C_GetSlotInfo(slots[currSlot], &slotInfo); if (chk_rv != CKR_OK) { return(1); } - printf(" Id : %lu\n", (unsigned long) slots[currSlot]); printf(" Desc : %.*s\n", 32, slotInfo.slotDescription); printf(" ManufID: %.*s\n", 32, slotInfo.manufacturerID); printf(" HWVers : %i.%i\n", slotInfo.hardwareVersion.major, slotInfo.hardwareVersion.minor); printf(" FWVers : %i.%i\n", slotInfo.firmwareVersion.major, slotInfo.firmwareVersion.minor); printf(" Flags : "); @@ -328,15 +327,10 @@ } } chk_rv = C_OpenSession(slots[0], CKF_SERIAL_SESSION, NULL, NULL, &hSession); if (chk_rv == CKR_OK) { - chk_rv = C_GetTokenInfo(slots[0], &tokenInfo); - if (chk_rv != CKR_OK) { - return(1); - } - if ((tokenInfo.flags & CKF_LOGIN_REQUIRED) == CKF_LOGIN_REQUIRED) { fgets_ret = NULL; while (fgets_ret == NULL) { printf("** ENTER PIN: ");