PyKCS11-1.2.4/0000755000175000017500000000000011744467602014362 5ustar rousseaurousseau00000000000000PyKCS11-1.2.4/src/0000755000175000017500000000000011744467602015151 5ustar rousseaurousseau00000000000000PyKCS11-1.2.4/src/dyn_unix.c0000644000175000017500000000342211277563365017157 0ustar rousseaurousseau00000000000000/* * This abstracts dynamic library loading functions and timing. * * MUSCLE SmartCard Development ( http://www.linuxnet.com ) * * Copyright (C) 1999 * David Corcoran * Copyright (C) 2004 * Ludovic Rousseau * * $Id: dyn_unix.c,v 1.13 2005/02/22 14:40:26 rousseau Exp $ */ //#include "config.h" #define HAVE_DLFCN_H #include #include #if defined(HAVE_DLFCN_H) && !defined(HAVE_DL_H) #include #include #include "dyn_generic.h" #define Log2(a, b) printf("%s:%d:%s() " a "\n", __FILE__, __LINE__, __FUNCTION__, b); #define Log3(a, b, c) printf("%s:%d:%s() " a "\n", __FILE__, __LINE__, __FUNCTION__, b, c); int SYS_dyn_LoadLibrary(void **handle, const char *library_name) { *handle = NULL; *handle = dlopen(library_name, RTLD_NOW); if (*handle == NULL) { Log2("%s", dlerror()); return -1; } return 0; } /* SYS_dyn_LoadLibrary */ int SYS_dyn_CloseLibrary(void **handle) { int ret; ret = dlclose(*handle); *handle = NULL; if (ret) { Log2("%s", dlerror()); return -1; } return 0; } /* SYS_dyn_CloseLibrary */ int SYS_dyn_GetAddress(void *handle, function_ptr *func_ptr, const char *function_name) { char new_function_name[256]; int rv; /* Some platforms might need a leading underscore for the symbol */ snprintf(new_function_name, sizeof(new_function_name), "_%s", function_name); *func_ptr = NULL; *func_ptr = dlsym(handle, new_function_name); /* Failed? Try again without the leading underscore */ if (*func_ptr == NULL) *func_ptr = dlsym(handle, function_name); if (*func_ptr == NULL) { Log3("%s: %s", function_name, dlerror()); rv = -1; } else rv = 0; return rv; } /* SYS_dyn_GetAddress */ #endif /* HAVE_DLFCN_H && !HAVE_DL_H && !__APPLE__ */ PyKCS11-1.2.4/src/utility.h0000644000175000017500000000242511055022763017016 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #ifndef _UTILITY_H__DEFINED_ #define _UTILITY_H__DEFINED_ unsigned char * Vector2Buffer(vector &Buf, CK_ULONG &Len); CK_ATTRIBUTE_PTR AttrVector2Template(vector &Attr, CK_ULONG &Len); void Template2AttrVector(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG Len, vector &Attr); void DestroyTemplate(CK_ATTRIBUTE_PTR &pTemplate, CK_ULONG Len); void Buffer2Vector(unsigned char* pBuf, CK_ULONG Len, vector &Buf, bool bAllocIfNull); #endif //_UTILITY_H__DEFINED_ PyKCS11-1.2.4/src/pkcs11lib.cpp0000644000175000017500000005737211406076773017464 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2008 Ludovic Rousseau // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include "stdafx.h" #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" #include "utility.h" #include #include "dyn_generic.h" #define CPKCS11LIB_PROLOGUE(FUNCTION_NAME) \ bool bRetryed = false; \ Retry: \ CK_RV rv; \ rv = CKR_OK; \ if (!m_hLib || !m_pFunc) \ return CKR_CRYPTOKI_NOT_INITIALIZED; #define CPKCS11LIB_EPILOGUE if (!bRetryed && m_hLib && m_pFunc && m_bAutoInitialized && \ CKR_CRYPTOKI_NOT_INITIALIZED == rv) { \ m_pFunc->C_Initialize(NULL); \ bRetryed=true; \ goto Retry; \ } CPKCS11Lib::CPKCS11Lib(void): m_bFinalizeOnClose(false), m_bAutoInitialized(false), m_hLib(0), m_pFunc(NULL) { } CPKCS11Lib::~CPKCS11Lib(void) { Unload(); } bool CPKCS11Lib::Load(const char* szLib, bool bAutoCallInitialize) { CK_RV rv; Unload(); SYS_dyn_LoadLibrary((void**)&m_hLib, szLib); //m_hLib = LoadLibrary(szLib); if (!m_hLib) return false; CK_C_GetFunctionList pC_GetFunctionList; SYS_dyn_GetAddress(m_hLib, (function_ptr *)&pC_GetFunctionList, "C_GetFunctionList"); if (!pC_GetFunctionList) { SYS_dyn_CloseLibrary((void**)&m_hLib); return false; } rv = pC_GetFunctionList(&m_pFunc); if (CKR_OK != rv || !m_pFunc) { SYS_dyn_CloseLibrary((void**)&m_hLib); return false; } if (bAutoCallInitialize) { CK_INFO infos; if (m_pFunc->C_GetInfo(&infos) == CKR_CRYPTOKI_NOT_INITIALIZED) { m_bAutoInitialized = m_bFinalizeOnClose = CKR_OK == m_pFunc->C_Initialize(NULL); } else m_bAutoInitialized = true; } return true; } bool CPKCS11Lib::Unload() { bool bRes = false; if (m_hLib && m_pFunc && m_bFinalizeOnClose) m_pFunc->C_Finalize(NULL); if (m_hLib) { bRes = true; SYS_dyn_CloseLibrary((void**)&m_hLib); } m_hLib = 0; m_pFunc = NULL; m_bFinalizeOnClose = false; return bRes; } CK_RV CPKCS11Lib::C_Initialize() { CPKCS11LIB_PROLOGUE(C_Initialize); rv = m_pFunc->C_Initialize(NULL); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Finalize() { CPKCS11LIB_PROLOGUE(C_Finalize); rv = m_pFunc->C_Finalize(NULL); if (CKR_OK == rv) m_bFinalizeOnClose = false; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GetInfo(CK_INFO* pInfo) { CK_RV rv; if (!m_pFunc) rv = CKR_CRYPTOKI_NOT_INITIALIZED; else rv = m_pFunc->C_GetInfo(pInfo); return rv; } CK_RV CPKCS11Lib::C_GetSlotList( unsigned char tokenPresent, vector& slotList) { CPKCS11LIB_PROLOGUE(C_GetSlotList); CK_ULONG i; slotList.clear(); CK_SLOT_ID ck_slotList[1024]; CK_ULONG ulSlotCount = sizeof(ck_slotList)/sizeof(ck_slotList[0]); rv = m_pFunc->C_GetSlotList(tokenPresent, ck_slotList, &ulSlotCount); if (CKR_OK == rv) for(i=0; iC_GetSlotInfo(slotID, pInfo); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GetTokenInfo ( CK_SLOT_ID slotID, CK_TOKEN_INFO* pInfo) { CPKCS11LIB_PROLOGUE(C_GetTokenInfo); rv = m_pFunc->C_GetTokenInfo(slotID, pInfo); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_InitToken( CK_SLOT_ID slotID, char* pPin, CK_ULONG ulPinLen, const char* pLabel) { CPKCS11LIB_PROLOGUE(C_InitToken); rv = m_pFunc->C_InitToken(slotID, (CK_CHAR*)pPin, ulPinLen, (CK_CHAR*)pLabel); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_InitPIN( CK_SESSION_HANDLE hSession, char* pPin, CK_ULONG ulPinLen) { CPKCS11LIB_PROLOGUE(C_InitPIN); rv = m_pFunc->C_InitPIN(hSession, (CK_UTF8CHAR_PTR) pPin, ulPinLen); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_SetPIN( CK_SESSION_HANDLE hSession, char* pOldPin, CK_ULONG ulOldLen, char* pNewPin, CK_ULONG ulNewLen) { CPKCS11LIB_PROLOGUE(C_SetPIN); rv = m_pFunc->C_SetPIN(hSession, (CK_UTF8CHAR_PTR)pOldPin, ulOldLen, (CK_UTF8CHAR_PTR)pNewPin, ulNewLen); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_OpenSession( CK_SLOT_ID slotID, CK_FLAGS flags, CK_SESSION_HANDLE& outhSession) { CPKCS11LIB_PROLOGUE(C_OpenSession); rv = m_pFunc->C_OpenSession(slotID, flags, NULL, NULL, &outhSession); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_CloseSession( CK_SESSION_HANDLE hSession) { CPKCS11LIB_PROLOGUE(C_CloseSession); rv = m_pFunc->C_CloseSession(hSession); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_CloseAllSessions( CK_SLOT_ID slotID) { CPKCS11LIB_PROLOGUE(C_CloseAllSessions); rv = m_pFunc->C_CloseAllSessions(slotID); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GetSessionInfo( CK_SESSION_HANDLE hSession, CK_SESSION_INFO* pInfo) { CPKCS11LIB_PROLOGUE(C_GetSessionInfo); rv = m_pFunc->C_GetSessionInfo(hSession, pInfo); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Login( CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, char* pPin, CK_ULONG ulPinLen) { CPKCS11LIB_PROLOGUE(C_Login); rv = m_pFunc->C_Login(hSession, userType, (CK_UTF8CHAR_PTR)pPin, ulPinLen); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Logout( CK_SESSION_HANDLE hSession) { CPKCS11LIB_PROLOGUE(C_Logout); rv = m_pFunc->C_Logout(hSession); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_CreateObject( CK_SESSION_HANDLE hSession, vector Template, CK_OBJECT_HANDLE& outhObject) { CPKCS11LIB_PROLOGUE(C_CreateObject); CK_ULONG ulCount = 0; CK_OBJECT_HANDLE hObj = static_cast(outhObject); CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_CreateObject(hSession, pTemplate, ulCount, &hObj); if (pTemplate) DestroyTemplate(pTemplate, ulCount); outhObject = static_cast(hObj); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DestroyObject( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { CPKCS11LIB_PROLOGUE(C_DestroyObject); rv = m_pFunc->C_DestroyObject(hSession, (CK_OBJECT_HANDLE)hObject); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GetObjectSize( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ULONG* pulSize) { CPKCS11LIB_PROLOGUE(C_GetObjectSize); rv = m_pFunc->C_GetObjectSize(hSession, (CK_OBJECT_HANDLE)hObject, pulSize); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GetAttributeValue ( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, vector &Template) { CPKCS11LIB_PROLOGUE(C_GetAttributeValue); CK_ULONG ulCount = 0, i; CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_GetAttributeValue(hSession, (CK_OBJECT_HANDLE)hObject, pTemplate, ulCount); for (i=0; i Template) { CPKCS11LIB_PROLOGUE(C_SetAttributeValue); CK_ULONG ulCount = 0; CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_SetAttributeValue(hSession, (CK_OBJECT_HANDLE)hObject, pTemplate, ulCount); if (pTemplate) DestroyTemplate(pTemplate, ulCount); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_FindObjectsInit( CK_SESSION_HANDLE hSession, vector &Template) { CPKCS11LIB_PROLOGUE(C_FindObjectsInit); CK_ULONG ulCount = 0; CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_FindObjectsInit(hSession, pTemplate, ulCount); if (pTemplate) DestroyTemplate(pTemplate, ulCount); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_FindObjects( CK_SESSION_HANDLE hSession, vector& objectList) { CPKCS11LIB_PROLOGUE(C_FindObjects); CK_ULONG i; if (!objectList.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulObjectsMax = (CK_ULONG) objectList.size(); CK_ULONG ulObjects = 0; CK_OBJECT_HANDLE_PTR pList = new CK_OBJECT_HANDLE[ulObjectsMax]; objectList.clear(); rv = m_pFunc->C_FindObjects(hSession, pList, ulObjectsMax, &ulObjects); if (CKR_OK == rv && ulObjects) { for (i=0; i(pList[i])); } if (pList) delete [] pList; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_FindObjectsFinal( CK_SESSION_HANDLE hSession) { CPKCS11LIB_PROLOGUE(C_FindObjectsFinal); rv = m_pFunc->C_FindObjectsFinal(hSession); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_EncryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CPKCS11LIB_PROLOGUE(C_EncryptInit); rv = m_pFunc->C_EncryptInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Encrypt( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData) { CPKCS11LIB_PROLOGUE(C_Encrypt); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outEncryptedData, ulOutDataLen); rv = m_pFunc->C_Encrypt(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outEncryptedData, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_EncryptUpdate( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData) { CPKCS11LIB_PROLOGUE(C_EncryptUpdate); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outEncryptedData, ulOutDataLen); rv = m_pFunc->C_EncryptUpdate(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outEncryptedData, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_EncryptFinal( CK_SESSION_HANDLE hSession, vector &outEncryptedData) { CPKCS11LIB_PROLOGUE(C_EncryptFinal); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outEncryptedData, ulOutDataLen); rv = m_pFunc->C_EncryptFinal(hSession, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outEncryptedData, true); if (pOutData) delete []pOutData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DecryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CPKCS11LIB_PROLOGUE(C_DecryptInit); rv = m_pFunc->C_DecryptInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Decrypt( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData) { CPKCS11LIB_PROLOGUE(C_Decrypt); if (!inEncryptedData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inEncryptedData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outData, ulOutDataLen); rv = m_pFunc->C_Decrypt(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outData, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DecryptUpdate( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData) { CPKCS11LIB_PROLOGUE(C_DecryptUpdate); if (!inEncryptedData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inEncryptedData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outData, ulOutDataLen); rv = m_pFunc->C_DecryptUpdate(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outData, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DecryptFinal( CK_SESSION_HANDLE hSession, vector &outData) { CPKCS11LIB_PROLOGUE(C_DecryptFinal); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outData, ulOutDataLen); rv = m_pFunc->C_DecryptFinal(hSession, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outData, true); if (pOutData) delete []pOutData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DigestInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism) { CPKCS11LIB_PROLOGUE(C_DigestInit); rv = m_pFunc->C_DigestInit(hSession, pMechanism); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Digest( CK_SESSION_HANDLE hSession, vector inData, vector &outDigest) { CPKCS11LIB_PROLOGUE(C_Digest); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outDigest, ulOutDataLen); rv = m_pFunc->C_Digest(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outDigest, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DigestUpdate( CK_SESSION_HANDLE hSession, vector inData) { CPKCS11LIB_PROLOGUE(C_DigestUpdate); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); rv = m_pFunc->C_DigestUpdate(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DigestKey ( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey) { CPKCS11LIB_PROLOGUE(C_DigestKey); rv = m_pFunc->C_DigestKey(hSession, (CK_OBJECT_HANDLE)hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_DigestFinal( CK_SESSION_HANDLE hSession, vector &outDigest) { CPKCS11LIB_PROLOGUE(C_DigestFinal); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outDigest, ulOutDataLen); rv = m_pFunc->C_DigestFinal(hSession, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outDigest, true); if (pOutData) delete []pOutData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_SignInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CPKCS11LIB_PROLOGUE(C_SignInit); rv = m_pFunc->C_SignInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Sign( CK_SESSION_HANDLE hSession, vector inData, vector &outSignature) { CPKCS11LIB_PROLOGUE(C_Sign); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outSignature, ulOutDataLen); rv = m_pFunc->C_Sign(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outSignature, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_SignUpdate( CK_SESSION_HANDLE hSession, vector inData) { CPKCS11LIB_PROLOGUE(C_SignUpdate); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); rv = m_pFunc->C_SignUpdate(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_SignFinal ( CK_SESSION_HANDLE hSession, vector &outSignature) { CPKCS11LIB_PROLOGUE(C_SignFinal); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outSignature, ulOutDataLen); rv = m_pFunc->C_SignFinal(hSession, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outSignature, true); if (pOutData) delete []pOutData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_VerifyInit ( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CPKCS11LIB_PROLOGUE(C_VerifyInit); rv = m_pFunc->C_VerifyInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_Verify( CK_SESSION_HANDLE hSession, vector inData, vector inSignature) { CPKCS11LIB_PROLOGUE(C_Verify); if (!inData.size()) return CKR_ARGUMENTS_BAD; if (!inSignature.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulInSignatureLen = 0; CK_BYTE* pInSignature = Vector2Buffer(inSignature, ulInSignatureLen); rv = m_pFunc->C_Verify(hSession, pInData, ulInDataLen, pInSignature, ulInSignatureLen); if (pInData) delete []pInData; if (pInSignature) delete []pInSignature; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_VerifyUpdate( CK_SESSION_HANDLE hSession, vector inData) { CPKCS11LIB_PROLOGUE(C_VerifyUpdate); if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); rv = m_pFunc->C_VerifyUpdate(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_VerifyFinal( CK_SESSION_HANDLE hSession, vector inSignature) { CPKCS11LIB_PROLOGUE(C_VerifyFinal); if (!inSignature.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInSignatureLen = 0; CK_BYTE* pInSignature = Vector2Buffer(inSignature, ulInSignatureLen); rv = m_pFunc->C_VerifyFinal(hSession, pInSignature, ulInSignatureLen); if (pInSignature) delete []pInSignature; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GenerateKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector Template, CK_OBJECT_HANDLE& outhKey) { CPKCS11LIB_PROLOGUE(C_GenerateKey); CK_ULONG ulCount = 0; CK_OBJECT_HANDLE hKey = static_cast(outhKey); CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_GenerateKey(hSession, pMechanism, pTemplate, ulCount, &hKey); if (pTemplate) DestroyTemplate(pTemplate, ulCount); outhKey = static_cast(hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GenerateKeyPair( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector PublicKeyTemplate, vector PrivateKeyTemplate, CK_OBJECT_HANDLE& outhPublicKey, CK_OBJECT_HANDLE& outhPrivateKey) { CPKCS11LIB_PROLOGUE(C_GenerateKeyPair); CK_ULONG ulPublicKeyAttributeCount = 0, ulPrivateKeyAttributeCount = 0; CK_OBJECT_HANDLE hPublicKey = static_cast(outhPublicKey); CK_OBJECT_HANDLE hPrivateKey = static_cast(outhPrivateKey); CK_ATTRIBUTE * pPublicKeyTemplate = AttrVector2Template(PublicKeyTemplate, ulPublicKeyAttributeCount); CK_ATTRIBUTE * pPrivateKeyTemplate = AttrVector2Template(PrivateKeyTemplate, ulPrivateKeyAttributeCount); rv = m_pFunc->C_GenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, &hPublicKey, &hPrivateKey); if (pPublicKeyTemplate) DestroyTemplate(pPublicKeyTemplate, ulPublicKeyAttributeCount); if (pPrivateKeyTemplate) DestroyTemplate(pPrivateKeyTemplate, ulPrivateKeyAttributeCount); outhPublicKey = static_cast(hPublicKey); outhPrivateKey = static_cast(hPrivateKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_WrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey, vector &WrappedKey) { CPKCS11LIB_PROLOGUE(C_WrapKey); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(WrappedKey, ulOutDataLen); rv = m_pFunc->C_WrapKey(hSession, pMechanism, (CK_OBJECT_HANDLE)hWrappingKey, (CK_OBJECT_HANDLE)hKey, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, WrappedKey, true); if (pOutData) delete []pOutData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_UnwrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hUnwrappingKey, vector WrappedKey, vector Template, CK_OBJECT_HANDLE& outhKey) { CPKCS11LIB_PROLOGUE(C_UnwrapKey); CK_OBJECT_HANDLE hKey = static_cast(outhKey); if (!WrappedKey.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(WrappedKey, ulInDataLen); CK_ULONG ulAttributeCount = 0; CK_ATTRIBUTE* pTemplate = AttrVector2Template(Template, ulAttributeCount); rv = m_pFunc->C_UnwrapKey(hSession, pMechanism, (CK_OBJECT_HANDLE)hUnwrappingKey, pInData, ulInDataLen, pTemplate, ulAttributeCount, &hKey); if (pInData) delete []pInData; if (pTemplate) DestroyTemplate(pTemplate, ulAttributeCount); outhKey = static_cast(hKey); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_SeedRandom( CK_SESSION_HANDLE hSession, vector Seed) { CPKCS11LIB_PROLOGUE(C_SeedRandom); CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(Seed, ulInDataLen); rv = m_pFunc->C_SeedRandom(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GenerateRandom( CK_SESSION_HANDLE hSession, vector &RandomData) { CPKCS11LIB_PROLOGUE(C_GenerateRandom); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(RandomData, ulOutDataLen); rv = m_pFunc->C_GenerateRandom(hSession, pOutData, ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, RandomData, true); if (pOutData) delete []pOutData; CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_WaitForSlotEvent( CK_FLAGS flags, unsigned long* pSlot) { CPKCS11LIB_PROLOGUE(C_WaitForSlotEvent); rv = m_pFunc->C_WaitForSlotEvent(flags, pSlot, NULL); CPKCS11LIB_EPILOGUE; return rv; } CK_RV CPKCS11Lib::C_GetMechanismList( unsigned long slotID, vector &mechanismList) { CPKCS11LIB_PROLOGUE(C_GetMechanismList); CK_ULONG i; mechanismList.clear(); CK_MECHANISM_TYPE ck_mechanismList[1024]; CK_ULONG ulCount = sizeof(ck_mechanismList)/sizeof(ck_mechanismList[0]); rv = m_pFunc->C_GetMechanismList(slotID, ck_mechanismList, &ulCount); if (CKR_OK == rv) for(i=0; iC_GetMechanismInfo(slotID, type, pInfo); CPKCS11LIB_EPILOGUE; return rv; } /////////////////////////////////////////////////////////////////////////////// PyKCS11-1.2.4/src/pykcs11string.h0000644000175000017500000000212711055022763020034 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once #include #include using namespace std; typedef struct PyKCS11String { PyKCS11String(); PyKCS11String(unsigned char* pBuf, int len); PyKCS11String(const char* str); PyKCS11String(basic_string str); PyKCS11String(vector bin_str); basic_string m_str; }PyKCS11String; PyKCS11-1.2.4/src/dyn_generic.h0000644000175000017500000000440211055022763017576 0ustar rousseaurousseau00000000000000/* * This abstracts dynamic library loading functions. * * MUSCLE SmartCard Development ( http://www.linuxnet.com ) * * Copyright (C) 1999 * David Corcoran * * $Id: dyn_generic.h,v 1.3 2003/10/18 17:19:36 aet-guest Exp $ */ #ifndef __dyn_generic_h__ #define __dyn_generic_h__ /** * @file * @brief load dynamic libraries * * @code * #include "dyn_generic.h" * * #ifdef WIN32 * #define LIBRARY_NAME "foobar.dll" * #else * #define LIBRARY_NAME "foobar.so" * #endif * * void *handle; * void (*p)(int, int); * * SYS_dyn_LoadLibrary(&handle, LIBRARY_NAME); * if (NULL == handle) * { * printf("Can't open %s", LIBRARY_NAME); * return -1; * } * * // we need a cast since function_ptr is of type "void (*)(void)" * // and p is of type "void (*)(int, int)" * SYS_dyn_GetAddress(handle, (function_ptr*)&p, FUNCTION_NAME); * * // we close now to not forget it after testing p value * SYS_dyn_CloseLibrary(&handle); * * if (NULL == p) * { * printf("function %s not found", FUNCTION_NAME); * return -1; * } * * // call the function * p(1, 2); * @endcode */ #ifdef __cplusplus extern "C" { #endif typedef void (*function_ptr)(void); /** * dynamically loads a library * @param handle returned handle * @param library_name library file name * @retval 0 if OK * @retval -1 on error and *pvLHandle is set to NULL */ int SYS_dyn_LoadLibrary(void **handle, const char *library_name); /** * close/unload a dynamically loaded library * @param handle handle returned by SYS_dyn_LoadLibrary() * @retval 0 if OK * @retval -1 on error * * Side effect: *pvLHandle is set to NULL */ int SYS_dyn_CloseLibrary(void **handle); /** * get the adsress of a function from a dynamicall loaded library * @param handle handle returned by SYS_dyn_LoadLibrary() * @param function_ptr address to store the function address * @param function_name function name * @retval 0 if OK * @retval -1 on error and pvFHandle is set to NULL */ int SYS_dyn_GetAddress(void *handle, function_ptr *function_ptr, const char *function_name); #ifdef __cplusplus } #endif #endif PyKCS11-1.2.4/src/stdafx.cpp0000644000175000017500000000205211055022763017133 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. // stdafx.cpp : source file that includes just the standard includes // PyKCS11.pch will be the pre-compiled header // stdafx.obj will contain the pre-compiled type information #include "stdafx.h" // TODO: reference any additional headers you need in STDAFX.H // and not in this file PyKCS11-1.2.4/src/ck_attribute_smart.h0000644000175000017500000000352411055022763021202 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once #include "pykcs11string.h" #include using namespace std; class CK_ATTRIBUTE_SMART { CK_ATTRIBUTE_TYPE m_type; vector m_value; public: CK_ATTRIBUTE_SMART(unsigned long type, const unsigned char* pValue, unsigned long len); CK_ATTRIBUTE_SMART(const CK_ATTRIBUTE_SMART & val); CK_ATTRIBUTE_SMART& operator=(const CK_ATTRIBUTE_SMART & val); CK_ATTRIBUTE_SMART(); ~CK_ATTRIBUTE_SMART(); void Reset(); void ResetValue(); void Reserve(long len); unsigned long GetType() const; void SetType(unsigned long attrType); int GetLen() const; bool IsString() const; bool IsBool() const; bool IsNum() const; bool IsBin() const; // returns the value as SWIG "cdata.i"'s struct PyKCS11String GetString() const; void SetString(unsigned long attrType, const char* szValue); long GetNum() const; void SetNum(unsigned long attrType, unsigned long ulValue); bool GetBool() const; void SetBool(unsigned long attrType, bool bValue); vector& GetBin(); void SetBin(unsigned long attrType, const vector& pBuf); }; PyKCS11-1.2.4/src/pkcs11lib.h0000644000175000017500000001575511406076773017130 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2008 Ludovic Rousseau // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once #ifdef SWIG //#define CK_OBJECT_HANDLE unsigned long //#define CK_SESSION_HANDLE unsigned long #else typedef CK_ATTRIBUTE CK_ATTRIBUTE_INTERNAL; #ifdef WIN32 #pragma warning(disable: 4800 4244) #include #endif #include using namespace std; #endif class CPKCS11Lib { bool m_bFinalizeOnClose; bool m_bAutoInitialized; #ifdef WIN32 HMODULE m_hLib; #else void *m_hLib; #endif CK_FUNCTION_LIST* m_pFunc; public: CPKCS11Lib(void); ~CPKCS11Lib(void); bool Load(const char* szLib, bool bAutoCallInitialize); bool Unload(); CK_RV C_Initialize(); CK_RV C_Finalize(); CK_RV C_GetInfo(CK_INFO* pInfo); CK_RV C_GetSlotList(unsigned char tokenPresent, vector& slotList); CK_RV C_GetSlotInfo(unsigned long slotID,CK_SLOT_INFO* pInfo); CK_RV C_GetTokenInfo(unsigned long slotID,CK_TOKEN_INFO* pInfo); #ifdef SWIG %apply (char *STRING, int LENGTH) { (char* pPin, unsigned long ulPinLen), (char* pOldPin, unsigned long ulOldLen), (char* pNewPin, unsigned long ulNewLen) }; %apply (char *STRING) { (char* pLabel) }; #endif CK_RV C_InitToken(unsigned long slotID, char* pPin, unsigned long ulPinLen, const char* pLabel); CK_RV C_InitPIN( CK_SESSION_HANDLE hSession, char* pPin, unsigned long ulPinLen); CK_RV C_SetPIN( CK_SESSION_HANDLE hSession, char* pOldPin, unsigned long ulOldLen, char* pNewPin, unsigned long ulNewLen); CK_RV C_OpenSession( unsigned long slotID, unsigned long flags, CK_SESSION_HANDLE& outhSession); CK_RV C_CloseSession(CK_SESSION_HANDLE hSession); CK_RV C_CloseAllSessions(unsigned long slotID); CK_RV C_GetSessionInfo( CK_SESSION_HANDLE hSession, CK_SESSION_INFO* pInfo); CK_RV C_Login( CK_SESSION_HANDLE hSession, unsigned long userType, char* pPin, unsigned long ulPinLen); #ifdef SWIG %clear (char* pPin, unsigned long ulPinLen), (char* pOldPin, unsigned long ulOldLen), (char* pNewPin, unsigned long ulNewLen) ; %clear (char* pLabel); #endif CK_RV C_Logout(CK_SESSION_HANDLE hSession); CK_RV C_CreateObject( CK_SESSION_HANDLE hSession, vector Template, CK_OBJECT_HANDLE& outhObject); CK_RV C_DestroyObject( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject); CK_RV C_GetObjectSize( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, unsigned long* pulSize); CK_RV C_GetAttributeValue( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, vector &Template); CK_RV C_SetAttributeValue( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, vector Template); CK_RV C_FindObjectsInit( CK_SESSION_HANDLE hSession, vector &Template); CK_RV C_FindObjects( CK_SESSION_HANDLE hSession, vector &objectsList); CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession); CK_RV C_EncryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Encrypt( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData); CK_RV C_EncryptUpdate( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData); CK_RV C_EncryptFinal( CK_SESSION_HANDLE hSession, vector &outEncryptedData); CK_RV C_DecryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Decrypt( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData); CK_RV C_DecryptUpdate( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData); CK_RV C_DecryptFinal( CK_SESSION_HANDLE hSession, vector &outData); CK_RV C_DigestInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism); CK_RV C_Digest( CK_SESSION_HANDLE hSession, vector inData, vector &outDigest); CK_RV C_DigestUpdate( CK_SESSION_HANDLE hSession, vector inData); CK_RV C_DigestKey( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey); CK_RV C_DigestFinal( CK_SESSION_HANDLE hSession, vector &outDigest); CK_RV C_SignInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Sign( CK_SESSION_HANDLE hSession, vector inData, vector &outSignature); CK_RV C_SignUpdate( CK_SESSION_HANDLE hSession, vector inData); CK_RV C_SignFinal( CK_SESSION_HANDLE hSession, vector &outSignature); CK_RV C_VerifyInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Verify( CK_SESSION_HANDLE hSession, vector inData, vector inSignature); CK_RV C_VerifyUpdate( CK_SESSION_HANDLE hSession, vector inData); CK_RV C_VerifyFinal( CK_SESSION_HANDLE hSession, vector inSignature); CK_RV C_GenerateKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector Template, CK_OBJECT_HANDLE & outhKey); CK_RV C_GenerateKeyPair( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector PublicKeyTemplate, vector PrivateKeyTemplate, CK_OBJECT_HANDLE& outhPublicKey, CK_OBJECT_HANDLE& outhPrivateKey ); CK_RV C_WrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey, vector &WrappedKey); CK_RV C_UnwrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hUnwrappingKey, vector WrappedKey, vector Template, CK_OBJECT_HANDLE & outhKey); CK_RV C_SeedRandom( CK_SESSION_HANDLE hSession, vector Seed); CK_RV C_GenerateRandom( CK_SESSION_HANDLE hSession, vector &RandomData); CK_RV C_WaitForSlotEvent( unsigned long flags, unsigned long * INOUT); CK_RV C_GetMechanismList( unsigned long slotID, vector &mechanismList); CK_RV C_GetMechanismInfo( unsigned long slotID, unsigned long type, CK_MECHANISM_INFO* pInfo); }; PyKCS11-1.2.4/src/pykcs11.h0000644000175000017500000000143311055022763016604 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once PyKCS11-1.2.4/src/utility.cpp0000644000175000017500000000457411055022763017360 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #include "stdafx.h" #include #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" #include "utility.h" using namespace std; unsigned char * Vector2Buffer(vector &Buf, CK_ULONG &Len) { Len = (CK_ULONG)Buf.size(); if (!Len) return NULL; CK_ULONG i; unsigned char *pBuf = new unsigned char[Len]; for (i = 0; i &Buf, bool bAllocIfNull) { Buf.clear(); if (!pBuf & bAllocIfNull) Buf = vector(Len); else { Buf.reserve(Len); CK_ULONG i; for (i = 0; i &Attr, CK_ULONG &Len) { Len = (CK_ULONG) Attr.size(); if (!Len) return NULL; CK_ULONG i; CK_ATTRIBUTE_PTR pTemplate = new CK_ATTRIBUTE[Len]; for (i=0; i< Len; i++) { pTemplate[i].type = Attr[i].GetType(); pTemplate[i].pValue = Vector2Buffer(Attr[i].GetBin(), pTemplate[i].ulValueLen); } return pTemplate; } void Template2AttrVector(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG Len, vector &Attr) { CK_ULONG i; for (i=0; i #include CK_ATTRIBUTE_SMART::CK_ATTRIBUTE_SMART(CK_ULONG type, const CK_BYTE* pValue, CK_ULONG len) { this->m_type = type; CK_ULONG i; if (pValue) { m_value.reserve(len); m_value.clear(); for (i=0; i(len); } CK_ATTRIBUTE_SMART::CK_ATTRIBUTE_SMART(const CK_ATTRIBUTE_SMART & val) { vector::const_iterator it; for (it = val.m_value.begin(); it != val.m_value.end(); it++) m_value.push_back(*it); m_type = val.m_type; } CK_ATTRIBUTE_SMART& CK_ATTRIBUTE_SMART::operator=(const CK_ATTRIBUTE_SMART & val) { m_value = val.m_value; m_type = val.m_type; return *this; } CK_ATTRIBUTE_SMART::CK_ATTRIBUTE_SMART() { m_value.reserve(1024); } CK_ATTRIBUTE_SMART::~CK_ATTRIBUTE_SMART() { Reset(); } CK_ULONG CK_ATTRIBUTE_SMART::GetType() const { return m_type; } void CK_ATTRIBUTE_SMART::SetType(CK_ULONG attrType) { m_type = attrType; } int CK_ATTRIBUTE_SMART::GetLen() const { return (int)m_value.size(); } bool CK_ATTRIBUTE_SMART::IsString() const { switch(m_type) { case CKA_LABEL: case CKA_APPLICATION: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsBool() const { switch(m_type) { case CKA_ALWAYS_SENSITIVE: case CKA_DECRYPT: case CKA_ENCRYPT: case CKA_HAS_RESET: case CKA_LOCAL: case CKA_MODIFIABLE: case CKA_NEVER_EXTRACTABLE: case CKA_PRIVATE: case CKA_RESET_ON_INIT: case CKA_SECONDARY_AUTH: case CKA_SENSITIVE: case CKA_SIGN: case CKA_SIGN_RECOVER: case CKA_TOKEN: case CKA_TRUSTED: case CKA_UNWRAP: case CKA_VERIFY: case CKA_VERIFY_RECOVER: case CKA_WRAP: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsNum() const { switch(m_type) { case CKA_CERTIFICATE_TYPE: case CKA_CLASS: case CKA_KEY_GEN_MECHANISM: case CKA_KEY_TYPE: case CKA_MODULUS_BITS: case CKA_VALUE_BITS: case CKA_VALUE_LEN: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsBin() const { return !IsBool() && !IsString() && !IsNum(); } void CK_ATTRIBUTE_SMART::Reset() { m_value.clear(); m_value.reserve(1024); m_type = 0; } void CK_ATTRIBUTE_SMART::ResetValue() { m_value.clear(); m_value.reserve(1024); } void CK_ATTRIBUTE_SMART::Reserve(long len) { m_value = vector(len); } PyKCS11String CK_ATTRIBUTE_SMART::GetString() const { return PyKCS11String(m_value); } void CK_ATTRIBUTE_SMART::SetString(CK_ULONG attrType, const char* szValue) { Reset(); m_type = attrType; if (szValue && strlen(szValue)) { size_t i; size_t iLen = strlen(szValue); for (i=0; i< iLen; i++) m_value.push_back((unsigned char)szValue[i]); } } long CK_ATTRIBUTE_SMART::GetNum() const { if (!IsNum() || m_value.size() != sizeof(CK_ULONG)) return 0; else { CK_ULONG i; CK_ULONG ulRes = 0; unsigned char* pVal = (unsigned char*)&ulRes; for (i=0; i& CK_ATTRIBUTE_SMART::GetBin() { return m_value; } void CK_ATTRIBUTE_SMART::SetBin(unsigned long attrType, const vector& pBuf) { Reset(); m_value = pBuf; m_type = attrType; } PyKCS11-1.2.4/src/pykcs11.cpp0000644000175000017500000000211111055022763017131 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. // PyKCS11.cpp : Defines the entry point for the DLL application. // #include "stdafx.h" #if defined(WIN32) || defined(_WIN32) #include BOOL WINAPI DllMain( HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { return TRUE; } #endif PyKCS11-1.2.4/src/dyn_win32.c0000644000175000017500000000323511055022763017122 0ustar rousseaurousseau00000000000000/* * MUSCLE SmartCard Development ( http://www.linuxnet.com ) * * Copyright (C) 1999 * David Corcoran * * $Id: dyn_win32.c 1957 2006-03-21 13:59:18Z rousseau $ */ /** * @file * @brief This abstracts dynamic library loading functions and timing. */ //#include "config.h" #if defined(WIN32) || defined(_WIN32) #include #include "windows.h" #include #include "dyn_generic.h" //#include "debug.h" int SYS_dyn_LoadLibrary(void **pvLHandle, const char *pcLibrary) { *pvLHandle = NULL; *pvLHandle = LoadLibrary(pcLibrary); if (*pvLHandle == NULL) { #if 0 Log2(PCSC_LOG_ERROR, "DYN_LoadLibrary: dlerror() reports %s", dlerror()); #endif return -1; } return 0; } int SYS_dyn_CloseLibrary(void **pvLHandle) { int ret; ret = FreeLibrary(*pvLHandle); *pvLHandle = NULL; /* If the function fails, the return value is zero. To get extended error * information, call GetLastError. */ if (ret == 0) { #if 0 Log2(PCSC_LOG_ERROR, "DYN_CloseLibrary: dlerror() reports %s", dlerror()); #endif return -1; } return 0; } int SYS_dyn_GetAddress(void *pvLHandle, function_ptr *pvFHandle, const char *pcFunction) { int rv; const char *pcFunctionName; /* * Zero out everything */ rv = 0; pcFunctionName = NULL; pcFunctionName = pcFunction; *pvFHandle = NULL; *pvFHandle = (function_ptr)GetProcAddress(pvLHandle, pcFunctionName); if (*pvFHandle == NULL) { #if 0 Log2(PCSC_LOG_ERROR, "DYN_GetAddress: dlerror() reports %s", dlerror()); #endif rv = -1; } else rv = 0; return rv; } #endif /* WIN32 */ PyKCS11-1.2.4/src/pykcs11.i0000644000175000017500000007250211536247717016626 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. %module LowLevel %{ #include #include #include #include "opensc/pkcs11.h" #ifdef WIN32 #pragma warning(disable: 4800 4244) #endif #include #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" using namespace std; %} %inline %{ using namespace std; %} %include cdata.i %include cpointer.i %include carrays.i %include typemaps.i %include std_vector.i %template(ckintlist) vector; %template(ckbytelist) vector; %template(ckattrlist) vector; %template(ckobjlist) vector; %pointer_class(unsigned long, CK_SESSION_HANDLE); %pointer_class(unsigned long, CK_OBJECT_HANDLE); %array_class(char,byteArray); #if SWIGPYTHON %typemap(out) PyKCS11String { $result = PyString_FromStringAndSize((const char*)($1.m_str.c_str()),(int)($1.m_str.size())); } %typemap(out) CK_RV { $result = PyInt_FromLong((long)$1); } #else #endif typedef struct CK_VERSION { %immutable; unsigned char major; unsigned char minor; %mutable; } CK_VERSION; typedef struct CK_INFO { %immutable; CK_VERSION cryptokiVersion; unsigned char manufacturerID[32]; unsigned long flags; unsigned char libraryDescription[32]; CK_VERSION libraryVersion; %mutable; } CK_INFO; %extend CK_INFO { PyKCS11String GetManufacturerID() { return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } PyKCS11String GetLibraryDescription() { return PyKCS11String(self->libraryDescription, sizeof(self->libraryDescription)); } PyKCS11String GetLibraryVersion() { char szVal[10]; sprintf(szVal, "%d.%d", self->libraryVersion.major, self->libraryVersion.minor); return PyKCS11String(szVal); } }; typedef struct CK_SLOT_INFO { %immutable; //unsigned char slotDescription[64]; //unsigned char manufacturerID[32]; unsigned long flags; CK_VERSION hardwareVersion; CK_VERSION firmwareVersion; %mutable; } CK_SLOT_INFO; %extend CK_SLOT_INFO { PyKCS11String GetManufacturerID() { return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } PyKCS11String GetSlotDescription() { return PyKCS11String(self->slotDescription, sizeof(self->slotDescription)); } PyKCS11String GetHardwareVersion() { char szVal[10]; sprintf(szVal, "%d.%02d", self->hardwareVersion.major, self->hardwareVersion.minor); return PyKCS11String(szVal); } PyKCS11String GetFirmwareVersion() { char szVal[10]; sprintf(szVal, "%d.%02d", self->firmwareVersion.major, self->firmwareVersion.minor); return PyKCS11String(szVal); } }; typedef struct CK_TOKEN_INFO { %immutable; //unsigned char label[32]; //unsigned char manufacturerID[32]; //unsigned char model[16]; //unsigned char serialNumber[16]; unsigned long flags; unsigned long ulMaxSessionCount; unsigned long ulSessionCount; unsigned long ulMaxRwSessionCount; unsigned long ulRwSessionCount; unsigned long ulMaxPinLen; unsigned long ulMinPinLen; unsigned long ulTotalPublicMemory; unsigned long ulFreePublicMemory; unsigned long ulTotalPrivateMemory; unsigned long ulFreePrivateMemory; CK_VERSION hardwareVersion; CK_VERSION firmwareVersion; //unsigned char utcTime[16]; %mutable; } CK_TOKEN_INFO; %extend CK_TOKEN_INFO { PyKCS11String GetLabel() { return PyKCS11String(self->label, sizeof(self->label)); } PyKCS11String GetManufacturerID() { return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } PyKCS11String GetModel() { return PyKCS11String(self->model, sizeof(self->model)); } PyKCS11String GetSerialNumber() { return PyKCS11String(self->serialNumber, sizeof(self->serialNumber)); } PyKCS11String GetFirmwareVersion() { char szVal[10]; sprintf(szVal, "%d.%02d", self->firmwareVersion.major, self->firmwareVersion.minor); return PyKCS11String(szVal); } PyKCS11String GetUtcTime() { return PyKCS11String(self->utcTime, sizeof(self->utcTime)); } }; typedef struct CK_SESSION_INFO { %immutable; unsigned long slotID; unsigned long state; unsigned long flags; unsigned long ulDeviceError; %mutable; } CK_SESSION_INFO; typedef struct CK_DATE{ //unsigned char year[4]; //unsigned char month[2]; // unsigned char day[2]; } CK_DATE; %extend CK_DATE { PyKCS11String GetYear() { char szVal[10]; memcpy(szVal, self->year, sizeof(self->year) ); return PyKCS11String(szVal); } PyKCS11String GetMonth() { char szVal[10]; memcpy(szVal, self->month, sizeof(self->month) ); return PyKCS11String(szVal); } PyKCS11String GetDay() { char szVal[10]; memcpy(szVal, self->day, sizeof(self->day) ); return PyKCS11String(szVal); } }; typedef struct CK_MECHANISM { unsigned long mechanism; void* pParameter; unsigned long ulParameterLen; } CK_MECHANISM; %extend CK_MECHANISM { CK_MECHANISM() { CK_MECHANISM* m = new CK_MECHANISM(); m->ulParameterLen = m->mechanism = 0; m->pParameter = NULL; return m; } }; typedef struct CK_MECHANISM_INFO { %immutable; unsigned long ulMinKeySize; unsigned long ulMaxKeySize; unsigned long flags; %mutable; } CK_MECHANISM_INFO; typedef unsigned long CK_RV; #define FALSE 0 #define TRUE !(FALSE) #define CK_TRUE 1 #define CK_FALSE 0 #define CK_UNAVAILABLE_INFORMATION (~0UL) #define CK_EFFECTIVELY_INFINITE 0 #define CK_INVALID_HANDLE 0 #define CKN_SURRENDER 0 #define CKF_TOKEN_PRESENT 0x00000001 #define CKF_REMOVABLE_DEVICE 0x00000002 #define CKF_HW_SLOT 0x00000004 #define CKF_RNG 0x00000001 #define CKF_WRITE_PROTECTED 0x00000002 #define CKF_LOGIN_REQUIRED 0x00000004 #define CKF_USER_PIN_INITIALIZED 0x00000008 #define CKF_RESTORE_KEY_NOT_NEEDED 0x00000020 #define CKF_CLOCK_ON_TOKEN 0x00000040 #define CKF_PROTECTED_AUTHENTICATION_PATH 0x00000100 #define CKF_DUAL_CRYPTO_OPERATIONS 0x00000200 #define CKF_TOKEN_INITIALIZED 0x00000400 #define CKF_SECONDARY_AUTHENTICATION 0x00000800 #define CKF_USER_PIN_COUNT_LOW 0x00010000 #define CKF_USER_PIN_FINAL_TRY 0x00020000 #define CKF_USER_PIN_LOCKED 0x00040000 #define CKF_USER_PIN_TO_BE_CHANGED 0x00080000 #define CKF_SO_PIN_COUNT_LOW 0x00100000 #define CKF_SO_PIN_FINAL_TRY 0x00200000 #define CKF_SO_PIN_LOCKED 0x00400000 #define CKF_SO_PIN_TO_BE_CHANGED 0x00800000 #define CKU_SO 0 #define CKU_USER 1 #define CKS_RO_PUBLIC_SESSION 0 #define CKS_RO_USER_FUNCTIONS 1 #define CKS_RW_PUBLIC_SESSION 2 #define CKS_RW_USER_FUNCTIONS 3 #define CKS_RW_SO_FUNCTIONS 4 #define CKF_RW_SESSION 0x00000002 #define CKF_SERIAL_SESSION 0x00000004 #define CKO_DATA 0x00000000 #define CKO_CERTIFICATE 0x00000001 #define CKO_PUBLIC_KEY 0x00000002 #define CKO_PRIVATE_KEY 0x00000003 #define CKO_SECRET_KEY 0x00000004 #define CKO_HW_FEATURE 0x00000005 #define CKO_DOMAIN_PARAMETERS 0x00000006 #define CKO_MECHANISM 0x00000007 #define CKO_VENDOR_DEFINED 0x80000000 #define CKH_MONOTONIC_COUNTER 0x00000001 #define CKH_CLOCK 0x00000002 #define CKH_VENDOR_DEFINED 0x80000000 #define CKK_RSA 0x00000000 #define CKK_DSA 0x00000001 #define CKK_DH 0x00000002 #define CKK_ECDSA 0x00000003 #define CKK_EC 0x00000003 #define CKK_X9_42_DH 0x00000004 #define CKK_KEA 0x00000005 #define CKK_GENERIC_SECRET 0x00000010 #define CKK_RC2 0x00000011 #define CKK_RC4 0x00000012 #define CKK_DES 0x00000013 #define CKK_DES2 0x00000014 #define CKK_DES3 0x00000015 #define CKK_CAST 0x00000016 #define CKK_CAST3 0x00000017 #define CKK_CAST5 0x00000018 #define CKK_CAST128 0x00000018 #define CKK_RC5 0x00000019 #define CKK_IDEA 0x0000001A #define CKK_SKIPJACK 0x0000001B #define CKK_BATON 0x0000001C #define CKK_JUNIPER 0x0000001D #define CKK_CDMF 0x0000001E #define CKK_AES 0x0000001F #define CKK_BLOWFISH 0x00000020 #define CKK_TWOFISH 0x00000021 #define CKK_VENDOR_DEFINED 0x80000000 #define CKC_X_509 0x00000000 #define CKC_X_509_ATTR_CERT 0x00000001 #define CKC_WTLS 0x00000002 #define CKC_VENDOR_DEFINED 0x80000000 #define CKA_CLASS 0x00000000 #define CKA_TOKEN 0x00000001 #define CKA_PRIVATE 0x00000002 #define CKA_LABEL 0x00000003 #define CKA_APPLICATION 0x00000010 #define CKA_VALUE 0x00000011 #define CKA_OBJECT_ID 0x00000012 #define CKA_CERTIFICATE_TYPE 0x00000080 #define CKA_ISSUER 0x00000081 #define CKA_SERIAL_NUMBER 0x00000082 #define CKA_AC_ISSUER 0x00000083 #define CKA_OWNER 0x00000084 #define CKA_ATTR_TYPES 0x00000085 #define CKA_TRUSTED 0x00000086 #define CKA_KEY_TYPE 0x00000100 #define CKA_SUBJECT 0x00000101 #define CKA_ID 0x00000102 #define CKA_SENSITIVE 0x00000103 #define CKA_ENCRYPT 0x00000104 #define CKA_DECRYPT 0x00000105 #define CKA_WRAP 0x00000106 #define CKA_UNWRAP 0x00000107 #define CKA_SIGN 0x00000108 #define CKA_SIGN_RECOVER 0x00000109 #define CKA_VERIFY 0x0000010A #define CKA_VERIFY_RECOVER 0x0000010B #define CKA_DERIVE 0x0000010C #define CKA_START_DATE 0x00000110 #define CKA_END_DATE 0x00000111 #define CKA_MODULUS 0x00000120 #define CKA_MODULUS_BITS 0x00000121 #define CKA_PUBLIC_EXPONENT 0x00000122 #define CKA_PRIVATE_EXPONENT 0x00000123 #define CKA_PRIME_1 0x00000124 #define CKA_PRIME_2 0x00000125 #define CKA_EXPONENT_1 0x00000126 #define CKA_EXPONENT_2 0x00000127 #define CKA_COEFFICIENT 0x00000128 #define CKA_PRIME 0x00000130 #define CKA_SUBPRIME 0x00000131 #define CKA_BASE 0x00000132 #define CKA_PRIME_BITS 0x00000133 #define CKA_SUBPRIME_BITS 0x00000134 #define CKA_SUB_PRIME_BITS CKA_SUBPRIME_BITS #define CKA_VALUE_BITS 0x00000160 #define CKA_VALUE_LEN 0x00000161 #define CKA_EXTRACTABLE 0x00000162 #define CKA_LOCAL 0x00000163 #define CKA_NEVER_EXTRACTABLE 0x00000164 #define CKA_ALWAYS_SENSITIVE 0x00000165 #define CKA_KEY_GEN_MECHANISM 0x00000166 #define CKA_MODIFIABLE 0x00000170 #define CKA_ECDSA_PARAMS 0x00000180 #define CKA_EC_PARAMS 0x00000180 #define CKA_EC_POINT 0x00000181 #define CKA_SECONDARY_AUTH 0x00000200 #define CKA_AUTH_PIN_FLAGS 0x00000201 #define CKA_HW_FEATURE_TYPE 0x00000300 #define CKA_RESET_ON_INIT 0x00000301 #define CKA_HAS_RESET 0x00000302 #define CKA_VENDOR_DEFINED 0x80000000 #define CKM_RSA_PKCS_KEY_PAIR_GEN 0x00000000 #define CKM_RSA_PKCS 0x00000001 #define CKM_RSA_9796 0x00000002 #define CKM_RSA_X_509 0x00000003 #define CKM_MD2_RSA_PKCS 0x00000004 #define CKM_MD5_RSA_PKCS 0x00000005 #define CKM_SHA1_RSA_PKCS 0x00000006 #define CKM_RIPEMD128_RSA_PKCS 0x00000007 #define CKM_RIPEMD160_RSA_PKCS 0x00000008 #define CKM_RSA_PKCS_OAEP 0x00000009 #define CKM_RSA_X9_31_KEY_PAIR_GEN 0x0000000A #define CKM_RSA_X9_31 0x0000000B #define CKM_SHA1_RSA_X9_31 0x0000000C #define CKM_RSA_PKCS_PSS 0x0000000D #define CKM_SHA1_RSA_PKCS_PSS 0x0000000E #define CKM_DSA_KEY_PAIR_GEN 0x00000010 #define CKM_DSA 0x00000011 #define CKM_DSA_SHA1 0x00000012 #define CKM_DH_PKCS_KEY_PAIR_GEN 0x00000020 #define CKM_DH_PKCS_DERIVE 0x00000021 #define CKM_X9_42_DH_KEY_PAIR_GEN 0x00000030 #define CKM_X9_42_DH_DERIVE 0x00000031 #define CKM_X9_42_DH_HYBRID_DERIVE 0x00000032 #define CKM_X9_42_MQV_DERIVE 0x00000033 #define CKM_SHA256_RSA_PKCS 0x00000040 #define CKM_SHA384_RSA_PKCS 0x00000041 #define CKM_SHA512_RSA_PKCS 0x00000042 #define CKM_SHA256_RSA_PKCS_PSS 0x00000043 #define CKM_SHA384_RSA_PKCS_PSS 0x00000044 #define CKM_SHA512_RSA_PKCS_PSS 0x00000045 #define CKM_RC2_KEY_GEN 0x00000100 #define CKM_RC2_ECB 0x00000101 #define CKM_RC2_CBC 0x00000102 #define CKM_RC2_MAC 0x00000103 #define CKM_RC2_MAC_GENERAL 0x00000104 #define CKM_RC2_CBC_PAD 0x00000105 #define CKM_RC4_KEY_GEN 0x00000110 #define CKM_RC4 0x00000111 #define CKM_DES_KEY_GEN 0x00000120 #define CKM_DES_ECB 0x00000121 #define CKM_DES_CBC 0x00000122 #define CKM_DES_MAC 0x00000123 #define CKM_DES_MAC_GENERAL 0x00000124 #define CKM_DES_CBC_PAD 0x00000125 #define CKM_DES2_KEY_GEN 0x00000130 #define CKM_DES3_KEY_GEN 0x00000131 #define CKM_DES3_ECB 0x00000132 #define CKM_DES3_CBC 0x00000133 #define CKM_DES3_MAC 0x00000134 #define CKM_DES3_MAC_GENERAL 0x00000135 #define CKM_DES3_CBC_PAD 0x00000136 #define CKM_CDMF_KEY_GEN 0x00000140 #define CKM_CDMF_ECB 0x00000141 #define CKM_CDMF_CBC 0x00000142 #define CKM_CDMF_MAC 0x00000143 #define CKM_CDMF_MAC_GENERAL 0x00000144 #define CKM_CDMF_CBC_PAD 0x00000145 #define CKM_DES_OFB64 0x00000150 #define CKM_DES_OFB8 0x00000151 #define CKM_DES_CFB64 0x00000152 #define CKM_DES_CFB8 0x00000153 #define CKM_MD2 0x00000200 #define CKM_MD2_HMAC 0x00000201 #define CKM_MD2_HMAC_GENERAL 0x00000202 #define CKM_MD5 0x00000210 #define CKM_MD5_HMAC 0x00000211 #define CKM_MD5_HMAC_GENERAL 0x00000212 #define CKM_SHA_1 0x00000220 #define CKM_SHA_1_HMAC 0x00000221 #define CKM_SHA_1_HMAC_GENERAL 0x00000222 #define CKM_RIPEMD128 0x00000230 #define CKM_RIPEMD128_HMAC 0x00000231 #define CKM_RIPEMD128_HMAC_GENERAL 0x00000232 #define CKM_RIPEMD160 0x00000240 #define CKM_RIPEMD160_HMAC 0x00000241 #define CKM_RIPEMD160_HMAC_GENERAL 0x00000242 #define CKM_SHA256 0x00000250 #define CKM_SHA256_HMAC 0x00000251 #define CKM_SHA256_HMAC_GENERAL 0x00000252 #define CKM_SHA384 0x00000260 #define CKM_SHA384_HMAC 0x00000261 #define CKM_SHA384_HMAC_GENERAL 0x00000262 #define CKM_SHA512 0x00000270 #define CKM_SHA512_HMAC 0x00000271 #define CKM_SHA512_HMAC_GENERAL 0x00000272 #define CKM_CAST_KEY_GEN 0x00000300 #define CKM_CAST_ECB 0x00000301 #define CKM_CAST_CBC 0x00000302 #define CKM_CAST_MAC 0x00000303 #define CKM_CAST_MAC_GENERAL 0x00000304 #define CKM_CAST_CBC_PAD 0x00000305 #define CKM_CAST3_KEY_GEN 0x00000310 #define CKM_CAST3_ECB 0x00000311 #define CKM_CAST3_CBC 0x00000312 #define CKM_CAST3_MAC 0x00000313 #define CKM_CAST3_MAC_GENERAL 0x00000314 #define CKM_CAST3_CBC_PAD 0x00000315 #define CKM_CAST5_KEY_GEN 0x00000320 #define CKM_CAST128_KEY_GEN 0x00000320 #define CKM_CAST5_ECB 0x00000321 #define CKM_CAST128_ECB 0x00000321 #define CKM_CAST5_CBC 0x00000322 #define CKM_CAST128_CBC 0x00000322 #define CKM_CAST5_MAC 0x00000323 #define CKM_CAST128_MAC 0x00000323 #define CKM_CAST5_MAC_GENERAL 0x00000324 #define CKM_CAST128_MAC_GENERAL 0x00000324 #define CKM_CAST5_CBC_PAD 0x00000325 #define CKM_CAST128_CBC_PAD 0x00000325 #define CKM_RC5_KEY_GEN 0x00000330 #define CKM_RC5_ECB 0x00000331 #define CKM_RC5_CBC 0x00000332 #define CKM_RC5_MAC 0x00000333 #define CKM_RC5_MAC_GENERAL 0x00000334 #define CKM_RC5_CBC_PAD 0x00000335 #define CKM_IDEA_KEY_GEN 0x00000340 #define CKM_IDEA_ECB 0x00000341 #define CKM_IDEA_CBC 0x00000342 #define CKM_IDEA_MAC 0x00000343 #define CKM_IDEA_MAC_GENERAL 0x00000344 #define CKM_IDEA_CBC_PAD 0x00000345 #define CKM_GENERIC_SECRET_KEY_GEN 0x00000350 #define CKM_CONCATENATE_BASE_AND_KEY 0x00000360 #define CKM_CONCATENATE_BASE_AND_DATA 0x00000362 #define CKM_CONCATENATE_DATA_AND_BASE 0x00000363 #define CKM_XOR_BASE_AND_DATA 0x00000364 #define CKM_EXTRACT_KEY_FROM_KEY 0x00000365 #define CKM_SSL3_PRE_MASTER_KEY_GEN 0x00000370 #define CKM_SSL3_MASTER_KEY_DERIVE 0x00000371 #define CKM_SSL3_KEY_AND_MAC_DERIVE 0x00000372 #define CKM_SSL3_MASTER_KEY_DERIVE_DH 0x00000373 #define CKM_TLS_PRE_MASTER_KEY_GEN 0x00000374 #define CKM_TLS_MASTER_KEY_DERIVE 0x00000375 #define CKM_TLS_KEY_AND_MAC_DERIVE 0x00000376 #define CKM_TLS_MASTER_KEY_DERIVE_DH 0x00000377 #define CKM_TLS_PRF 0x00000378 #define CKM_SSL3_MD5_MAC 0x00000380 #define CKM_SSL3_SHA1_MAC 0x00000381 #define CKM_MD5_KEY_DERIVATION 0x00000390 #define CKM_MD2_KEY_DERIVATION 0x00000391 #define CKM_SHA1_KEY_DERIVATION 0x00000392 #define CKM_SHA256_KEY_DERIVATION 0x00000393 #define CKM_SHA384_KEY_DERIVATION 0x00000394 #define CKM_SHA512_KEY_DERIVATION 0x00000395 #define CKM_PBE_MD2_DES_CBC 0x000003A0 #define CKM_PBE_MD5_DES_CBC 0x000003A1 #define CKM_PBE_MD5_CAST_CBC 0x000003A2 #define CKM_PBE_MD5_CAST3_CBC 0x000003A3 #define CKM_PBE_MD5_CAST5_CBC 0x000003A4 #define CKM_PBE_MD5_CAST128_CBC 0x000003A4 #define CKM_PBE_SHA1_CAST5_CBC 0x000003A5 #define CKM_PBE_SHA1_CAST128_CBC 0x000003A5 #define CKM_PBE_SHA1_RC4_128 0x000003A6 #define CKM_PBE_SHA1_RC4_40 0x000003A7 #define CKM_PBE_SHA1_DES3_EDE_CBC 0x000003A8 #define CKM_PBE_SHA1_DES2_EDE_CBC 0x000003A9 #define CKM_PBE_SHA1_RC2_128_CBC 0x000003AA #define CKM_PBE_SHA1_RC2_40_CBC 0x000003AB #define CKM_PKCS5_PBKD2 0x000003B0 #define CKM_PBA_SHA1_WITH_SHA1_HMAC 0x000003C0 #define CKM_WTLS_PRE_MASTER_KEY_GEN 0x000003D0 #define CKM_WTLS_MASTER_KEY_DERIVE 0x000003D1 #define CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC 0x000003D2 #define CKM_WTLS_PRF 0x000003D3 #define CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE 0x000003D4 #define CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE 0x000003D5 #define CKM_KEY_WRAP_LYNKS 0x00000400 #define CKM_KEY_WRAP_SET_OAEP 0x00000401 #define CKM_CMS_SIG 0x00000500 #define CKM_SKIPJACK_KEY_GEN 0x00001000 #define CKM_SKIPJACK_ECB64 0x00001001 #define CKM_SKIPJACK_CBC64 0x00001002 #define CKM_SKIPJACK_OFB64 0x00001003 #define CKM_SKIPJACK_CFB64 0x00001004 #define CKM_SKIPJACK_CFB32 0x00001005 #define CKM_SKIPJACK_CFB16 0x00001006 #define CKM_SKIPJACK_CFB8 0x00001007 #define CKM_SKIPJACK_WRAP 0x00001008 #define CKM_SKIPJACK_PRIVATE_WRAP 0x00001009 #define CKM_SKIPJACK_RELAYX 0x0000100a #define CKM_KEA_KEY_PAIR_GEN 0x00001010 #define CKM_KEA_KEY_DERIVE 0x00001011 #define CKM_FORTEZZA_TIMESTAMP 0x00001020 #define CKM_BATON_KEY_GEN 0x00001030 #define CKM_BATON_ECB128 0x00001031 #define CKM_BATON_ECB96 0x00001032 #define CKM_BATON_CBC128 0x00001033 #define CKM_BATON_COUNTER 0x00001034 #define CKM_BATON_SHUFFLE 0x00001035 #define CKM_BATON_WRAP 0x00001036 #define CKM_ECDSA_KEY_PAIR_GEN 0x00001040 #define CKM_EC_KEY_PAIR_GEN 0x00001040 #define CKM_ECDSA 0x00001041 #define CKM_ECDSA_SHA1 0x00001042 #define CKM_ECDH1_DERIVE 0x00001050 #define CKM_ECDH1_COFACTOR_DERIVE 0x00001051 #define CKM_ECMQV_DERIVE 0x00001052 #define CKM_JUNIPER_KEY_GEN 0x00001060 #define CKM_JUNIPER_ECB128 0x00001061 #define CKM_JUNIPER_CBC128 0x00001062 #define CKM_JUNIPER_COUNTER 0x00001063 #define CKM_JUNIPER_SHUFFLE 0x00001064 #define CKM_JUNIPER_WRAP 0x00001065 #define CKM_FASTHASH 0x00001070 #define CKM_AES_KEY_GEN 0x00001080 #define CKM_AES_ECB 0x00001081 #define CKM_AES_CBC 0x00001082 #define CKM_AES_MAC 0x00001083 #define CKM_AES_MAC_GENERAL 0x00001084 #define CKM_AES_CBC_PAD 0x00001085 #define CKM_BLOWFISH_KEY_GEN 0x00001090 #define CKM_BLOWFISH_CBC 0x00001091 #define CKM_TWOFISH_KEY_GEN 0x00001092 #define CKM_TWOFISH_CBC 0x00001093 #define CKM_DES_ECB_ENCRYPT_DATA 0x00001100 #define CKM_DES_CBC_ENCRYPT_DATA 0x00001101 #define CKM_DES3_ECB_ENCRYPT_DATA 0x00001102 #define CKM_DES3_CBC_ENCRYPT_DATA 0x00001103 #define CKM_AES_ECB_ENCRYPT_DATA 0x00001104 #define CKM_AES_CBC_ENCRYPT_DATA 0x00001105 #define CKM_DSA_PARAMETER_GEN 0x00002000 #define CKM_DH_PKCS_PARAMETER_GEN 0x00002001 #define CKM_X9_42_DH_PARAMETER_GEN 0x00002002 #define CKM_VENDOR_DEFINED 0x80000000 #define CKF_HW 0x00000001 #define CKF_ENCRYPT 0x00000100 #define CKF_DECRYPT 0x00000200 #define CKF_DIGEST 0x00000400 #define CKF_SIGN 0x00000800 #define CKF_SIGN_RECOVER 0x00001000 #define CKF_VERIFY 0x00002000 #define CKF_VERIFY_RECOVER 0x00004000 #define CKF_GENERATE 0x00008000 #define CKF_GENERATE_KEY_PAIR 0x00010000 #define CKF_WRAP 0x00020000 #define CKF_UNWRAP 0x00040000 #define CKF_DERIVE 0x00080000 #define CKF_EC_F_P 0x00100000 #define CKF_EC_F_2M 0x00200000 #define CKF_EC_ECPARAMETERS 0x00400000 #define CKF_EC_NAMEDCURVE 0x00800000 #define CKF_EC_UNCOMPRESS 0x01000000 #define CKF_EC_COMPRESS 0x02000000 #define CKF_EXTENSION 0x80000000 #define CKR_OK 0x00000000 #define CKR_CANCEL 0x00000001 #define CKR_HOST_MEMORY 0x00000002 #define CKR_SLOT_ID_INVALID 0x00000003 #define CKR_GENERAL_ERROR 0x00000005 #define CKR_FUNCTION_FAILED 0x00000006 #define CKR_ARGUMENTS_BAD 0x00000007 #define CKR_NO_EVENT 0x00000008 #define CKR_NEED_TO_CREATE_THREADS 0x00000009 #define CKR_CANT_LOCK 0x0000000A #define CKR_ATTRIBUTE_READ_ONLY 0x00000010 #define CKR_ATTRIBUTE_SENSITIVE 0x00000011 #define CKR_ATTRIBUTE_TYPE_INVALID 0x00000012 #define CKR_ATTRIBUTE_VALUE_INVALID 0x00000013 #define CKR_DATA_INVALID 0x00000020 #define CKR_DATA_LEN_RANGE 0x00000021 #define CKR_DEVICE_ERROR 0x00000030 #define CKR_DEVICE_MEMORY 0x00000031 #define CKR_DEVICE_REMOVED 0x00000032 #define CKR_ENCRYPTED_DATA_INVALID 0x00000040 #define CKR_ENCRYPTED_DATA_LEN_RANGE 0x00000041 #define CKR_FUNCTION_CANCELED 0x00000050 #define CKR_FUNCTION_NOT_PARALLEL 0x00000051 #define CKR_FUNCTION_NOT_SUPPORTED 0x00000054 #define CKR_KEY_HANDLE_INVALID 0x00000060 #define CKR_KEY_SIZE_RANGE 0x00000062 #define CKR_KEY_TYPE_INCONSISTENT 0x00000063 #define CKR_KEY_NOT_NEEDED 0x00000064 #define CKR_KEY_CHANGED 0x00000065 #define CKR_KEY_NEEDED 0x00000066 #define CKR_KEY_INDIGESTIBLE 0x00000067 #define CKR_KEY_FUNCTION_NOT_PERMITTED 0x00000068 #define CKR_KEY_NOT_WRAPPABLE 0x00000069 #define CKR_KEY_UNEXTRACTABLE 0x0000006A #define CKR_MECHANISM_INVALID 0x00000070 #define CKR_MECHANISM_PARAM_INVALID 0x00000071 #define CKR_OBJECT_HANDLE_INVALID 0x00000082 #define CKR_OPERATION_ACTIVE 0x00000090 #define CKR_OPERATION_NOT_INITIALIZED 0x00000091 #define CKR_PIN_INCORRECT 0x000000A0 #define CKR_PIN_INVALID 0x000000A1 #define CKR_PIN_LEN_RANGE 0x000000A2 #define CKR_PIN_EXPIRED 0x000000A3 #define CKR_PIN_LOCKED 0x000000A4 #define CKR_SESSION_CLOSED 0x000000B0 #define CKR_SESSION_COUNT 0x000000B1 #define CKR_SESSION_HANDLE_INVALID 0x000000B3 #define CKR_SESSION_PARALLEL_NOT_SUPPORTED 0x000000B4 #define CKR_SESSION_READ_ONLY 0x000000B5 #define CKR_SESSION_EXISTS 0x000000B6 #define CKR_SESSION_READ_ONLY_EXISTS 0x000000B7 #define CKR_SESSION_READ_WRITE_SO_EXISTS 0x000000B8 #define CKR_SIGNATURE_INVALID 0x000000C0 #define CKR_SIGNATURE_LEN_RANGE 0x000000C1 #define CKR_TEMPLATE_INCOMPLETE 0x000000D0 #define CKR_TEMPLATE_INCONSISTENT 0x000000D1 #define CKR_TOKEN_NOT_PRESENT 0x000000E0 #define CKR_TOKEN_NOT_RECOGNIZED 0x000000E1 #define CKR_TOKEN_WRITE_PROTECTED 0x000000E2 #define CKR_UNWRAPPING_KEY_HANDLE_INVALID 0x000000F0 #define CKR_UNWRAPPING_KEY_SIZE_RANGE 0x000000F1 #define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT 0x000000F2 #define CKR_USER_ALREADY_LOGGED_IN 0x00000100 #define CKR_USER_NOT_LOGGED_IN 0x00000101 #define CKR_USER_PIN_NOT_INITIALIZED 0x00000102 #define CKR_USER_TYPE_INVALID 0x00000103 #define CKR_USER_ANOTHER_ALREADY_LOGGED_IN 0x00000104 #define CKR_USER_TOO_MANY_TYPES 0x00000105 #define CKR_WRAPPED_KEY_INVALID 0x00000110 #define CKR_WRAPPED_KEY_LEN_RANGE 0x00000112 #define CKR_WRAPPING_KEY_HANDLE_INVALID 0x00000113 #define CKR_WRAPPING_KEY_SIZE_RANGE 0x00000114 #define CKR_WRAPPING_KEY_TYPE_INCONSISTENT 0x00000115 #define CKR_RANDOM_SEED_NOT_SUPPORTED 0x00000120 #define CKR_RANDOM_NO_RNG 0x00000121 #define CKR_DOMAIN_PARAMS_INVALID 0x00000130 #define CKR_BUFFER_TOO_SMALL 0x00000150 #define CKR_SAVED_STATE_INVALID 0x00000160 #define CKR_INFORMATION_SENSITIVE 0x00000170 #define CKR_STATE_UNSAVEABLE 0x00000180 #define CKR_CRYPTOKI_NOT_INITIALIZED 0x00000190 #define CKR_CRYPTOKI_ALREADY_INITIALIZED 0x00000191 #define CKR_MUTEX_BAD 0x000001A0 #define CKR_MUTEX_NOT_LOCKED 0x000001A1 #define CKR_VENDOR_DEFINED 0x80000000 #define CKF_LIBRARY_CANT_CREATE_OS_THREADS 0x00000001 #define CKF_OS_LOCKING_OK 0x00000002 #define CKF_DONT_BLOCK 1 #define CKG_MGF1_SHA1 0x00000001 #define CKZ_DATA_SPECIFIED 0x00000001 #define CKD_NULL 0x00000001 #define CKD_SHA1_KDF 0x00000002 #define CKD_NULL 0x00000001 #define CKD_SHA1_KDF_ASN1 0x00000003 #define CKD_SHA1_KDF_CONCATENATE 0x00000004 #define CKP_PKCS5_PBKD2_HMAC_SHA1 0x00000001 #define CKZ_SALT_SPECIFIED 0x00000001 %include "pkcs11lib.h" class CK_ATTRIBUTE_SMART { public: void Reset(); void ResetValue(); void Reserve(long len); unsigned long GetType() const; void SetType(unsigned long attrType); int GetLen() const; bool IsString() const; bool IsBool() const; bool IsNum() const; bool IsBin() const; PyKCS11String GetString() const; void SetString(unsigned long attrType, const char* szValue); long GetNum() const; void SetNum(unsigned long attrType, unsigned long ulValue); bool GetBool() const; void SetBool(unsigned long attrType, bool bValue); vector GetBin(); void SetBin(unsigned long attrType, const vector& pBuf); }; PyKCS11-1.2.4/src/stdafx.h0000644000175000017500000000241511101072611016570 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA // stdafx.h : include file for standard system include files, // or project specific include files that are used frequently, but // are changed infrequently // #pragma once #include #include #include #include using namespace std; #ifdef WIN32 #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers // Windows Header Files: #include #endif #include "opensc/pkcs11.h" // TODO: reference additional headers your program requires here PyKCS11-1.2.4/src/unix_pykcs11_wrap.cpp0000644000175000017500000307414511744467536021270 0ustar rousseaurousseau00000000000000/* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). * Version 2.0.4 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make * changes to this file unless you know what you are doing--modify the SWIG * interface file instead. * ----------------------------------------------------------------------------- */ #define SWIGPYTHON #define SWIG_PYTHON_DIRECTOR_NO_VTABLE #ifdef __cplusplus /* SwigValueWrapper is described in swig.swg */ template class SwigValueWrapper { struct SwigMovePointer { T *ptr; SwigMovePointer(T *p) : ptr(p) { } ~SwigMovePointer() { delete ptr; } SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } } pointer; SwigValueWrapper& operator=(const SwigValueWrapper& rhs); SwigValueWrapper(const SwigValueWrapper& rhs); public: SwigValueWrapper() : pointer(0) { } SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } operator T&() const { return *pointer.ptr; } T *operator&() { return pointer.ptr; } }; template T SwigValueInit() { return T(); } #endif /* ----------------------------------------------------------------------------- * This section contains generic SWIG labels for method/variable * declarations/attributes, and other compiler dependent labels. * ----------------------------------------------------------------------------- */ /* template workaround for compilers that cannot correctly implement the C++ standard */ #ifndef SWIGTEMPLATEDISAMBIGUATOR # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) # define SWIGTEMPLATEDISAMBIGUATOR template # elif defined(__HP_aCC) /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ # define SWIGTEMPLATEDISAMBIGUATOR template # else # define SWIGTEMPLATEDISAMBIGUATOR # endif #endif /* inline attribute */ #ifndef SWIGINLINE # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) # define SWIGINLINE inline # else # define SWIGINLINE # endif #endif /* attribute recognised by some compilers to avoid 'unused' warnings */ #ifndef SWIGUNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif # elif defined(__ICC) # define SWIGUNUSED __attribute__ ((__unused__)) # else # define SWIGUNUSED # endif #endif #ifndef SWIG_MSC_UNSUPPRESS_4505 # if defined(_MSC_VER) # pragma warning(disable : 4505) /* unreferenced local function has been removed */ # endif #endif #ifndef SWIGUNUSEDPARM # ifdef __cplusplus # define SWIGUNUSEDPARM(p) # else # define SWIGUNUSEDPARM(p) p SWIGUNUSED # endif #endif /* internal SWIG method */ #ifndef SWIGINTERN # define SWIGINTERN static SWIGUNUSED #endif /* internal inline SWIG method */ #ifndef SWIGINTERNINLINE # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE #endif /* exporting methods */ #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # ifndef GCC_HASCLASSVISIBILITY # define GCC_HASCLASSVISIBILITY # endif #endif #ifndef SWIGEXPORT # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # if defined(STATIC_LINKED) # define SWIGEXPORT # else # define SWIGEXPORT __declspec(dllexport) # endif # else # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) # define SWIGEXPORT __attribute__ ((visibility("default"))) # else # define SWIGEXPORT # endif # endif #endif /* calling conventions for Windows */ #ifndef SWIGSTDCALL # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # define SWIGSTDCALL __stdcall # else # define SWIGSTDCALL # endif #endif /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) # define _CRT_SECURE_NO_DEPRECATE #endif /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) # define _SCL_SECURE_NO_DEPRECATE #endif /* Python.h has to appear first */ #include /* ----------------------------------------------------------------------------- * swigrun.swg * * This file contains generic C API SWIG runtime support for pointer * type checking. * ----------------------------------------------------------------------------- */ /* This should only be incremented when either the layout of swig_type_info changes, or for whatever reason, the runtime changes incompatibly */ #define SWIG_RUNTIME_VERSION "4" /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ #ifdef SWIG_TYPE_TABLE # define SWIG_QUOTE_STRING(x) #x # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) #else # define SWIG_TYPE_TABLE_NAME #endif /* You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for creating a static or dynamic library from the SWIG runtime code. In 99.9% of the cases, SWIG just needs to declare them as 'static'. But only do this if strictly necessary, ie, if you have problems with your compiler or suchlike. */ #ifndef SWIGRUNTIME # define SWIGRUNTIME SWIGINTERN #endif #ifndef SWIGRUNTIMEINLINE # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE #endif /* Generic buffer size */ #ifndef SWIG_BUFFER_SIZE # define SWIG_BUFFER_SIZE 1024 #endif /* Flags for pointer conversions */ #define SWIG_POINTER_DISOWN 0x1 #define SWIG_CAST_NEW_MEMORY 0x2 /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 /* Flags/methods for returning states. The SWIG conversion methods, as ConvertPtr, return an integer that tells if the conversion was successful or not. And if not, an error code can be returned (see swigerrors.swg for the codes). Use the following macros/flags to set or process the returning states. In old versions of SWIG, code such as the following was usually written: if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { // success code } else { //fail code } Now you can be more explicit: int res = SWIG_ConvertPtr(obj,vptr,ty.flags); if (SWIG_IsOK(res)) { // success code } else { // fail code } which is the same really, but now you can also do Type *ptr; int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); if (SWIG_IsOK(res)) { // success code if (SWIG_IsNewObj(res) { ... delete *ptr; } else { ... } } else { // fail code } I.e., now SWIG_ConvertPtr can return new objects and you can identify the case and take care of the deallocation. Of course that also requires SWIG_ConvertPtr to return new result values, such as int SWIG_ConvertPtr(obj, ptr,...) { if () { if () { *ptr = ; return SWIG_NEWOBJ; } else { *ptr = ; return SWIG_OLDOBJ; } } else { return SWIG_BADOBJ; } } Of course, returning the plain '0(success)/-1(fail)' still works, but you can be more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the SWIG errors code. Finally, if the SWIG_CASTRANK_MODE is enabled, the result code allows to return the 'cast rank', for example, if you have this int food(double) int fooi(int); and you call food(1) // cast rank '1' (1 -> 1.0) fooi(1) // cast rank '0' just use the SWIG_AddCast()/SWIG_CheckState() */ #define SWIG_OK (0) #define SWIG_ERROR (-1) #define SWIG_IsOK(r) (r >= 0) #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) /* The CastRankLimit says how many bits are used for the cast rank */ #define SWIG_CASTRANKLIMIT (1 << 8) /* The NewMask denotes the object was created (using new/malloc) */ #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) /* The TmpMask is for in/out typemaps that use temporal objects */ #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) /* Simple returning values */ #define SWIG_BADOBJ (SWIG_ERROR) #define SWIG_OLDOBJ (SWIG_OK) #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) /* Check, add and del mask methods */ #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) /* Cast-Rank Mode */ #if defined(SWIG_CASTRANK_MODE) # ifndef SWIG_TypeRank # define SWIG_TypeRank unsigned long # endif # ifndef SWIG_MAXCASTRANK /* Default cast allowed */ # define SWIG_MAXCASTRANK (2) # endif # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) SWIGINTERNINLINE int SWIG_AddCast(int r) { return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; } SWIGINTERNINLINE int SWIG_CheckState(int r) { return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; } #else /* no cast-rank mode */ # define SWIG_AddCast # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) #endif #include #ifdef __cplusplus extern "C" { #endif typedef void *(*swig_converter_func)(void *, int *); typedef struct swig_type_info *(*swig_dycast_func)(void **); /* Structure to store information on one type */ typedef struct swig_type_info { const char *name; /* mangled name of this type */ const char *str; /* human readable name of this type */ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ struct swig_cast_info *cast; /* linked list of types that can cast into this type */ void *clientdata; /* language specific type data */ int owndata; /* flag if the structure owns the clientdata */ } swig_type_info; /* Structure to store a type and conversion function used for casting */ typedef struct swig_cast_info { swig_type_info *type; /* pointer to type that is equivalent to this type */ swig_converter_func converter; /* function to cast the void pointers */ struct swig_cast_info *next; /* pointer to next cast in linked list */ struct swig_cast_info *prev; /* pointer to the previous cast */ } swig_cast_info; /* Structure used to store module information * Each module generates one structure like this, and the runtime collects * all of these structures and stores them in a circularly linked list.*/ typedef struct swig_module_info { swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ size_t size; /* Number of types in this module */ struct swig_module_info *next; /* Pointer to next element in circularly linked list */ swig_type_info **type_initial; /* Array of initially generated type structures */ swig_cast_info **cast_initial; /* Array of initially generated casting structures */ void *clientdata; /* Language specific module data */ } swig_module_info; /* Compare two type names skipping the space characters, therefore "char*" == "char *" and "Class" == "Class", etc. Return 0 when the two name types are equivalent, as in strncmp, but skipping ' '. */ SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2) { for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { while ((*f1 == ' ') && (f1 != l1)) ++f1; while ((*f2 == ' ') && (f2 != l2)) ++f2; if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; } return (int)((l1 - f1) - (l2 - f2)); } /* Check type equivalence in a name list like ||... Return 0 if not equal, 1 if equal */ SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb) { int equiv = 0; const char* te = tb + strlen(tb); const char* ne = nb; while (!equiv && *ne) { for (nb = ne; *ne; ++ne) { if (*ne == '|') break; } equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; if (*ne) ++ne; } return equiv; } /* Check type equivalence in a name list like ||... Return 0 if equal, -1 if nb < tb, 1 if nb > tb */ SWIGRUNTIME int SWIG_TypeCompare(const char *nb, const char *tb) { int equiv = 0; const char* te = tb + strlen(tb); const char* ne = nb; while (!equiv && *ne) { for (nb = ne; *ne; ++ne) { if (*ne == '|') break; } equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; if (*ne) ++ne; } return equiv; } /* Check the typename */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty) { if (ty) { swig_cast_info *iter = ty->cast; while (iter) { if (strcmp(iter->type->name, c) == 0) { if (iter == ty->cast) return iter; /* Move iter to the top of the linked list */ iter->prev->next = iter->next; if (iter->next) iter->next->prev = iter->prev; iter->next = ty->cast; iter->prev = 0; if (ty->cast) ty->cast->prev = iter; ty->cast = iter; return iter; } iter = iter->next; } } return 0; } /* Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison */ SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { if (ty) { swig_cast_info *iter = ty->cast; while (iter) { if (iter->type == from) { if (iter == ty->cast) return iter; /* Move iter to the top of the linked list */ iter->prev->next = iter->next; if (iter->next) iter->next->prev = iter->prev; iter->next = ty->cast; iter->prev = 0; if (ty->cast) ty->cast->prev = iter; ty->cast = iter; return iter; } iter = iter->next; } } return 0; } /* Cast a pointer up an inheritance hierarchy */ SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); } /* Dynamic pointer casting. Down an inheritance hierarchy */ SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { swig_type_info *lastty = ty; if (!ty || !ty->dcast) return ty; while (ty && (ty->dcast)) { ty = (*ty->dcast)(ptr); if (ty) lastty = ty; } return lastty; } /* Return the name associated with this type */ SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty) { return ty->name; } /* Return the pretty name associated with this type, that is an unmangled type name in a form presentable to the user. */ SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type) { /* The "str" field contains the equivalent pretty names of the type, separated by vertical-bar characters. We choose to print the last name, as it is often (?) the most specific. */ if (!type) return NULL; if (type->str != NULL) { const char *last_name = type->str; const char *s; for (s = type->str; *s; s++) if (*s == '|') last_name = s+1; return last_name; } else return type->name; } /* Set the clientdata field for a type */ SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { swig_cast_info *cast = ti->cast; /* if (ti->clientdata == clientdata) return; */ ti->clientdata = clientdata; while (cast) { if (!cast->converter) { swig_type_info *tc = cast->type; if (!tc->clientdata) { SWIG_TypeClientData(tc, clientdata); } } cast = cast->next; } } SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { SWIG_TypeClientData(ti, clientdata); ti->owndata = 1; } /* Search for a swig_type_info structure only by mangled name Search is a O(log #types) We start searching at module start, and finish searching when start == end. Note: if start == end at the beginning of the function, we go all the way around the circular list. */ SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name) { swig_module_info *iter = start; do { if (iter->size) { register size_t l = 0; register size_t r = iter->size - 1; do { /* since l+r >= 0, we can (>> 1) instead (/ 2) */ register size_t i = (l + r) >> 1; const char *iname = iter->types[i]->name; if (iname) { register int compare = strcmp(name, iname); if (compare == 0) { return iter->types[i]; } else if (compare < 0) { if (i) { r = i - 1; } else { break; } } else if (compare > 0) { l = i + 1; } } else { break; /* should never happen */ } } while (l <= r); } iter = iter->next; } while (iter != end); return 0; } /* Search for a swig_type_info structure for either a mangled name or a human readable name. It first searches the mangled names of the types, which is a O(log #types) If a type is not found it then searches the human readable names, which is O(#types). We start searching at module start, and finish searching when start == end. Note: if start == end at the beginning of the function, we go all the way around the circular list. */ SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name) { /* STEP 1: Search the name field using binary search */ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); if (ret) { return ret; } else { /* STEP 2: If the type hasn't been found, do a complete search of the str field (the human readable name) */ swig_module_info *iter = start; do { register size_t i = 0; for (; i < iter->size; ++i) { if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) return iter->types[i]; } iter = iter->next; } while (iter != end); } /* neither found a match */ return 0; } /* Pack binary data into a string */ SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz) { static const char hex[17] = "0123456789abcdef"; register const unsigned char *u = (unsigned char *) ptr; register const unsigned char *eu = u + sz; for (; u != eu; ++u) { register unsigned char uu = *u; *(c++) = hex[(uu & 0xf0) >> 4]; *(c++) = hex[uu & 0xf]; } return c; } /* Unpack binary data from a string */ SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) { register unsigned char *u = (unsigned char *) ptr; register const unsigned char *eu = u + sz; for (; u != eu; ++u) { register char d = *(c++); register unsigned char uu; if ((d >= '0') && (d <= '9')) uu = ((d - '0') << 4); else if ((d >= 'a') && (d <= 'f')) uu = ((d - ('a'-10)) << 4); else return (char *) 0; d = *(c++); if ((d >= '0') && (d <= '9')) uu |= (d - '0'); else if ((d >= 'a') && (d <= 'f')) uu |= (d - ('a'-10)); else return (char *) 0; *u = uu; } return c; } /* Pack 'void *' into a string buffer. */ SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { char *r = buff; if ((2*sizeof(void *) + 2) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,&ptr,sizeof(void *)); if (strlen(name) + 1 > (bsz - (r - buff))) return 0; strcpy(r,name); return buff; } SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { if (*c != '_') { if (strcmp(c,"NULL") == 0) { *ptr = (void *) 0; return name; } else { return 0; } } return SWIG_UnpackData(++c,ptr,sizeof(void *)); } SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { char *r = buff; size_t lname = (name ? strlen(name) : 0); if ((2*sz + 2 + lname) > bsz) return 0; *(r++) = '_'; r = SWIG_PackData(r,ptr,sz); if (lname) { strncpy(r,name,lname+1); } else { *r = 0; } return buff; } SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { if (*c != '_') { if (strcmp(c,"NULL") == 0) { memset(ptr,0,sz); return name; } else { return 0; } } return SWIG_UnpackData(++c,ptr,sz); } #ifdef __cplusplus } #endif /* Errors in SWIG */ #define SWIG_UnknownError -1 #define SWIG_IOError -2 #define SWIG_RuntimeError -3 #define SWIG_IndexError -4 #define SWIG_TypeError -5 #define SWIG_DivisionByZero -6 #define SWIG_OverflowError -7 #define SWIG_SyntaxError -8 #define SWIG_ValueError -9 #define SWIG_SystemError -10 #define SWIG_AttributeError -11 #define SWIG_MemoryError -12 #define SWIG_NullReferenceError -13 /* Compatibility macros for Python 3 */ #if PY_VERSION_HEX >= 0x03000000 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) #define PyInt_Check(x) PyLong_Check(x) #define PyInt_AsLong(x) PyLong_AsLong(x) #define PyInt_FromLong(x) PyLong_FromLong(x) #define PyString_Check(name) PyBytes_Check(name) #define PyString_FromString(x) PyUnicode_FromString(x) #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) #define PyString_AsString(str) PyBytes_AsString(str) #define PyString_Size(str) PyBytes_Size(str) #define PyString_InternFromString(key) PyUnicode_InternFromString(key) #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) #endif #ifndef Py_TYPE # define Py_TYPE(op) ((op)->ob_type) #endif /* SWIG APIs for compatibility of both Python 2 & 3 */ #if PY_VERSION_HEX >= 0x03000000 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat #else # define SWIG_Python_str_FromFormat PyString_FromFormat #endif /* Warning: This function will allocate a new string in Python 3, * so please call SWIG_Python_str_DelForPy3(x) to free the space. */ SWIGINTERN char* SWIG_Python_str_AsChar(PyObject *str) { #if PY_VERSION_HEX >= 0x03000000 char *cstr; char *newstr; Py_ssize_t len; str = PyUnicode_AsUTF8String(str); PyBytes_AsStringAndSize(str, &cstr, &len); newstr = (char *) malloc(len+1); memcpy(newstr, cstr, len+1); Py_XDECREF(str); return newstr; #else return PyString_AsString(str); #endif } #if PY_VERSION_HEX >= 0x03000000 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) #else # define SWIG_Python_str_DelForPy3(x) #endif SWIGINTERN PyObject* SWIG_Python_str_FromChar(const char *c) { #if PY_VERSION_HEX >= 0x03000000 return PyUnicode_FromString(c); #else return PyString_FromString(c); #endif } /* Add PyOS_snprintf for old Pythons */ #if PY_VERSION_HEX < 0x02020000 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) # define PyOS_snprintf _snprintf # else # define PyOS_snprintf snprintf # endif #endif /* A crude PyString_FromFormat implementation for old Pythons */ #if PY_VERSION_HEX < 0x02020000 #ifndef SWIG_PYBUFFER_SIZE # define SWIG_PYBUFFER_SIZE 1024 #endif static PyObject * PyString_FromFormat(const char *fmt, ...) { va_list ap; char buf[SWIG_PYBUFFER_SIZE * 2]; int res; va_start(ap, fmt); res = vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); } #endif /* Add PyObject_Del for old Pythons */ #if PY_VERSION_HEX < 0x01060000 # define PyObject_Del(op) PyMem_DEL((op)) #endif #ifndef PyObject_DEL # define PyObject_DEL PyObject_Del #endif /* A crude PyExc_StopIteration exception for old Pythons */ #if PY_VERSION_HEX < 0x02020000 # ifndef PyExc_StopIteration # define PyExc_StopIteration PyExc_RuntimeError # endif # ifndef PyObject_GenericGetAttr # define PyObject_GenericGetAttr 0 # endif #endif /* Py_NotImplemented is defined in 2.1 and up. */ #if PY_VERSION_HEX < 0x02010000 # ifndef Py_NotImplemented # define Py_NotImplemented PyExc_RuntimeError # endif #endif /* A crude PyString_AsStringAndSize implementation for old Pythons */ #if PY_VERSION_HEX < 0x02010000 # ifndef PyString_AsStringAndSize # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} # endif #endif /* PySequence_Size for old Pythons */ #if PY_VERSION_HEX < 0x02000000 # ifndef PySequence_Size # define PySequence_Size PySequence_Length # endif #endif /* PyBool_FromLong for old Pythons */ #if PY_VERSION_HEX < 0x02030000 static PyObject *PyBool_FromLong(long ok) { PyObject *result = ok ? Py_True : Py_False; Py_INCREF(result); return result; } #endif /* Py_ssize_t for old Pythons */ /* This code is as recommended by: */ /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) typedef int Py_ssize_t; # define PY_SSIZE_T_MAX INT_MAX # define PY_SSIZE_T_MIN INT_MIN typedef inquiry lenfunc; typedef intargfunc ssizeargfunc; typedef intintargfunc ssizessizeargfunc; typedef intobjargproc ssizeobjargproc; typedef intintobjargproc ssizessizeobjargproc; typedef getreadbufferproc readbufferproc; typedef getwritebufferproc writebufferproc; typedef getsegcountproc segcountproc; typedef getcharbufferproc charbufferproc; static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) { long result = 0; PyObject *i = PyNumber_Int(x); if (i) { result = PyInt_AsLong(i); Py_DECREF(i); } return result; } #endif #if PY_VERSION_HEX < 0x02040000 #define Py_VISIT(op) \ do { \ if (op) { \ int vret = visit((op), arg); \ if (vret) \ return vret; \ } \ } while (0) #endif #if PY_VERSION_HEX < 0x02030000 typedef struct { PyTypeObject type; PyNumberMethods as_number; PyMappingMethods as_mapping; PySequenceMethods as_sequence; PyBufferProcs as_buffer; PyObject *name, *slots; } PyHeapTypeObject; #endif #if PY_VERSION_HEX < 0x02030000 typedef destructor freefunc; #endif #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ (PY_MAJOR_VERSION > 3)) # define SWIGPY_USE_CAPSULE # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) #endif #if PY_VERSION_HEX < 0x03020000 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) #endif /* ----------------------------------------------------------------------------- * error manipulation * ----------------------------------------------------------------------------- */ SWIGRUNTIME PyObject* SWIG_Python_ErrorType(int code) { PyObject* type = 0; switch(code) { case SWIG_MemoryError: type = PyExc_MemoryError; break; case SWIG_IOError: type = PyExc_IOError; break; case SWIG_RuntimeError: type = PyExc_RuntimeError; break; case SWIG_IndexError: type = PyExc_IndexError; break; case SWIG_TypeError: type = PyExc_TypeError; break; case SWIG_DivisionByZero: type = PyExc_ZeroDivisionError; break; case SWIG_OverflowError: type = PyExc_OverflowError; break; case SWIG_SyntaxError: type = PyExc_SyntaxError; break; case SWIG_ValueError: type = PyExc_ValueError; break; case SWIG_SystemError: type = PyExc_SystemError; break; case SWIG_AttributeError: type = PyExc_AttributeError; break; default: type = PyExc_RuntimeError; } return type; } SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char* mesg) { PyObject *type = 0; PyObject *value = 0; PyObject *traceback = 0; if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); if (value) { char *tmp; PyObject *old_str = PyObject_Str(value); PyErr_Clear(); Py_XINCREF(type); PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); SWIG_Python_str_DelForPy3(tmp); Py_DECREF(old_str); Py_DECREF(value); } else { PyErr_SetString(PyExc_RuntimeError, mesg); } } #if defined(SWIG_PYTHON_NO_THREADS) # if defined(SWIG_PYTHON_THREADS) # undef SWIG_PYTHON_THREADS # endif #endif #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ # define SWIG_PYTHON_USE_GIL # endif # endif # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ # ifndef SWIG_PYTHON_INITIALIZE_THREADS # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() # endif # ifdef __cplusplus /* C++ code */ class SWIG_Python_Thread_Block { bool status; PyGILState_STATE state; public: void end() { if (status) { PyGILState_Release(state); status = false;} } SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} ~SWIG_Python_Thread_Block() { end(); } }; class SWIG_Python_Thread_Allow { bool status; PyThreadState *save; public: void end() { if (status) { PyEval_RestoreThread(save); status = false; }} SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} ~SWIG_Python_Thread_Allow() { end(); } }; # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() # else /* C code */ # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) # endif # else /* Old thread way, not implemented, user must provide it */ # if !defined(SWIG_PYTHON_INITIALIZE_THREADS) # define SWIG_PYTHON_INITIALIZE_THREADS # endif # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) # define SWIG_PYTHON_THREAD_BEGIN_BLOCK # endif # if !defined(SWIG_PYTHON_THREAD_END_BLOCK) # define SWIG_PYTHON_THREAD_END_BLOCK # endif # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) # define SWIG_PYTHON_THREAD_BEGIN_ALLOW # endif # if !defined(SWIG_PYTHON_THREAD_END_ALLOW) # define SWIG_PYTHON_THREAD_END_ALLOW # endif # endif #else /* No thread support */ # define SWIG_PYTHON_INITIALIZE_THREADS # define SWIG_PYTHON_THREAD_BEGIN_BLOCK # define SWIG_PYTHON_THREAD_END_BLOCK # define SWIG_PYTHON_THREAD_BEGIN_ALLOW # define SWIG_PYTHON_THREAD_END_ALLOW #endif /* ----------------------------------------------------------------------------- * Python API portion that goes into the runtime * ----------------------------------------------------------------------------- */ #ifdef __cplusplus extern "C" { #endif /* ----------------------------------------------------------------------------- * Constant declarations * ----------------------------------------------------------------------------- */ /* Constant Types */ #define SWIG_PY_POINTER 4 #define SWIG_PY_BINARY 5 /* Constant information structure */ typedef struct swig_const_info { int type; char *name; long lvalue; double dvalue; void *pvalue; swig_type_info **ptype; } swig_const_info; /* ----------------------------------------------------------------------------- * Wrapper of PyInstanceMethod_New() used in Python 3 * It is exported to the generated module, used for -fastproxy * ----------------------------------------------------------------------------- */ #if PY_VERSION_HEX >= 0x03000000 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { return PyInstanceMethod_New(func); } #else SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) { return NULL; } #endif #ifdef __cplusplus } #endif /* ----------------------------------------------------------------------------- * pyrun.swg * * This file contains the runtime support for Python modules * and includes code for managing global variables and pointer * type checking. * * ----------------------------------------------------------------------------- */ /* Common SWIG API */ /* for raw pointers */ #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) #ifdef SWIGPYTHON_BUILTIN #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) #else #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) #endif #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) #define swig_owntype int /* for raw packed data */ #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) /* for class or struct pointers */ #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) /* for C or C++ function pointers */ #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) /* for C++ member pointers, ie, member methods */ #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) /* Runtime API */ #define SWIG_GetModule(clientdata) SWIG_Python_GetModule() #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) #define SWIG_NewClientData(obj) SwigPyClientData_New(obj) #define SWIG_SetErrorObj SWIG_Python_SetErrorObj #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) #define SWIG_fail goto fail /* Runtime API implementation */ /* Error manipulation */ SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; PyErr_SetObject(errtype, obj); Py_DECREF(obj); SWIG_PYTHON_THREAD_END_BLOCK; } SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; PyErr_SetString(errtype, (char *) msg); SWIG_PYTHON_THREAD_END_BLOCK; } #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) /* Set a constant value */ #if defined(SWIGPYTHON_BUILTIN) SWIGINTERN void SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { PyObject *s = PyString_InternFromString(key); PyList_Append(seq, s); Py_DECREF(s); } SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { PyDict_SetItemString(d, (char *)name, obj); Py_DECREF(obj); if (public_interface) SwigPyBuiltin_AddPublicSymbol(public_interface, name); } #else SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { PyDict_SetItemString(d, (char *)name, obj); Py_DECREF(obj); } #endif /* Append a value to the result obj */ SWIGINTERN PyObject* SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { #if !defined(SWIG_PYTHON_OUTPUT_TUPLE) if (!result) { result = obj; } else if (result == Py_None) { Py_DECREF(result); result = obj; } else { if (!PyList_Check(result)) { PyObject *o2 = result; result = PyList_New(1); PyList_SetItem(result, 0, o2); } PyList_Append(result,obj); Py_DECREF(obj); } return result; #else PyObject* o2; PyObject* o3; if (!result) { result = obj; } else if (result == Py_None) { Py_DECREF(result); result = obj; } else { if (!PyTuple_Check(result)) { o2 = result; result = PyTuple_New(1); PyTuple_SET_ITEM(result, 0, o2); } o3 = PyTuple_New(1); PyTuple_SET_ITEM(o3, 0, obj); o2 = result; result = PySequence_Concat(o2, o3); Py_DECREF(o2); Py_DECREF(o3); } return result; #endif } /* Unpack the argument tuple */ SWIGINTERN int SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) { if (!args) { if (!min && !max) { return 1; } else { PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", name, (min == max ? "" : "at least "), (int)min); return 0; } } if (!PyTuple_Check(args)) { if (min <= 1 && max >= 1) { register int i; objs[0] = args; for (i = 1; i < max; ++i) { objs[i] = 0; } return 2; } PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); return 0; } else { register Py_ssize_t l = PyTuple_GET_SIZE(args); if (l < min) { PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", name, (min == max ? "" : "at least "), (int)min, (int)l); return 0; } else if (l > max) { PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", name, (min == max ? "" : "at most "), (int)max, (int)l); return 0; } else { register int i; for (i = 0; i < l; ++i) { objs[i] = PyTuple_GET_ITEM(args, i); } for (; l < max; ++l) { objs[l] = 0; } return i + 1; } } } /* A functor is a function object with one single object argument */ #if PY_VERSION_HEX >= 0x02020000 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); #else #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); #endif /* Helper for static pointer initialization for both C and C++ code, for example static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); */ #ifdef __cplusplus #define SWIG_STATIC_POINTER(var) var #else #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var #endif /* ----------------------------------------------------------------------------- * Pointer declarations * ----------------------------------------------------------------------------- */ /* Flags for new pointer objects */ #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) #ifdef __cplusplus extern "C" { #endif /* How to access Py_None */ #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) # ifndef SWIG_PYTHON_NO_BUILD_NONE # ifndef SWIG_PYTHON_BUILD_NONE # define SWIG_PYTHON_BUILD_NONE # endif # endif #endif #ifdef SWIG_PYTHON_BUILD_NONE # ifdef Py_None # undef Py_None # define Py_None SWIG_Py_None() # endif SWIGRUNTIMEINLINE PyObject * _SWIG_Py_None(void) { PyObject *none = Py_BuildValue((char*)""); Py_DECREF(none); return none; } SWIGRUNTIME PyObject * SWIG_Py_None(void) { static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); return none; } #endif /* The python void return value */ SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void) { PyObject *none = Py_None; Py_INCREF(none); return none; } /* SwigPyClientData */ typedef struct { PyObject *klass; PyObject *newraw; PyObject *newargs; PyObject *destroy; int delargs; int implicitconv; PyTypeObject *pytype; } SwigPyClientData; SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty) { SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; return data ? data->implicitconv : 0; } SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc) { SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; PyObject *klass = data ? data->klass : 0; return (klass ? klass : PyExc_RuntimeError); } SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject* obj) { if (!obj) { return 0; } else { SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); /* the klass element */ data->klass = obj; Py_INCREF(data->klass); /* the newraw method and newargs arguments used to create a new raw instance */ if (PyClass_Check(obj)) { data->newraw = 0; data->newargs = obj; Py_INCREF(obj); } else { #if (PY_VERSION_HEX < 0x02020000) data->newraw = 0; #else data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); #endif if (data->newraw) { Py_INCREF(data->newraw); data->newargs = PyTuple_New(1); PyTuple_SetItem(data->newargs, 0, obj); } else { data->newargs = obj; } Py_INCREF(data->newargs); } /* the destroy method, aka as the C++ delete method */ data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); if (PyErr_Occurred()) { PyErr_Clear(); data->destroy = 0; } if (data->destroy) { int flags; Py_INCREF(data->destroy); flags = PyCFunction_GET_FLAGS(data->destroy); #ifdef METH_O data->delargs = !(flags & (METH_O)); #else data->delargs = 0; #endif } else { data->delargs = 0; } data->implicitconv = 0; data->pytype = 0; return data; } } SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data) { Py_XDECREF(data->newraw); Py_XDECREF(data->newargs); Py_XDECREF(data->destroy); } /* =============== SwigPyObject =====================*/ typedef struct { PyObject_HEAD void *ptr; swig_type_info *ty; int own; PyObject *next; #ifdef SWIGPYTHON_BUILTIN PyObject *dict; #endif } SwigPyObject; SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v) { return PyLong_FromVoidPtr(v->ptr); } SWIGRUNTIME PyObject * SwigPyObject_format(const char* fmt, SwigPyObject *v) { PyObject *res = NULL; PyObject *args = PyTuple_New(1); if (args) { if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { PyObject *ofmt = SWIG_Python_str_FromChar(fmt); if (ofmt) { #if PY_VERSION_HEX >= 0x03000000 res = PyUnicode_Format(ofmt,args); #else res = PyString_Format(ofmt,args); #endif Py_DECREF(ofmt); } Py_DECREF(args); } } return res; } SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v) { return SwigPyObject_format("%o",v); } SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v) { return SwigPyObject_format("%x",v); } SWIGRUNTIME PyObject * #ifdef METH_NOARGS SwigPyObject_repr(SwigPyObject *v) #else SwigPyObject_repr(SwigPyObject *v, PyObject *args) #endif { const char *name = SWIG_TypePrettyName(v->ty); PyObject *repr = SWIG_Python_str_FromFormat("", name, (void *)v); if (v->next) { # ifdef METH_NOARGS PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); # else PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); # endif # if PY_VERSION_HEX >= 0x03000000 PyObject *joined = PyUnicode_Concat(repr, nrep); Py_DecRef(repr); Py_DecRef(nrep); repr = joined; # else PyString_ConcatAndDel(&repr,nrep); # endif } return repr; } SWIGRUNTIME int SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { char *str; #ifdef METH_NOARGS PyObject *repr = SwigPyObject_repr(v); #else PyObject *repr = SwigPyObject_repr(v, NULL); #endif if (repr) { str = SWIG_Python_str_AsChar(repr); fputs(str, fp); SWIG_Python_str_DelForPy3(str); Py_DECREF(repr); return 0; } else { return 1; } } SWIGRUNTIME PyObject * SwigPyObject_str(SwigPyObject *v) { char result[SWIG_BUFFER_SIZE]; return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? SWIG_Python_str_FromChar(result) : 0; } SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) { void *i = v->ptr; void *j = w->ptr; return (i < j) ? -1 : ((i > j) ? 1 : 0); } /* Added for Python 3.x, would it also be useful for Python 2.x? */ SWIGRUNTIME PyObject* SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) { PyObject* res; if( op != Py_EQ && op != Py_NE ) { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); return res; } SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); #ifdef SWIGPYTHON_BUILTIN static swig_type_info *SwigPyObject_stype = 0; SWIGRUNTIME PyTypeObject* SwigPyObject_type(void) { SwigPyClientData *cd; assert(SwigPyObject_stype); cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; assert(cd); assert(cd->pytype); return cd->pytype; } #else SWIGRUNTIME PyTypeObject* SwigPyObject_type(void) { static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); return type; } #endif SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op) { #ifdef SWIGPYTHON_BUILTIN PyTypeObject *target_tp = SwigPyObject_type(); if (PyType_IsSubtype(op->ob_type, target_tp)) return 1; return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); #else return (Py_TYPE(op) == SwigPyObject_type()) || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); #endif } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own); SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v) { SwigPyObject *sobj = (SwigPyObject *) v; PyObject *next = sobj->next; if (sobj->own == SWIG_POINTER_OWN) { swig_type_info *ty = sobj->ty; SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; PyObject *destroy = data ? data->destroy : 0; if (destroy) { /* destroy is always a VARARGS method */ PyObject *res; if (data->delargs) { /* we need to create a temporary object to carry the destroy operation */ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); res = SWIG_Python_CallFunctor(destroy, tmp); Py_DECREF(tmp); } else { PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); PyObject *mself = PyCFunction_GET_SELF(destroy); res = ((*meth)(mself, v)); } Py_XDECREF(res); } #if !defined(SWIG_PYTHON_SILENT_MEMLEAK) else { const char *name = SWIG_TypePrettyName(ty); printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); } #endif } Py_XDECREF(next); PyObject_DEL(v); } SWIGRUNTIME PyObject* SwigPyObject_append(PyObject* v, PyObject* next) { SwigPyObject *sobj = (SwigPyObject *) v; #ifndef METH_O PyObject *tmp = 0; if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; next = tmp; #endif if (!SwigPyObject_Check(next)) { return NULL; } sobj->next = next; Py_INCREF(next); return SWIG_Py_Void(); } SWIGRUNTIME PyObject* #ifdef METH_NOARGS SwigPyObject_next(PyObject* v) #else SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) #endif { SwigPyObject *sobj = (SwigPyObject *) v; if (sobj->next) { Py_INCREF(sobj->next); return sobj->next; } else { return SWIG_Py_Void(); } } SWIGINTERN PyObject* #ifdef METH_NOARGS SwigPyObject_disown(PyObject *v) #else SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) #endif { SwigPyObject *sobj = (SwigPyObject *)v; sobj->own = 0; return SWIG_Py_Void(); } SWIGINTERN PyObject* #ifdef METH_NOARGS SwigPyObject_acquire(PyObject *v) #else SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) #endif { SwigPyObject *sobj = (SwigPyObject *)v; sobj->own = SWIG_POINTER_OWN; return SWIG_Py_Void(); } SWIGINTERN PyObject* SwigPyObject_own(PyObject *v, PyObject *args) { PyObject *val = 0; #if (PY_VERSION_HEX < 0x02020000) if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) #else if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) #endif { return NULL; } else { SwigPyObject *sobj = (SwigPyObject *)v; PyObject *obj = PyBool_FromLong(sobj->own); if (val) { #ifdef METH_NOARGS if (PyObject_IsTrue(val)) { SwigPyObject_acquire(v); } else { SwigPyObject_disown(v); } #else if (PyObject_IsTrue(val)) { SwigPyObject_acquire(v,args); } else { SwigPyObject_disown(v,args); } #endif } return obj; } } #ifdef METH_O static PyMethodDef swigobject_methods[] = { {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, {0, 0, 0, 0} }; #else static PyMethodDef swigobject_methods[] = { {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, {0, 0, 0, 0} }; #endif #if PY_VERSION_HEX < 0x02020000 SWIGINTERN PyObject * SwigPyObject_getattr(SwigPyObject *sobj,char *name) { return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); } #endif SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void) { static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; static PyNumberMethods SwigPyObject_as_number = { (binaryfunc)0, /*nb_add*/ (binaryfunc)0, /*nb_subtract*/ (binaryfunc)0, /*nb_multiply*/ /* nb_divide removed in Python 3 */ #if PY_VERSION_HEX < 0x03000000 (binaryfunc)0, /*nb_divide*/ #endif (binaryfunc)0, /*nb_remainder*/ (binaryfunc)0, /*nb_divmod*/ (ternaryfunc)0,/*nb_power*/ (unaryfunc)0, /*nb_negative*/ (unaryfunc)0, /*nb_positive*/ (unaryfunc)0, /*nb_absolute*/ (inquiry)0, /*nb_nonzero*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ #if PY_VERSION_HEX < 0x03000000 0, /*nb_coerce*/ #endif (unaryfunc)SwigPyObject_long, /*nb_int*/ #if PY_VERSION_HEX < 0x03000000 (unaryfunc)SwigPyObject_long, /*nb_long*/ #else 0, /*nb_reserved*/ #endif (unaryfunc)0, /*nb_float*/ #if PY_VERSION_HEX < 0x03000000 (unaryfunc)SwigPyObject_oct, /*nb_oct*/ (unaryfunc)SwigPyObject_hex, /*nb_hex*/ #endif #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ #endif }; static PyTypeObject swigpyobject_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { /* PyObject header changed in Python 3 */ #if PY_VERSION_HEX >= 0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif (char *)"SwigPyObject", /* tp_name */ sizeof(SwigPyObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ (printfunc)SwigPyObject_print, /* tp_print */ #if PY_VERSION_HEX < 0x02020000 (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ #else (getattrfunc)0, /* tp_getattr */ #endif (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX >= 0x03000000 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ #else (cmpfunc)SwigPyObject_compare, /* tp_compare */ #endif (reprfunc)SwigPyObject_repr, /* tp_repr */ &SwigPyObject_as_number, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc)0, /* tp_hash */ (ternaryfunc)0, /* tp_call */ (reprfunc)SwigPyObject_str, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ swigobject_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ swigobject_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #if PY_VERSION_HEX >= 0x02060000 0, /* tp_version */ #endif #ifdef COUNT_ALLOCS 0,0,0,0 /* tp_alloc -> tp_next */ #endif }; swigpyobject_type = tmp; type_init = 1; #if PY_VERSION_HEX < 0x02020000 swigpyobject_type.ob_type = &PyType_Type; #else if (PyType_Ready(&swigpyobject_type) < 0) return NULL; #endif } return &swigpyobject_type; } SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own) { SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); if (sobj) { sobj->ptr = ptr; sobj->ty = ty; sobj->own = own; sobj->next = 0; } return (PyObject *)sobj; } /* ----------------------------------------------------------------------------- * Implements a simple Swig Packed type, and use it instead of string * ----------------------------------------------------------------------------- */ typedef struct { PyObject_HEAD void *pack; swig_type_info *ty; size_t size; } SwigPyPacked; SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { char result[SWIG_BUFFER_SIZE]; fputs("pack, v->size, 0, sizeof(result))) { fputs("at ", fp); fputs(result, fp); } fputs(v->ty->name,fp); fputs(">", fp); return 0; } SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v) { char result[SWIG_BUFFER_SIZE]; if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { return SWIG_Python_str_FromFormat("", result, v->ty->name); } else { return SWIG_Python_str_FromFormat("", v->ty->name); } } SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v) { char result[SWIG_BUFFER_SIZE]; if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); } else { return SWIG_Python_str_FromChar(v->ty->name); } } SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) { size_t i = v->size; size_t j = w->size; int s = (i < j) ? -1 : ((i > j) ? 1 : 0); return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); } SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); SWIGRUNTIME PyTypeObject* SwigPyPacked_type(void) { static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); return type; } SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op) { return ((op)->ob_type == SwigPyPacked_TypeOnce()) || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); } SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v) { if (SwigPyPacked_Check(v)) { SwigPyPacked *sobj = (SwigPyPacked *) v; free(sobj->pack); } PyObject_DEL(v); } SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void) { static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; static PyTypeObject swigpypacked_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { /* PyObject header changed in Python 3 */ #if PY_VERSION_HEX>=0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif (char *)"SwigPyPacked", /* tp_name */ sizeof(SwigPyPacked), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ (printfunc)SwigPyPacked_print, /* tp_print */ (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX>=0x03000000 0, /* tp_reserved in 3.0.1 */ #else (cmpfunc)SwigPyPacked_compare, /* tp_compare */ #endif (reprfunc)SwigPyPacked_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc)0, /* tp_hash */ (ternaryfunc)0, /* tp_call */ (reprfunc)SwigPyPacked_str, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ swigpacked_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ 0, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0, /* tp_free */ 0, /* tp_is_gc */ 0, /* tp_bases */ 0, /* tp_mro */ 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #if PY_VERSION_HEX >= 0x02060000 0, /* tp_version */ #endif #ifdef COUNT_ALLOCS 0,0,0,0 /* tp_alloc -> tp_next */ #endif }; swigpypacked_type = tmp; type_init = 1; #if PY_VERSION_HEX < 0x02020000 swigpypacked_type.ob_type = &PyType_Type; #else if (PyType_Ready(&swigpypacked_type) < 0) return NULL; #endif } return &swigpypacked_type; } SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) { SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); if (sobj) { void *pack = malloc(size); if (pack) { memcpy(pack, ptr, size); sobj->pack = pack; sobj->ty = ty; sobj->size = size; } else { PyObject_DEL((PyObject *) sobj); sobj = 0; } } return (PyObject *) sobj; } SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) { if (SwigPyPacked_Check(obj)) { SwigPyPacked *sobj = (SwigPyPacked *)obj; if (sobj->size != size) return 0; memcpy(ptr, sobj->pack, size); return sobj->ty; } else { return 0; } } /* ----------------------------------------------------------------------------- * pointers/data manipulation * ----------------------------------------------------------------------------- */ SWIGRUNTIMEINLINE PyObject * _SWIG_This(void) { return SWIG_Python_str_FromChar("this"); } static PyObject *swig_this = NULL; SWIGRUNTIME PyObject * SWIG_This(void) { if (swig_this == NULL) swig_this = _SWIG_This(); return swig_this; } /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ /* TODO: I don't know how to implement the fast getset in Python 3 right now */ #if PY_VERSION_HEX>=0x03000000 #define SWIG_PYTHON_SLOW_GETSET_THIS #endif SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj) { PyObject *obj; if (SwigPyObject_Check(pyobj)) return (SwigPyObject *) pyobj; #ifdef SWIGPYTHON_BUILTIN (void)obj; # ifdef PyWeakref_CheckProxy if (PyWeakref_CheckProxy(pyobj)) { pyobj = PyWeakref_GET_OBJECT(pyobj); if (pyobj && SwigPyObject_Check(pyobj)) return (SwigPyObject*) pyobj; } # endif return NULL; #else obj = 0; #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) if (PyInstance_Check(pyobj)) { obj = _PyInstance_Lookup(pyobj, SWIG_This()); } else { PyObject **dictptr = _PyObject_GetDictPtr(pyobj); if (dictptr != NULL) { PyObject *dict = *dictptr; obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; } else { #ifdef PyWeakref_CheckProxy if (PyWeakref_CheckProxy(pyobj)) { PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; } #endif obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; } } } #else obj = PyObject_GetAttr(pyobj,SWIG_This()); if (obj) { Py_DECREF(obj); } else { if (PyErr_Occurred()) PyErr_Clear(); return 0; } #endif if (obj && !SwigPyObject_Check(obj)) { /* a PyObject is called 'this', try to get the 'real this' SwigPyObject from it */ return SWIG_Python_GetSwigThis(obj); } return (SwigPyObject *)obj; #endif } /* Acquire a pointer value */ SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own) { if (own == SWIG_POINTER_OWN) { SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); if (sobj) { int oldown = sobj->own; sobj->own = own; return oldown; } } return 0; } /* Convert a pointer value */ SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { int res; SwigPyObject *sobj; if (!obj) return SWIG_ERROR; if (obj == Py_None) { if (ptr) *ptr = 0; return SWIG_OK; } res = SWIG_ERROR; sobj = SWIG_Python_GetSwigThis(obj); if (own) *own = 0; while (sobj) { void *vptr = sobj->ptr; if (ty) { swig_type_info *to = sobj->ty; if (to == ty) { /* no type cast needed */ if (ptr) *ptr = vptr; break; } else { swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); if (!tc) { sobj = (SwigPyObject *)sobj->next; } else { if (ptr) { int newmemory = 0; *ptr = SWIG_TypeCast(tc,vptr,&newmemory); if (newmemory == SWIG_CAST_NEW_MEMORY) { assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ if (own) *own = *own | SWIG_CAST_NEW_MEMORY; } } break; } } } else { if (ptr) *ptr = vptr; break; } } if (sobj) { if (own) *own = *own | sobj->own; if (flags & SWIG_POINTER_DISOWN) { sobj->own = 0; } res = SWIG_OK; } else { if (flags & SWIG_POINTER_IMPLICIT_CONV) { SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; if (data && !data->implicitconv) { PyObject *klass = data->klass; if (klass) { PyObject *impconv; data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ impconv = SWIG_Python_CallFunctor(klass, obj); data->implicitconv = 0; if (PyErr_Occurred()) { PyErr_Clear(); impconv = 0; } if (impconv) { SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); if (iobj) { void *vptr; res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); if (SWIG_IsOK(res)) { if (ptr) { *ptr = vptr; /* transfer the ownership to 'ptr' */ iobj->own = 0; res = SWIG_AddCast(res); res = SWIG_AddNewMask(res); } else { res = SWIG_AddCast(res); } } } Py_DECREF(impconv); } } } } } return res; } /* Convert a function ptr value */ SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { if (!PyCFunction_Check(obj)) { return SWIG_ConvertPtr(obj, ptr, ty, 0); } else { void *vptr = 0; /* here we get the method pointer for callbacks */ const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; if (desc) desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; if (!desc) return SWIG_ERROR; if (ty) { swig_cast_info *tc = SWIG_TypeCheck(desc,ty); if (tc) { int newmemory = 0; *ptr = SWIG_TypeCast(tc,vptr,&newmemory); assert(!newmemory); /* newmemory handling not yet implemented */ } else { return SWIG_ERROR; } } else { *ptr = vptr; } return SWIG_OK; } } /* Convert a packed value value */ SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); if (!to) return SWIG_ERROR; if (ty) { if (to != ty) { /* check type cast? */ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); if (!tc) return SWIG_ERROR; } } return SWIG_OK; } /* ----------------------------------------------------------------------------- * Create a new pointer object * ----------------------------------------------------------------------------- */ /* Create a new instance object, without calling __init__, and set the 'this' attribute. */ SWIGRUNTIME PyObject* SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) { #if (PY_VERSION_HEX >= 0x02020000) PyObject *inst = 0; PyObject *newraw = data->newraw; if (newraw) { inst = PyObject_Call(newraw, data->newargs, NULL); if (inst) { #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { PyObject *dict = *dictptr; if (dict == NULL) { dict = PyDict_New(); *dictptr = dict; PyDict_SetItem(dict, SWIG_This(), swig_this); } } #else PyObject *key = SWIG_This(); PyObject_SetAttr(inst, key, swig_this); #endif } } else { #if PY_VERSION_HEX >= 0x03000000 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); PyObject_SetAttr(inst, SWIG_This(), swig_this); Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; #else PyObject *dict = PyDict_New(); PyDict_SetItem(dict, SWIG_This(), swig_this); inst = PyInstance_NewRaw(data->newargs, dict); Py_DECREF(dict); #endif } return inst; #else #if (PY_VERSION_HEX >= 0x02010000) PyObject *inst; PyObject *dict = PyDict_New(); PyDict_SetItem(dict, SWIG_This(), swig_this); inst = PyInstance_NewRaw(data->newargs, dict); Py_DECREF(dict); return (PyObject *) inst; #else PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); if (inst == NULL) { return NULL; } inst->in_class = (PyClassObject *)data->newargs; Py_INCREF(inst->in_class); inst->in_dict = PyDict_New(); if (inst->in_dict == NULL) { Py_DECREF(inst); return NULL; } #ifdef Py_TPFLAGS_HAVE_WEAKREFS inst->in_weakreflist = NULL; #endif #ifdef Py_TPFLAGS_GC PyObject_GC_Init(inst); #endif PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); return (PyObject *) inst; #endif #endif } SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) { PyObject *dict; #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { dict = *dictptr; if (dict == NULL) { dict = PyDict_New(); *dictptr = dict; } PyDict_SetItem(dict, SWIG_This(), swig_this); return; } #endif dict = PyObject_GetAttrString(inst, (char*)"__dict__"); PyDict_SetItem(dict, SWIG_This(), swig_this); Py_DECREF(dict); } SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args) { PyObject *obj[2]; if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) { return NULL; } else { SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); if (sthis) { SwigPyObject_append((PyObject*) sthis, obj[1]); } else { SWIG_Python_SetSwigThis(obj[0], obj[1]); } return SWIG_Py_Void(); } } /* Create a new pointer object */ SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { SwigPyClientData *clientdata; PyObject * robj; int own; if (!ptr) return SWIG_Py_Void(); clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; if (clientdata && clientdata->pytype) { SwigPyObject *newobj; if (flags & SWIG_BUILTIN_TP_INIT) { newobj = (SwigPyObject*) self; if (newobj->ptr) { PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); while (newobj->next) newobj = (SwigPyObject *) newobj->next; newobj->next = next_self; newobj = (SwigPyObject *)next_self; } } else { newobj = PyObject_New(SwigPyObject, clientdata->pytype); } if (newobj) { newobj->ptr = ptr; newobj->ty = type; newobj->own = own; newobj->next = 0; #ifdef SWIGPYTHON_BUILTIN newobj->dict = 0; #endif return (PyObject*) newobj; } return SWIG_Py_Void(); } assert(!(flags & SWIG_BUILTIN_TP_INIT)); robj = SwigPyObject_New(ptr, type, own); if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); if (inst) { Py_DECREF(robj); robj = inst; } } return robj; } /* Create a new packed object */ SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); } /* -----------------------------------------------------------------------------* * Get type list * -----------------------------------------------------------------------------*/ #ifdef SWIG_LINK_RUNTIME void *SWIG_ReturnGlobalTypeList(void *); #endif SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void) { static void *type_pointer = (void *)0; /* first check if module already created */ if (!type_pointer) { #ifdef SWIG_LINK_RUNTIME type_pointer = SWIG_ReturnGlobalTypeList((void *)0); #else # ifdef SWIGPY_USE_CAPSULE type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); # else type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); # endif if (PyErr_Occurred()) { PyErr_Clear(); type_pointer = (void *)0; } #endif } return (swig_module_info *) type_pointer; } #if PY_MAJOR_VERSION < 2 /* PyModule_AddObject function was introduced in Python 2.0. The following function is copied out of Python/modsupport.c in python version 2.3.4 */ SWIGINTERN int PyModule_AddObject(PyObject *m, char *name, PyObject *o) { PyObject *dict; if (!PyModule_Check(m)) { PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); return SWIG_ERROR; } if (!o) { PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); return SWIG_ERROR; } dict = PyModule_GetDict(m); if (dict == NULL) { /* Internal error -- modules must have a dict! */ PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", PyModule_GetName(m)); return SWIG_ERROR; } if (PyDict_SetItemString(dict, name, o)) return SWIG_ERROR; Py_DECREF(o); return SWIG_OK; } #endif SWIGRUNTIME void #ifdef SWIGPY_USE_CAPSULE SWIG_Python_DestroyModule(PyObject *obj) #else SWIG_Python_DestroyModule(void *vptr) #endif { #ifdef SWIGPY_USE_CAPSULE swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); #else swig_module_info *swig_module = (swig_module_info *) vptr; #endif swig_type_info **types = swig_module->types; size_t i; for (i =0; i < swig_module->size; ++i) { swig_type_info *ty = types[i]; if (ty->owndata) { SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; if (data) SwigPyClientData_Del(data); } } Py_DECREF(SWIG_This()); swig_this = NULL; } SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module) { #if PY_VERSION_HEX >= 0x03000000 /* Add a dummy module object into sys.modules */ PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); #else static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); #endif #ifdef SWIGPY_USE_CAPSULE PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); if (pointer && module) { PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); } else { Py_XDECREF(pointer); } #else PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); if (pointer && module) { PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); } else { Py_XDECREF(pointer); } #endif } /* The python cached type query */ SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void) { static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); return cache; } SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type) { PyObject *cache = SWIG_Python_TypeCache(); PyObject *key = SWIG_Python_str_FromChar(type); PyObject *obj = PyDict_GetItem(cache, key); swig_type_info *descriptor; if (obj) { #ifdef SWIGPY_USE_CAPSULE descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); #else descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); #endif } else { swig_module_info *swig_module = SWIG_Python_GetModule(); descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { #ifdef SWIGPY_USE_CAPSULE obj = PyCapsule_New((void*) descriptor, NULL, NULL); #else obj = PyCObject_FromVoidPtr(descriptor, NULL); #endif PyDict_SetItem(cache, key, obj); Py_DECREF(obj); } } Py_DECREF(key); return descriptor; } /* For backward compatibility only */ #define SWIG_POINTER_EXCEPTION 0 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) SWIGRUNTIME int SWIG_Python_AddErrMesg(const char* mesg, int infront) { if (PyErr_Occurred()) { PyObject *type = 0; PyObject *value = 0; PyObject *traceback = 0; PyErr_Fetch(&type, &value, &traceback); if (value) { char *tmp; PyObject *old_str = PyObject_Str(value); Py_XINCREF(type); PyErr_Clear(); if (infront) { PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); } else { PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); } SWIG_Python_str_DelForPy3(tmp); Py_DECREF(old_str); } return 1; } else { return 0; } } SWIGRUNTIME int SWIG_Python_ArgFail(int argnum) { if (PyErr_Occurred()) { /* add information about failing argument */ char mesg[256]; PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); return SWIG_Python_AddErrMesg(mesg, 1); } else { return 0; } } SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self) { SwigPyObject *v = (SwigPyObject *)self; swig_type_info *ty = v ? v->ty : 0; return ty ? ty->str : (char*)""; } SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj) { if (type) { #if defined(SWIG_COBJECT_TYPES) if (obj && SwigPyObject_Check(obj)) { const char *otype = (const char *) SwigPyObject_GetDesc(obj); if (otype) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", type, otype); return; } } else #endif { const char *otype = (obj ? obj->ob_type->tp_name : 0); if (otype) { PyObject *str = PyObject_Str(obj); const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; if (cstr) { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", type, otype, cstr); SWIG_Python_str_DelForPy3(cstr); } else { PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", type, otype); } Py_XDECREF(str); return; } } PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); } else { PyErr_Format(PyExc_TypeError, "unexpected type is received"); } } /* Convert a pointer value, signal an exception on a type mismatch */ SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { void *result; if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { PyErr_Clear(); #if SWIG_POINTER_EXCEPTION if (flags) { SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); SWIG_Python_ArgFail(argnum); } #endif } return result; } SWIGRUNTIME int SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { PyTypeObject *tp = obj->ob_type; PyObject *descr; PyObject *encoded_name; descrsetfunc f; int res; #ifdef Py_USING_UNICODE if (PyString_Check(name)) { name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); if (!name) return -1; } else if (!PyUnicode_Check(name)) #else if (!PyString_Check(name)) #endif { PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); return -1; } else { Py_INCREF(name); } if (!tp->tp_dict) { if (PyType_Ready(tp) < 0) goto done; } res = -1; descr = _PyType_Lookup(tp, name); f = NULL; if (descr != NULL) f = descr->ob_type->tp_descr_set; if (!f) { if (PyString_Check(name)) { encoded_name = name; Py_INCREF(name); } else { encoded_name = PyUnicode_AsUTF8String(name); } PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); Py_DECREF(encoded_name); } else { res = f(descr, obj, value); } done: Py_DECREF(name); return res; } #ifdef __cplusplus } #endif #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_CK_ATTRIBUTE_SMART swig_types[0] #define SWIGTYPE_p_CK_DATE swig_types[1] #define SWIGTYPE_p_CK_INFO swig_types[2] #define SWIGTYPE_p_CK_MECHANISM swig_types[3] #define SWIGTYPE_p_CK_MECHANISM_INFO swig_types[4] #define SWIGTYPE_p_CK_OBJECT_HANDLE swig_types[5] #define SWIGTYPE_p_CK_SESSION_HANDLE swig_types[6] #define SWIGTYPE_p_CK_SESSION_INFO swig_types[7] #define SWIGTYPE_p_CK_SLOT_INFO swig_types[8] #define SWIGTYPE_p_CK_TOKEN_INFO swig_types[9] #define SWIGTYPE_p_CK_VERSION swig_types[10] #define SWIGTYPE_p_CPKCS11Lib swig_types[11] #define SWIGTYPE_p_allocator_type swig_types[12] #define SWIGTYPE_p_byteArray swig_types[13] #define SWIGTYPE_p_char swig_types[14] #define SWIGTYPE_p_difference_type swig_types[15] #define SWIGTYPE_p_p_PyObject swig_types[16] #define SWIGTYPE_p_size_type swig_types[17] #define SWIGTYPE_p_std__allocatorT_CK_ATTRIBUTE_SMART_t swig_types[18] #define SWIGTYPE_p_std__allocatorT_CK_OBJECT_HANDLE_t swig_types[19] #define SWIGTYPE_p_std__allocatorT_long_t swig_types[20] #define SWIGTYPE_p_std__allocatorT_unsigned_char_t swig_types[21] #define SWIGTYPE_p_std__invalid_argument swig_types[22] #define SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t swig_types[23] #define SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t swig_types[24] #define SWIGTYPE_p_std__vectorT__Tp__Alloc_t swig_types[25] #define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[26] #define SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t swig_types[27] #define SWIGTYPE_p_swig__SwigPyIterator swig_types[28] #define SWIGTYPE_p_unsigned_char swig_types[29] #define SWIGTYPE_p_unsigned_long swig_types[30] #define SWIGTYPE_p_value_type swig_types[31] #define SWIGTYPE_p_void swig_types[32] static swig_type_info *swig_types[34]; static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) /* -------- TYPES TABLE (END) -------- */ #if (PY_VERSION_HEX <= 0x02000000) # if !defined(SWIG_PYTHON_CLASSIC) # error "This python version requires swig to be run with the '-classic' option" # endif #endif /*----------------------------------------------- @(target):= _LowLevel.so ------------------------------------------------*/ #if PY_VERSION_HEX >= 0x03000000 # define SWIG_init PyInit__LowLevel #else # define SWIG_init init_LowLevel #endif #define SWIG_name "_LowLevel" #define SWIGVERSION 0x020004 #define SWIG_VERSION SWIGVERSION #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) #include namespace swig { class SwigPtr_PyObject { protected: PyObject *_obj; public: SwigPtr_PyObject() :_obj(0) { } SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) { Py_XINCREF(_obj); } SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) { if (initial_ref) { Py_XINCREF(_obj); } } SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) { Py_XINCREF(item._obj); Py_XDECREF(_obj); _obj = item._obj; return *this; } ~SwigPtr_PyObject() { Py_XDECREF(_obj); } operator PyObject *() const { return _obj; } PyObject *operator->() const { return _obj; } }; } namespace swig { struct SwigVar_PyObject : SwigPtr_PyObject { SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } SwigVar_PyObject & operator = (PyObject* obj) { Py_XDECREF(_obj); _obj = obj; return *this; } }; } #include #include #include #include "opensc/pkcs11.h" #ifdef WIN32 #pragma warning(disable: 4800 4244) #endif #include #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" using namespace std; using namespace std; typedef struct SWIGCDATA { char *data; size_t len; } SWIGCDATA; extern "C" { static SWIGCDATA cdata_void(void *ptr, size_t nelements) { SWIGCDATA d; d.data = (char *) ptr; d.len = nelements; return d; } } SWIGINTERN int SWIG_AsVal_double (PyObject *obj, double *val) { int res = SWIG_TypeError; if (PyFloat_Check(obj)) { if (val) *val = PyFloat_AsDouble(obj); return SWIG_OK; } else if (PyInt_Check(obj)) { if (val) *val = PyInt_AsLong(obj); return SWIG_OK; } else if (PyLong_Check(obj)) { double v = PyLong_AsDouble(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_OK; } else { PyErr_Clear(); } } #ifdef SWIG_PYTHON_CAST_MODE { int dispatch = 0; double d = PyFloat_AsDouble(obj); if (!PyErr_Occurred()) { if (val) *val = d; return SWIG_AddCast(SWIG_OK); } else { PyErr_Clear(); } if (!dispatch) { long v = PyLong_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); } else { PyErr_Clear(); } } } #endif return res; } #include #include SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max) { double x = *d; if ((min <= x && x <= max)) { double fx = floor(x); double cx = ceil(x); double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ if ((errno == EDOM) || (errno == ERANGE)) { errno = 0; } else { double summ, reps, diff; if (rd < x) { diff = x - rd; } else if (rd > x) { diff = rd - x; } else { return 1; } summ = rd + x; reps = diff/summ; if (reps < 8*DBL_EPSILON) { *d = rd; return 1; } } } return 0; } SWIGINTERN int SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) { if (PyInt_Check(obj)) { long v = PyInt_AsLong(obj); if (v >= 0) { if (val) *val = v; return SWIG_OK; } else { return SWIG_OverflowError; } } else if (PyLong_Check(obj)) { unsigned long v = PyLong_AsUnsignedLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_OK; } else { PyErr_Clear(); } } #ifdef SWIG_PYTHON_CAST_MODE { int dispatch = 0; unsigned long v = PyLong_AsUnsignedLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_AddCast(SWIG_OK); } else { PyErr_Clear(); } if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { if (val) *val = (unsigned long)(d); return res; } } } #endif return SWIG_TypeError; } SWIGINTERNINLINE int SWIG_AsVal_size_t (PyObject * obj, size_t *val) { unsigned long v; int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); return res; } SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { static int init = 0; static swig_type_info* info = 0; if (!init) { info = SWIG_TypeQuery("_p_char"); init = 1; } return info; } SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char* carray, size_t size) { if (carray) { if (size > INT_MAX) { swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); return pchar_descriptor ? SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); } else { #if PY_VERSION_HEX >= 0x03000000 return PyUnicode_FromStringAndSize(carray, static_cast< int >(size)); #else return PyString_FromStringAndSize(carray, static_cast< int >(size)); #endif } } else { return SWIG_Py_Void(); } } SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) { #if PY_VERSION_HEX>=0x03000000 if (PyUnicode_Check(obj)) #else if (PyString_Check(obj)) #endif { char *cstr; Py_ssize_t len; #if PY_VERSION_HEX>=0x03000000 if (!alloc && cptr) { /* We can't allow converting without allocation, since the internal representation of string in Python 3 is UCS-2/UCS-4 but we require a UTF-8 representation. TODO(bhy) More detailed explanation */ return SWIG_RuntimeError; } obj = PyUnicode_AsUTF8String(obj); PyBytes_AsStringAndSize(obj, &cstr, &len); if(alloc) *alloc = SWIG_NEWOBJ; #else PyString_AsStringAndSize(obj, &cstr, &len); #endif if (cptr) { if (alloc) { /* In python the user should not be able to modify the inner string representation. To warranty that, if you define SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string buffer is always returned. The default behavior is just to return the pointer value, so, be careful. */ #if defined(SWIG_PYTHON_SAFE_CSTRINGS) if (*alloc != SWIG_OLDOBJ) #else if (*alloc == SWIG_NEWOBJ) #endif { *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); *alloc = SWIG_NEWOBJ; } else { *cptr = cstr; *alloc = SWIG_OLDOBJ; } } else { #if PY_VERSION_HEX>=0x03000000 assert(0); /* Should never reach here in Python 3 */ #endif *cptr = SWIG_Python_str_AsChar(obj); } } if (psize) *psize = len + 1; #if PY_VERSION_HEX>=0x03000000 Py_XDECREF(obj); #endif return SWIG_OK; } else { swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); if (pchar_descriptor) { void* vptr = 0; if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { if (cptr) *cptr = (char *) vptr; if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; if (alloc) *alloc = SWIG_OLDOBJ; return SWIG_OK; } } } return SWIG_TypeError; } #include #if PY_VERSION_HEX >= 0x03020000 # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj)) #else # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj)) #endif #include #if defined(__GNUC__) # if __GNUC__ == 2 && __GNUC_MINOR <= 96 # define SWIG_STD_NOMODERN_STL # endif #endif #include #include #include namespace swig { struct stop_iteration { }; struct SwigPyIterator { private: SwigPtr_PyObject _seq; protected: SwigPyIterator(PyObject *seq) : _seq(seq) { } public: virtual ~SwigPyIterator() {} // Access iterator method, required by Python virtual PyObject *value() const = 0; // Forward iterator method, required by Python virtual SwigPyIterator *incr(size_t n = 1) = 0; // Backward iterator method, very common in C++, but not required in Python virtual SwigPyIterator *decr(size_t /*n*/ = 1) { throw stop_iteration(); } // Random access iterator methods, but not required in Python virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const { throw std::invalid_argument("operation not supported"); } virtual bool equal (const SwigPyIterator &/*x*/) const { throw std::invalid_argument("operation not supported"); } // C++ common/needed methods virtual SwigPyIterator *copy() const = 0; PyObject *next() { SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads PyObject *obj = value(); incr(); SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads return obj; } /* Make an alias for Python 3.x */ PyObject *__next__() { return next(); } PyObject *previous() { SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads decr(); PyObject *obj = value(); SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads return obj; } SwigPyIterator *advance(ptrdiff_t n) { return (n > 0) ? incr(n) : decr(-n); } bool operator == (const SwigPyIterator& x) const { return equal(x); } bool operator != (const SwigPyIterator& x) const { return ! operator==(x); } SwigPyIterator& operator += (ptrdiff_t n) { return *advance(n); } SwigPyIterator& operator -= (ptrdiff_t n) { return *advance(-n); } SwigPyIterator* operator + (ptrdiff_t n) const { return copy()->advance(n); } SwigPyIterator* operator - (ptrdiff_t n) const { return copy()->advance(-n); } ptrdiff_t operator - (const SwigPyIterator& x) const { return x.distance(*this); } static swig_type_info* descriptor() { static int init = 0; static swig_type_info* desc = 0; if (!init) { desc = SWIG_TypeQuery("swig::SwigPyIterator *"); init = 1; } return desc; } }; #if defined(SWIGPYTHON_BUILTIN) inline PyObject* make_output_iterator_builtin (PyObject *pyself) { Py_INCREF(pyself); return pyself; } #endif } #define SWIG_From_long PyInt_FromLong SWIGINTERNINLINE PyObject * SWIG_From_ptrdiff_t (ptrdiff_t value) { return SWIG_From_long (static_cast< long >(value)); } SWIGINTERNINLINE PyObject* SWIG_From_bool (bool value) { return PyBool_FromLong(value ? 1 : 0); } SWIGINTERN int SWIG_AsVal_long (PyObject *obj, long* val) { if (PyInt_Check(obj)) { if (val) *val = PyInt_AsLong(obj); return SWIG_OK; } else if (PyLong_Check(obj)) { long v = PyLong_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_OK; } else { PyErr_Clear(); } } #ifdef SWIG_PYTHON_CAST_MODE { int dispatch = 0; long v = PyInt_AsLong(obj); if (!PyErr_Occurred()) { if (val) *val = v; return SWIG_AddCast(SWIG_OK); } else { PyErr_Clear(); } if (!dispatch) { double d; int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { if (val) *val = (long)(d); return res; } } } #endif return SWIG_TypeError; } SWIGINTERNINLINE int SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val) { long v; int res = SWIG_AsVal_long (obj, val ? &v : 0); if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); return res; } #include #include #include namespace swig { template struct noconst_traits { typedef Type noconst_type; }; template struct noconst_traits { typedef Type noconst_type; }; /* type categories */ struct pointer_category { }; struct value_category { }; /* General traits that provides type_name and type_info */ template struct traits { }; template inline const char* type_name() { return traits::noconst_type >::type_name(); } template struct traits_info { static swig_type_info *type_query(std::string name) { name += " *"; return SWIG_TypeQuery(name.c_str()); } static swig_type_info *type_info() { static swig_type_info *info = type_query(type_name()); return info; } }; template inline swig_type_info *type_info() { return traits_info::type_info(); } /* Partial specialization for pointers */ template struct traits { typedef pointer_category category; static std::string make_ptr_name(const char* name) { std::string ptrname = name; ptrname += " *"; return ptrname; } static const char* type_name() { static std::string name = make_ptr_name(swig::type_name()); return name.c_str(); } }; template struct traits_as { }; template struct traits_check { }; } namespace swig { /* Traits that provides the from method */ template struct traits_from_ptr { static PyObject *from(Type *val, int owner = 0) { return SWIG_InternalNewPointerObj(val, type_info(), owner); } }; template struct traits_from { static PyObject *from(const Type& val) { return traits_from_ptr::from(new Type(val), 1); } }; template struct traits_from { static PyObject *from(Type* val) { return traits_from_ptr::from(val, 0); } }; template struct traits_from { static PyObject *from(const Type* val) { return traits_from_ptr::from(const_cast(val), 0); } }; template inline PyObject *from(const Type& val) { return traits_from::from(val); } template inline PyObject *from_ptr(Type* val, int owner) { return traits_from_ptr::from(val, owner); } /* Traits that provides the asval/as/check method */ template struct traits_asptr { static int asptr(PyObject *obj, Type **val) { Type *p; int res = SWIG_ConvertPtr(obj, (void**)&p, type_info(), 0); if (SWIG_IsOK(res)) { if (val) *val = p; } return res; } }; template inline int asptr(PyObject *obj, Type **vptr) { return traits_asptr::asptr(obj, vptr); } template struct traits_asval { static int asval(PyObject *obj, Type *val) { if (val) { Type *p = 0; int res = traits_asptr::asptr(obj, &p); if (!SWIG_IsOK(res)) return res; if (p) { typedef typename noconst_traits::noconst_type noconst_type; *(const_cast(val)) = *p; if (SWIG_IsNewObj(res)){ delete p; res = SWIG_DelNewMask(res); } return res; } else { return SWIG_ERROR; } } else { return traits_asptr::asptr(obj, (Type **)(0)); } } }; template struct traits_asval { static int asval(PyObject *obj, Type **val) { if (val) { typedef typename noconst_traits::noconst_type noconst_type; noconst_type *p = 0; int res = traits_asptr::asptr(obj, &p); if (SWIG_IsOK(res)) { *(const_cast(val)) = p; } return res; } else { return traits_asptr::asptr(obj, (Type **)(0)); } } }; template inline int asval(PyObject *obj, Type *val) { return traits_asval::asval(obj, val); } template struct traits_as { static Type as(PyObject *obj, bool throw_error) { Type v; int res = asval(obj, &v); if (!obj || !SWIG_IsOK(res)) { if (!PyErr_Occurred()) { ::SWIG_Error(SWIG_TypeError, swig::type_name()); } if (throw_error) throw std::invalid_argument("bad type"); } return v; } }; template struct traits_as { static Type as(PyObject *obj, bool throw_error) { Type *v = 0; int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); if (SWIG_IsOK(res) && v) { if (SWIG_IsNewObj(res)) { Type r(*v); delete v; return r; } else { return *v; } } else { // Uninitialized return value, no Type() constructor required. static Type *v_def = (Type*) malloc(sizeof(Type)); if (!PyErr_Occurred()) { SWIG_Error(SWIG_TypeError, swig::type_name()); } if (throw_error) throw std::invalid_argument("bad type"); memset(v_def,0,sizeof(Type)); return *v_def; } } }; template struct traits_as { static Type* as(PyObject *obj, bool throw_error) { Type *v = 0; int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); if (SWIG_IsOK(res)) { return v; } else { if (!PyErr_Occurred()) { SWIG_Error(SWIG_TypeError, swig::type_name()); } if (throw_error) throw std::invalid_argument("bad type"); return 0; } } }; template inline Type as(PyObject *obj, bool te = false) { return traits_as::category>::as(obj, te); } template struct traits_check { static bool check(PyObject *obj) { int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR; return SWIG_IsOK(res) ? true : false; } }; template struct traits_check { static bool check(PyObject *obj) { int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR; return SWIG_IsOK(res) ? true : false; } }; template inline bool check(PyObject *obj) { return traits_check::category>::check(obj); } } #include namespace std { template <> struct less : public binary_function { bool operator()(PyObject * v, PyObject *w) const { bool res; SWIG_PYTHON_THREAD_BEGIN_BLOCK; res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false; /* This may fall into a case of inconsistent eg. ObjA > ObjX > ObjB but ObjA < ObjB */ if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) ) { /* Objects can't be compared, this mostly occurred in Python 3.0 */ /* Compare their ptr directly for a workaround */ res = (v < w); PyErr_Clear(); } SWIG_PYTHON_THREAD_END_BLOCK; return res; } }; template <> struct less : public binary_function { bool operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const { return std::less()(v, w); } }; template <> struct less : public binary_function { bool operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const { return std::less()(v, w); } }; } namespace swig { template <> struct traits { typedef value_category category; static const char* type_name() { return "PyObject *"; } }; template <> struct traits_asval { typedef PyObject * value_type; static int asval(PyObject *obj, value_type *val) { if (val) *val = obj; return SWIG_OK; } }; template <> struct traits_check { static bool check(PyObject *) { return true; } }; template <> struct traits_from { typedef PyObject * value_type; static PyObject *from(const value_type& val) { Py_XINCREF(val); return val; } }; } namespace swig { inline size_t check_index(ptrdiff_t i, size_t size, bool insert = false) { if ( i < 0 ) { if ((size_t) (-i) <= size) return (size_t) (i + size); } else if ( (size_t) i < size ) { return (size_t) i; } else if (insert && ((size_t) i == size)) { return size; } throw std::out_of_range("index out of range"); } inline size_t slice_index(ptrdiff_t i, size_t size) { if ( i < 0 ) { if ((size_t) (-i) <= size) { return (size_t) (i + size); } else { throw std::out_of_range("index out of range"); } } else { return ( (size_t) i < size ) ? ((size_t) i) : size; } } template inline typename Sequence::iterator getpos(Sequence* self, Difference i) { typename Sequence::iterator pos = self->begin(); std::advance(pos, check_index(i,self->size())); return pos; } template inline typename Sequence::const_iterator cgetpos(const Sequence* self, Difference i) { typename Sequence::const_iterator pos = self->begin(); std::advance(pos, check_index(i,self->size())); return pos; } template inline Sequence* getslice(const Sequence* self, Difference i, Difference j) { typename Sequence::size_type size = self->size(); typename Sequence::size_type ii = swig::check_index(i, size); typename Sequence::size_type jj = swig::slice_index(j, size); if (jj > ii) { typename Sequence::const_iterator vb = self->begin(); typename Sequence::const_iterator ve = self->begin(); std::advance(vb,ii); std::advance(ve,jj); return new Sequence(vb, ve); } else { return new Sequence(); } } template inline void setslice(Sequence* self, Difference i, Difference j, const InputSeq& v = InputSeq()) { typename Sequence::size_type size = self->size(); typename Sequence::size_type ii = swig::check_index(i, size, true); typename Sequence::size_type jj = swig::slice_index(j, size); if (jj < ii) jj = ii; size_t ssize = jj - ii; if (ssize <= v.size()) { typename Sequence::iterator sb = self->begin(); typename InputSeq::const_iterator vmid = v.begin(); std::advance(sb,ii); std::advance(vmid, jj - ii); self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end()); } else { typename Sequence::iterator sb = self->begin(); typename Sequence::iterator se = self->begin(); std::advance(sb,ii); std::advance(se,jj); self->erase(sb,se); self->insert(sb, v.begin(), v.end()); } } template inline void delslice(Sequence* self, Difference i, Difference j) { typename Sequence::size_type size = self->size(); typename Sequence::size_type ii = swig::check_index(i, size, true); typename Sequence::size_type jj = swig::slice_index(j, size); if (jj > ii) { typename Sequence::iterator sb = self->begin(); typename Sequence::iterator se = self->begin(); std::advance(sb,ii); std::advance(se,jj); self->erase(sb,se); } } } #if defined(__SUNPRO_CC) && defined(_RWSTD_VER) # if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) # define SWIG_STD_NOITERATOR_TRAITS_STL # endif #endif #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) #include #else namespace std { template struct iterator_traits { typedef ptrdiff_t difference_type; typedef typename Iterator::value_type value_type; }; template struct iterator_traits<__reverse_bi_iterator > { typedef Distance difference_type; typedef T value_type; }; template struct iterator_traits { typedef T value_type; typedef ptrdiff_t difference_type; }; template inline typename iterator_traits<_InputIterator>::difference_type distance(_InputIterator __first, _InputIterator __last) { typename iterator_traits<_InputIterator>::difference_type __n = 0; while (__first != __last) { ++__first; ++__n; } return __n; } } #endif namespace swig { template class SwigPyIterator_T : public SwigPyIterator { public: typedef OutIterator out_iterator; typedef typename std::iterator_traits::value_type value_type; typedef SwigPyIterator_T self_type; SwigPyIterator_T(out_iterator curr, PyObject *seq) : SwigPyIterator(seq), current(curr) { } const out_iterator& get_current() const { return current; } bool equal (const SwigPyIterator &iter) const { const self_type *iters = dynamic_cast(&iter); if (iters) { return (current == iters->get_current()); } else { throw std::invalid_argument("bad iterator type"); } } ptrdiff_t distance(const SwigPyIterator &iter) const { const self_type *iters = dynamic_cast(&iter); if (iters) { return std::distance(current, iters->get_current()); } else { throw std::invalid_argument("bad iterator type"); } } protected: out_iterator current; }; template struct from_oper { typedef const ValueType& argument_type; typedef PyObject *result_type; result_type operator()(argument_type v) const { return swig::from(v); } }; template::value_type, typename FromOper = from_oper > class SwigPyIteratorOpen_T : public SwigPyIterator_T { public: FromOper from; typedef OutIterator out_iterator; typedef ValueType value_type; typedef SwigPyIterator_T base; typedef SwigPyIteratorOpen_T self_type; SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq) : SwigPyIterator_T(curr, seq) { } PyObject *value() const { return from(static_cast(*(base::current))); } SwigPyIterator *copy() const { return new self_type(*this); } SwigPyIterator *incr(size_t n = 1) { while (n--) { ++base::current; } return this; } SwigPyIterator *decr(size_t n = 1) { while (n--) { --base::current; } return this; } }; template::value_type, typename FromOper = from_oper > class SwigPyIteratorClosed_T : public SwigPyIterator_T { public: FromOper from; typedef OutIterator out_iterator; typedef ValueType value_type; typedef SwigPyIterator_T base; typedef SwigPyIteratorClosed_T self_type; SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) : SwigPyIterator_T(curr, seq), begin(first), end(last) { } PyObject *value() const { if (base::current == end) { throw stop_iteration(); } else { return from(static_cast(*(base::current))); } } SwigPyIterator *copy() const { return new self_type(*this); } SwigPyIterator *incr(size_t n = 1) { while (n--) { if (base::current == end) { throw stop_iteration(); } else { ++base::current; } } return this; } SwigPyIterator *decr(size_t n = 1) { while (n--) { if (base::current == begin) { throw stop_iteration(); } else { --base::current; } } return this; } private: out_iterator begin; out_iterator end; }; template inline SwigPyIterator* make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) { return new SwigPyIteratorClosed_T(current, begin, end, seq); } template inline SwigPyIterator* make_output_iterator(const OutIter& current, PyObject *seq = 0) { return new SwigPyIteratorOpen_T(current, seq); } } namespace swig { template struct SwigPySequence_Ref { SwigPySequence_Ref(PyObject* seq, int index) : _seq(seq), _index(index) { } operator T () const { swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index); try { return swig::as(item, true); } catch (std::exception& e) { char msg[1024]; sprintf(msg, "in sequence element %d ", _index); if (!PyErr_Occurred()) { ::SWIG_Error(SWIG_TypeError, swig::type_name()); } SWIG_Python_AddErrorMsg(msg); SWIG_Python_AddErrorMsg(e.what()); throw; } } SwigPySequence_Ref& operator=(const T& v) { PySequence_SetItem(_seq, _index, swig::from(v)); return *this; } private: PyObject* _seq; int _index; }; template struct SwigPySequence_ArrowProxy { SwigPySequence_ArrowProxy(const T& x): m_value(x) {} const T* operator->() const { return &m_value; } operator const T*() const { return &m_value; } T m_value; }; template struct SwigPySequence_InputIterator { typedef SwigPySequence_InputIterator self; typedef std::random_access_iterator_tag iterator_category; typedef Reference reference; typedef T value_type; typedef T* pointer; typedef int difference_type; SwigPySequence_InputIterator() { } SwigPySequence_InputIterator(PyObject* seq, int index) : _seq(seq), _index(index) { } reference operator*() const { return reference(_seq, _index); } SwigPySequence_ArrowProxy operator->() const { return SwigPySequence_ArrowProxy(operator*()); } bool operator==(const self& ri) const { return (_index == ri._index) && (_seq == ri._seq); } bool operator!=(const self& ri) const { return !(operator==(ri)); } self& operator ++ () { ++_index; return *this; } self& operator -- () { --_index; return *this; } self& operator += (difference_type n) { _index += n; return *this; } self operator +(difference_type n) const { return self(_seq, _index + n); } self& operator -= (difference_type n) { _index -= n; return *this; } self operator -(difference_type n) const { return self(_seq, _index - n); } difference_type operator - (const self& ri) const { return _index - ri._index; } bool operator < (const self& ri) const { return _index < ri._index; } reference operator[](difference_type n) const { return reference(_seq, _index + n); } private: PyObject* _seq; difference_type _index; }; template struct SwigPySequence_Cont { typedef SwigPySequence_Ref reference; typedef const SwigPySequence_Ref const_reference; typedef T value_type; typedef T* pointer; typedef int difference_type; typedef int size_type; typedef const pointer const_pointer; typedef SwigPySequence_InputIterator iterator; typedef SwigPySequence_InputIterator const_iterator; SwigPySequence_Cont(PyObject* seq) : _seq(0) { if (!PySequence_Check(seq)) { throw std::invalid_argument("a sequence is expected"); } _seq = seq; Py_INCREF(_seq); } ~SwigPySequence_Cont() { Py_XDECREF(_seq); } size_type size() const { return static_cast(PySequence_Size(_seq)); } bool empty() const { return size() == 0; } iterator begin() { return iterator(_seq, 0); } const_iterator begin() const { return const_iterator(_seq, 0); } iterator end() { return iterator(_seq, size()); } const_iterator end() const { return const_iterator(_seq, size()); } reference operator[](difference_type n) { return reference(_seq, n); } const_reference operator[](difference_type n) const { return const_reference(_seq, n); } bool check(bool set_err = true) const { int s = size(); for (int i = 0; i < s; ++i) { swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i); if (!swig::check(item)) { if (set_err) { char msg[1024]; sprintf(msg, "in sequence element %d", i); SWIG_Error(SWIG_RuntimeError, msg); } return false; } } return true; } private: PyObject* _seq; }; } SWIGINTERN swig::SwigPyIterator *vector_Sl_long_Sg__iterator(vector< long > *self,PyObject **PYTHON_SELF){ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); } SWIGINTERN bool vector_Sl_long_Sg____nonzero__(vector< long > const *self){ return !(self->empty()); } SWIGINTERN bool vector_Sl_long_Sg____bool__(vector< long > const *self){ return !(self->empty()); } SWIGINTERN vector< long >::size_type vector_Sl_long_Sg____len__(vector< long > const *self){ return self->size(); } SWIGINTERNINLINE PyObject* SWIG_From_unsigned_SS_long (unsigned long value) { return (value > LONG_MAX) ? PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); } SWIGINTERNINLINE PyObject * SWIG_From_size_t (size_t value) { return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); } SWIGINTERN vector< long >::value_type vector_Sl_long_Sg__pop(vector< long > *self){ if (self->size() == 0) throw std::out_of_range("pop from empty container"); std::vector >::value_type x = self->back(); self->pop_back(); return x; } SWIGINTERN std::vector< long,std::allocator< long > > *vector_Sl_long_Sg____getslice__(vector< long > *self,vector< long >::difference_type i,vector< long >::difference_type j){ return swig::getslice(self, i, j); } namespace swig { template <> struct traits { typedef value_category category; static const char* type_name() { return"long"; } }; template <> struct traits_asval { typedef long value_type; static int asval(PyObject *obj, value_type *val) { return SWIG_AsVal_long (obj, val); } }; template <> struct traits_from { typedef long value_type; static PyObject *from(const value_type& val) { return SWIG_From_long (val); } }; } namespace swig { template inline void assign(const SwigPySeq& swigpyseq, Seq* seq) { // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented typedef typename SwigPySeq::value_type value_type; typename SwigPySeq::const_iterator it = swigpyseq.begin(); for (;it != swigpyseq.end(); ++it) { seq->insert(seq->end(),(value_type)(*it)); } } template struct traits_asptr_stdseq { typedef Seq sequence; typedef T value_type; static int asptr(PyObject *obj, sequence **seq) { if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { sequence *p; if (::SWIG_ConvertPtr(obj,(void**)&p, swig::type_info(),0) == SWIG_OK) { if (seq) *seq = p; return SWIG_OLDOBJ; } } else if (PySequence_Check(obj)) { try { SwigPySequence_Cont swigpyseq(obj); if (seq) { sequence *pseq = new sequence(); assign(swigpyseq, pseq); *seq = pseq; return SWIG_NEWOBJ; } else { return swigpyseq.check() ? SWIG_OK : SWIG_ERROR; } } catch (std::exception& e) { if (seq) { if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, e.what()); } } return SWIG_ERROR; } } return SWIG_ERROR; } }; template struct traits_from_stdseq { typedef Seq sequence; typedef T value_type; typedef typename Seq::size_type size_type; typedef typename sequence::const_iterator const_iterator; static PyObject *from(const sequence& seq) { #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS swig_type_info *desc = swig::type_info(); if (desc && desc->clientdata) { return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); } #endif size_type size = seq.size(); if (size <= (size_type)INT_MAX) { PyObject *obj = PyTuple_New((int)size); int i = 0; for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) { PyTuple_SetItem(obj,i,swig::from(*it)); } return obj; } else { PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python"); return NULL; } } }; } namespace swig { template struct traits_asptr > { static int asptr(PyObject *obj, std::vector **vec) { return traits_asptr_stdseq >::asptr(obj, vec); } }; template struct traits_from > { static PyObject *from(const std::vector& vec) { return traits_from_stdseq >::from(vec); } }; } namespace swig { template <> struct traits > > { typedef pointer_category category; static const char* type_name() { return "std::vector<" "long" "," "std::allocator< long >" " >"; } }; } SWIGINTERN void vector_Sl_long_Sg____setslice____SWIG_0(vector< long > *self,vector< long >::difference_type i,vector< long >::difference_type j,std::vector< long,std::allocator< long > > const &v=std::vector< long,std::allocator< long > >()){ swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_long_Sg____delslice__(vector< long > *self,vector< long >::difference_type i,vector< long >::difference_type j){ swig::delslice(self, i, j); } SWIGINTERN void vector_Sl_long_Sg____delitem____SWIG_0(vector< long > *self,vector< long >::difference_type i){ self->erase(swig::getpos(self,i)); } SWIGINTERN std::vector< long,std::allocator< long > > *vector_Sl_long_Sg____getitem____SWIG_0(vector< long > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return NULL; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); return swig::getslice(self, i, j); } SWIGINTERN void vector_Sl_long_Sg____setitem____SWIG_0(vector< long > *self,PySliceObject *slice,std::vector< long,std::allocator< long > > const &v){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_long_Sg____setitem____SWIG_1(vector< long > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN void vector_Sl_long_Sg____delitem____SWIG_1(vector< long > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN vector< long >::value_type const &vector_Sl_long_Sg____getitem____SWIG_1(vector< long > const *self,vector< long >::difference_type i){ return *(swig::cgetpos(self, i)); } SWIGINTERN void vector_Sl_long_Sg____setitem____SWIG_2(vector< long > *self,vector< long >::difference_type i,vector< long >::value_type const &x){ *(swig::getpos(self,i)) = x; } SWIGINTERN void vector_Sl_long_Sg__append(vector< long > *self,vector< long >::value_type const &x){ self->push_back(x); } SWIGINTERN swig::SwigPyIterator *vector_Sl_unsigned_SS_char_Sg__iterator(vector< unsigned char > *self,PyObject **PYTHON_SELF){ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); } SWIGINTERN bool vector_Sl_unsigned_SS_char_Sg____nonzero__(vector< unsigned char > const *self){ return !(self->empty()); } SWIGINTERN bool vector_Sl_unsigned_SS_char_Sg____bool__(vector< unsigned char > const *self){ return !(self->empty()); } SWIGINTERN vector< unsigned char >::size_type vector_Sl_unsigned_SS_char_Sg____len__(vector< unsigned char > const *self){ return self->size(); } SWIGINTERN vector< unsigned char >::value_type vector_Sl_unsigned_SS_char_Sg__pop(vector< unsigned char > *self){ if (self->size() == 0) throw std::out_of_range("pop from empty container"); std::vector >::value_type x = self->back(); self->pop_back(); return x; } SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_char (unsigned char value) { return SWIG_From_unsigned_SS_long (value); } SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *vector_Sl_unsigned_SS_char_Sg____getslice__(vector< unsigned char > *self,vector< unsigned char >::difference_type i,vector< unsigned char >::difference_type j){ return swig::getslice(self, i, j); } #include #if !defined(SWIG_NO_LLONG_MAX) # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) # define LLONG_MAX __LONG_LONG_MAX__ # define LLONG_MIN (-LLONG_MAX - 1LL) # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) # endif #endif SWIGINTERN int SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) { unsigned long v; int res = SWIG_AsVal_unsigned_SS_long (obj, &v); if (SWIG_IsOK(res)) { if ((v > UCHAR_MAX)) { return SWIG_OverflowError; } else { if (val) *val = static_cast< unsigned char >(v); } } return res; } namespace swig { template <> struct traits { typedef value_category category; static const char* type_name() { return"unsigned char"; } }; template <> struct traits_asval { typedef unsigned char value_type; static int asval(PyObject *obj, value_type *val) { return SWIG_AsVal_unsigned_SS_char (obj, val); } }; template <> struct traits_from { typedef unsigned char value_type; static PyObject *from(const value_type& val) { return SWIG_From_unsigned_SS_char (val); } }; } namespace swig { template <> struct traits > > { typedef pointer_category category; static const char* type_name() { return "std::vector<" "unsigned char" "," "std::allocator< unsigned char >" " >"; } }; } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____setslice____SWIG_0(vector< unsigned char > *self,vector< unsigned char >::difference_type i,vector< unsigned char >::difference_type j,std::vector< unsigned char,std::allocator< unsigned char > > const &v=std::vector< unsigned char,std::allocator< unsigned char > >()){ swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____delslice__(vector< unsigned char > *self,vector< unsigned char >::difference_type i,vector< unsigned char >::difference_type j){ swig::delslice(self, i, j); } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____delitem____SWIG_0(vector< unsigned char > *self,vector< unsigned char >::difference_type i){ self->erase(swig::getpos(self,i)); } SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *vector_Sl_unsigned_SS_char_Sg____getitem____SWIG_0(vector< unsigned char > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return NULL; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); return swig::getslice(self, i, j); } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_0(vector< unsigned char > *self,PySliceObject *slice,std::vector< unsigned char,std::allocator< unsigned char > > const &v){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_1(vector< unsigned char > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____delitem____SWIG_1(vector< unsigned char > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN vector< unsigned char >::value_type const &vector_Sl_unsigned_SS_char_Sg____getitem____SWIG_1(vector< unsigned char > const *self,vector< unsigned char >::difference_type i){ return *(swig::cgetpos(self, i)); } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_2(vector< unsigned char > *self,vector< unsigned char >::difference_type i,vector< unsigned char >::value_type const &x){ *(swig::getpos(self,i)) = x; } SWIGINTERN void vector_Sl_unsigned_SS_char_Sg__append(vector< unsigned char > *self,vector< unsigned char >::value_type const &x){ self->push_back(x); } SWIGINTERN swig::SwigPyIterator *vector_Sl_CK_ATTRIBUTE_SMART_Sg__iterator(vector< CK_ATTRIBUTE_SMART > *self,PyObject **PYTHON_SELF){ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); } SWIGINTERN bool vector_Sl_CK_ATTRIBUTE_SMART_Sg____nonzero__(vector< CK_ATTRIBUTE_SMART > const *self){ return !(self->empty()); } SWIGINTERN bool vector_Sl_CK_ATTRIBUTE_SMART_Sg____bool__(vector< CK_ATTRIBUTE_SMART > const *self){ return !(self->empty()); } SWIGINTERN vector< CK_ATTRIBUTE_SMART >::size_type vector_Sl_CK_ATTRIBUTE_SMART_Sg____len__(vector< CK_ATTRIBUTE_SMART > const *self){ return self->size(); } SWIGINTERN vector< CK_ATTRIBUTE_SMART >::value_type vector_Sl_CK_ATTRIBUTE_SMART_Sg__pop(vector< CK_ATTRIBUTE_SMART > *self){ if (self->size() == 0) throw std::out_of_range("pop from empty container"); std::vector >::value_type x = self->back(); self->pop_back(); return x; } SWIGINTERN std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *vector_Sl_CK_ATTRIBUTE_SMART_Sg____getslice__(vector< CK_ATTRIBUTE_SMART > *self,vector< CK_ATTRIBUTE_SMART >::difference_type i,vector< CK_ATTRIBUTE_SMART >::difference_type j){ return swig::getslice(self, i, j); } namespace swig { template <> struct traits { typedef pointer_category category; static const char* type_name() { return"CK_ATTRIBUTE_SMART"; } }; } namespace swig { template <> struct traits > > { typedef pointer_category category; static const char* type_name() { return "std::vector<" "CK_ATTRIBUTE_SMART" "," "std::allocator< CK_ATTRIBUTE_SMART >" " >"; } }; } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____setslice____SWIG_0(vector< CK_ATTRIBUTE_SMART > *self,vector< CK_ATTRIBUTE_SMART >::difference_type i,vector< CK_ATTRIBUTE_SMART >::difference_type j,std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &v=std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > >()){ swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____delslice__(vector< CK_ATTRIBUTE_SMART > *self,vector< CK_ATTRIBUTE_SMART >::difference_type i,vector< CK_ATTRIBUTE_SMART >::difference_type j){ swig::delslice(self, i, j); } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____delitem____SWIG_0(vector< CK_ATTRIBUTE_SMART > *self,vector< CK_ATTRIBUTE_SMART >::difference_type i){ self->erase(swig::getpos(self,i)); } SWIGINTERN std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *vector_Sl_CK_ATTRIBUTE_SMART_Sg____getitem____SWIG_0(vector< CK_ATTRIBUTE_SMART > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return NULL; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); return swig::getslice(self, i, j); } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____setitem____SWIG_0(vector< CK_ATTRIBUTE_SMART > *self,PySliceObject *slice,std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &v){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____setitem____SWIG_1(vector< CK_ATTRIBUTE_SMART > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____delitem____SWIG_1(vector< CK_ATTRIBUTE_SMART > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN vector< CK_ATTRIBUTE_SMART >::value_type const &vector_Sl_CK_ATTRIBUTE_SMART_Sg____getitem____SWIG_1(vector< CK_ATTRIBUTE_SMART > const *self,vector< CK_ATTRIBUTE_SMART >::difference_type i){ return *(swig::cgetpos(self, i)); } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg____setitem____SWIG_2(vector< CK_ATTRIBUTE_SMART > *self,vector< CK_ATTRIBUTE_SMART >::difference_type i,vector< CK_ATTRIBUTE_SMART >::value_type const &x){ *(swig::getpos(self,i)) = x; } SWIGINTERN void vector_Sl_CK_ATTRIBUTE_SMART_Sg__append(vector< CK_ATTRIBUTE_SMART > *self,vector< CK_ATTRIBUTE_SMART >::value_type const &x){ self->push_back(x); } SWIGINTERN swig::SwigPyIterator *vector_Sl_CK_OBJECT_HANDLE_Sg__iterator(vector< CK_OBJECT_HANDLE > *self,PyObject **PYTHON_SELF){ return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); } SWIGINTERN bool vector_Sl_CK_OBJECT_HANDLE_Sg____nonzero__(vector< CK_OBJECT_HANDLE > const *self){ return !(self->empty()); } SWIGINTERN bool vector_Sl_CK_OBJECT_HANDLE_Sg____bool__(vector< CK_OBJECT_HANDLE > const *self){ return !(self->empty()); } SWIGINTERN vector< CK_OBJECT_HANDLE >::size_type vector_Sl_CK_OBJECT_HANDLE_Sg____len__(vector< CK_OBJECT_HANDLE > const *self){ return self->size(); } SWIGINTERN vector< CK_OBJECT_HANDLE >::value_type vector_Sl_CK_OBJECT_HANDLE_Sg__pop(vector< CK_OBJECT_HANDLE > *self){ if (self->size() == 0) throw std::out_of_range("pop from empty container"); std::vector >::value_type x = self->back(); self->pop_back(); return x; } SWIGINTERN std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *vector_Sl_CK_OBJECT_HANDLE_Sg____getslice__(vector< CK_OBJECT_HANDLE > *self,vector< CK_OBJECT_HANDLE >::difference_type i,vector< CK_OBJECT_HANDLE >::difference_type j){ return swig::getslice(self, i, j); } namespace swig { template <> struct traits { typedef pointer_category category; static const char* type_name() { return"CK_OBJECT_HANDLE"; } }; } namespace swig { template <> struct traits > > { typedef pointer_category category; static const char* type_name() { return "std::vector<" "CK_OBJECT_HANDLE" "," "std::allocator< CK_OBJECT_HANDLE >" " >"; } }; } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____setslice____SWIG_0(vector< CK_OBJECT_HANDLE > *self,vector< CK_OBJECT_HANDLE >::difference_type i,vector< CK_OBJECT_HANDLE >::difference_type j,std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &v=std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > >()){ swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____delslice__(vector< CK_OBJECT_HANDLE > *self,vector< CK_OBJECT_HANDLE >::difference_type i,vector< CK_OBJECT_HANDLE >::difference_type j){ swig::delslice(self, i, j); } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____delitem____SWIG_0(vector< CK_OBJECT_HANDLE > *self,vector< CK_OBJECT_HANDLE >::difference_type i){ self->erase(swig::getpos(self,i)); } SWIGINTERN std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *vector_Sl_CK_OBJECT_HANDLE_Sg____getitem____SWIG_0(vector< CK_OBJECT_HANDLE > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return NULL; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); return swig::getslice(self, i, j); } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____setitem____SWIG_0(vector< CK_OBJECT_HANDLE > *self,PySliceObject *slice,std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &v){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::setslice(self, i, j, v); } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____setitem____SWIG_1(vector< CK_OBJECT_HANDLE > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____delitem____SWIG_1(vector< CK_OBJECT_HANDLE > *self,PySliceObject *slice){ Py_ssize_t i, j, step; if( !PySlice_Check(slice) ) { SWIG_Error(SWIG_TypeError, "Slice object expected."); return; } PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), self->size(), &i, &j, &step); swig::delslice(self, i,j); } SWIGINTERN vector< CK_OBJECT_HANDLE >::value_type const &vector_Sl_CK_OBJECT_HANDLE_Sg____getitem____SWIG_1(vector< CK_OBJECT_HANDLE > const *self,vector< CK_OBJECT_HANDLE >::difference_type i){ return *(swig::cgetpos(self, i)); } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg____setitem____SWIG_2(vector< CK_OBJECT_HANDLE > *self,vector< CK_OBJECT_HANDLE >::difference_type i,vector< CK_OBJECT_HANDLE >::value_type const &x){ *(swig::getpos(self,i)) = x; } SWIGINTERN void vector_Sl_CK_OBJECT_HANDLE_Sg__append(vector< CK_OBJECT_HANDLE > *self,vector< CK_OBJECT_HANDLE >::value_type const &x){ self->push_back(x); } typedef unsigned long CK_SESSION_HANDLE; SWIGINTERN CK_SESSION_HANDLE *new_CK_SESSION_HANDLE(){ return (new unsigned long); } SWIGINTERN void delete_CK_SESSION_HANDLE(CK_SESSION_HANDLE *self){ if (self) delete self; } SWIGINTERN void CK_SESSION_HANDLE_assign(CK_SESSION_HANDLE *self,unsigned long value){ *self = value; } SWIGINTERN unsigned long CK_SESSION_HANDLE_value(CK_SESSION_HANDLE *self){ return *self; } SWIGINTERN unsigned long *CK_SESSION_HANDLE_cast(CK_SESSION_HANDLE *self){ return self; } SWIGINTERN CK_SESSION_HANDLE *CK_SESSION_HANDLE_frompointer(unsigned long *t){ return (CK_SESSION_HANDLE *) t; } typedef unsigned long CK_OBJECT_HANDLE; SWIGINTERN CK_OBJECT_HANDLE *new_CK_OBJECT_HANDLE(){ return (new unsigned long); } SWIGINTERN void delete_CK_OBJECT_HANDLE(CK_OBJECT_HANDLE *self){ if (self) delete self; } SWIGINTERN void CK_OBJECT_HANDLE_assign(CK_OBJECT_HANDLE *self,unsigned long value){ *self = value; } SWIGINTERN unsigned long CK_OBJECT_HANDLE_value(CK_OBJECT_HANDLE *self){ return *self; } SWIGINTERN unsigned long *CK_OBJECT_HANDLE_cast(CK_OBJECT_HANDLE *self){ return self; } SWIGINTERN CK_OBJECT_HANDLE *CK_OBJECT_HANDLE_frompointer(unsigned long *t){ return (CK_OBJECT_HANDLE *) t; } typedef char byteArray; SWIGINTERN byteArray *new_byteArray(size_t nelements){ return (new char[nelements]); } SWIGINTERN void delete_byteArray(byteArray *self){ delete[] self; } SWIGINTERN char byteArray___getitem__(byteArray *self,size_t index){ return self[index]; } SWIGINTERNINLINE PyObject * SWIG_From_char (char c) { return SWIG_FromCharPtrAndSize(&c,1); } SWIGINTERN int SWIG_AsCharArray(PyObject * obj, char *val, size_t size) { char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ; int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc); if (SWIG_IsOK(res)) { if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize; if (csize <= size) { if (val) { if (csize) memcpy(val, cptr, csize*sizeof(char)); if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char)); } if (alloc == SWIG_NEWOBJ) { delete[] cptr; res = SWIG_DelNewMask(res); } return res; } if (alloc == SWIG_NEWOBJ) delete[] cptr; } return SWIG_TypeError; } SWIGINTERN int SWIG_AsVal_char (PyObject * obj, char *val) { int res = SWIG_AsCharArray(obj, val, 1); if (!SWIG_IsOK(res)) { long v; res = SWIG_AddCast(SWIG_AsVal_long (obj, &v)); if (SWIG_IsOK(res)) { if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) { if (val) *val = static_cast< char >(v); } else { res = SWIG_OverflowError; } } } return res; } SWIGINTERN void byteArray___setitem__(byteArray *self,size_t index,char value){ self[index] = value; } SWIGINTERN char *byteArray_cast(byteArray *self){ return self; } SWIGINTERNINLINE PyObject * SWIG_FromCharPtr(const char *cptr) { return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); } SWIGINTERN byteArray *byteArray_frompointer(char *t){ return static_cast< byteArray * >(t); } SWIGINTERN PyKCS11String CK_INFO_GetManufacturerID(CK_INFO *self){ return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } SWIGINTERN PyKCS11String CK_INFO_GetLibraryDescription(CK_INFO *self){ return PyKCS11String(self->libraryDescription, sizeof(self->libraryDescription)); } SWIGINTERN PyKCS11String CK_INFO_GetLibraryVersion(CK_INFO *self){ char szVal[10]; sprintf(szVal, "%d.%d", self->libraryVersion.major, self->libraryVersion.minor); return PyKCS11String(szVal); } SWIGINTERN PyKCS11String CK_SLOT_INFO_GetManufacturerID(CK_SLOT_INFO *self){ return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } SWIGINTERN PyKCS11String CK_SLOT_INFO_GetSlotDescription(CK_SLOT_INFO *self){ return PyKCS11String(self->slotDescription, sizeof(self->slotDescription)); } SWIGINTERN PyKCS11String CK_SLOT_INFO_GetHardwareVersion(CK_SLOT_INFO *self){ char szVal[10]; sprintf(szVal, "%d.%02d", self->hardwareVersion.major, self->hardwareVersion.minor); return PyKCS11String(szVal); } SWIGINTERN PyKCS11String CK_SLOT_INFO_GetFirmwareVersion(CK_SLOT_INFO *self){ char szVal[10]; sprintf(szVal, "%d.%02d", self->firmwareVersion.major, self->firmwareVersion.minor); return PyKCS11String(szVal); } SWIGINTERN PyKCS11String CK_TOKEN_INFO_GetLabel(CK_TOKEN_INFO *self){ return PyKCS11String(self->label, sizeof(self->label)); } SWIGINTERN PyKCS11String CK_TOKEN_INFO_GetManufacturerID(CK_TOKEN_INFO *self){ return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } SWIGINTERN PyKCS11String CK_TOKEN_INFO_GetModel(CK_TOKEN_INFO *self){ return PyKCS11String(self->model, sizeof(self->model)); } SWIGINTERN PyKCS11String CK_TOKEN_INFO_GetSerialNumber(CK_TOKEN_INFO *self){ return PyKCS11String(self->serialNumber, sizeof(self->serialNumber)); } SWIGINTERN PyKCS11String CK_TOKEN_INFO_GetFirmwareVersion(CK_TOKEN_INFO *self){ char szVal[10]; sprintf(szVal, "%d.%02d", self->firmwareVersion.major, self->firmwareVersion.minor); return PyKCS11String(szVal); } SWIGINTERN PyKCS11String CK_TOKEN_INFO_GetUtcTime(CK_TOKEN_INFO *self){ return PyKCS11String(self->utcTime, sizeof(self->utcTime)); } SWIGINTERN PyKCS11String CK_DATE_GetYear(CK_DATE *self){ char szVal[10]; memcpy(szVal, self->year, sizeof(self->year) ); return PyKCS11String(szVal); } SWIGINTERN PyKCS11String CK_DATE_GetMonth(CK_DATE *self){ char szVal[10]; memcpy(szVal, self->month, sizeof(self->month) ); return PyKCS11String(szVal); } SWIGINTERN PyKCS11String CK_DATE_GetDay(CK_DATE *self){ char szVal[10]; memcpy(szVal, self->day, sizeof(self->day) ); return PyKCS11String(szVal); } SWIGINTERN CK_MECHANISM *new_CK_MECHANISM(){ CK_MECHANISM* m = new CK_MECHANISM(); m->ulParameterLen = m->mechanism = 0; m->pParameter = NULL; return m; } SWIGINTERNINLINE PyObject * SWIG_From_int (int value) { return SWIG_From_long (value); } SWIGINTERN int SWIG_AsVal_bool (PyObject *obj, bool *val) { int r = PyObject_IsTrue(obj); if (r == -1) return SWIG_ERROR; if (val) *val = r ? true : false; return SWIG_OK; } #ifdef __cplusplus extern "C" { #endif SWIGINTERN PyObject *_wrap_cdata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; void *arg1 = (void *) 0 ; size_t arg2 = (size_t) 1 ; int res1 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; SWIGCDATA result; if (!PyArg_ParseTuple(args,(char *)"O|O:cdata",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdata" "', argument " "1"" of type '" "void *""'"); } if (obj1) { ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdata" "', argument " "2"" of type '" "size_t""'"); } arg2 = static_cast< size_t >(val2); } result = cdata_void(arg1,arg2); resultobj = SWIG_FromCharPtrAndSize((&result)->data,(&result)->len); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_memmove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; void *arg1 = (void *) 0 ; void *arg2 = (void *) 0 ; size_t arg3 ; int res1 ; int res2 ; char *buf2 = 0 ; size_t size2 = 0 ; int alloc2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:memmove",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memmove" "', argument " "1"" of type '" "void *""'"); } res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, &size2, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memmove" "', argument " "2"" of type '" "void const *""'"); } arg2 = reinterpret_cast< void * >(buf2); arg3 = static_cast< size_t >(size2); memmove(arg1,(void const *)arg2,arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = result; return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); } arg2 = static_cast< size_t >(val2); try { result = (swig::SwigPyIterator *)(arg1)->incr(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { result = (swig::SwigPyIterator *)(arg1)->incr(); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_SwigPyIterator_incr__SWIG_1(self, args); } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_SwigPyIterator_incr__SWIG_0(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n" " Possible C/C++ prototypes are:\n" " swig::SwigPyIterator::incr(size_t)\n" " swig::SwigPyIterator::incr()\n"); return 0; } SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); } arg2 = static_cast< size_t >(val2); try { result = (swig::SwigPyIterator *)(arg1)->decr(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { result = (swig::SwigPyIterator *)(arg1)->decr(); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_SwigPyIterator_decr__SWIG_1(self, args); } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_SwigPyIterator_decr__SWIG_0(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n" " Possible C/C++ prototypes are:\n" " swig::SwigPyIterator::decr(size_t)\n" " swig::SwigPyIterator::decr()\n"); return 0; } SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; ptrdiff_t result; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); try { result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); } catch(std::invalid_argument &_e) { SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; } resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); try { result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); } catch(std::invalid_argument &_e) { SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; } resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { result = (PyObject *)(arg1)->next(); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = result; return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { result = (PyObject *)(arg1)->__next__(); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = result; return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); try { result = (PyObject *)(arg1)->previous(); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = result; return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); } arg2 = static_cast< ptrdiff_t >(val2); try { result = (swig::SwigPyIterator *)(arg1)->advance(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); } arg2 = static_cast< ptrdiff_t >(val2); try { result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); } arg2 = static_cast< ptrdiff_t >(val2); try { result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); } arg2 = static_cast< ptrdiff_t >(val2); try { result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; ptrdiff_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; swig::SwigPyIterator *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); } arg2 = static_cast< ptrdiff_t >(val2); try { result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); } catch(swig::stop_iteration &_e) { { (void)_e; SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); SWIG_fail; } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; swig::SwigPyIterator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; ptrdiff_t result; if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); } arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); } arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_SwigPyIterator___sub____SWIG_1(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_SwigPyIterator___sub____SWIG_0(self, args); } } } fail: Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_ckintlist_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; PyObject **arg2 = (PyObject **) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; arg2 = &obj0; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_iterator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_iterator" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (swig::SwigPyIterator *)vector_Sl_long_Sg__iterator(arg1,arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist___nonzero__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___nonzero__" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (bool)vector_Sl_long_Sg____nonzero__((vector< long > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist___bool__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___bool__" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (bool)vector_Sl_long_Sg____bool__((vector< long > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist___len__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___len__" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = vector_Sl_long_Sg____len__((vector< long > const *)arg1); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::value_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_pop",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_pop" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); try { result = (vector< long >::value_type)vector_Sl_long_Sg__pop(arg1); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; vector< long >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; std::vector< long,std::allocator< long > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___getslice__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___getslice__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist___getslice__" "', argument " "3"" of type '" "vector< long >::difference_type""'"); } arg3 = static_cast< vector< long >::difference_type >(val3); try { result = (std::vector< long,std::allocator< long > > *)vector_Sl_long_Sg____getslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; vector< long >::difference_type arg3 ; std::vector< long,std::allocator< long > > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; int res4 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckintlist___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___setslice__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___setslice__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist___setslice__" "', argument " "3"" of type '" "vector< long >::difference_type""'"); } arg3 = static_cast< vector< long >::difference_type >(val3); { std::vector > *ptr = (std::vector > *)0; res4 = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ckintlist___setslice__" "', argument " "4"" of type '" "std::vector< long,std::allocator< long > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckintlist___setslice__" "', argument " "4"" of type '" "std::vector< long,std::allocator< long > > const &""'"); } arg4 = ptr; } try { vector_Sl_long_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< long,std::allocator< long > > const &)*arg4); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: if (SWIG_IsNewObj(res4)) delete arg4; return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; vector< long >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___setslice__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___setslice__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist___setslice__" "', argument " "3"" of type '" "vector< long >::difference_type""'"); } arg3 = static_cast< vector< long >::difference_type >(val3); try { vector_Sl_long_Sg____setslice____SWIG_0(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___setslice__(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist___setslice____SWIG_1(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = swig::asptr(argv[3], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckintlist___setslice____SWIG_0(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist___setslice__'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::__setslice__(vector< long >::difference_type,vector< long >::difference_type,std::vector< long,std::allocator< long > > const &)\n" " vector< long >::__setslice__(vector< long >::difference_type,vector< long >::difference_type)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; vector< long >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___delslice__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___delslice__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist___delslice__" "', argument " "3"" of type '" "vector< long >::difference_type""'"); } arg3 = static_cast< vector< long >::difference_type >(val3); try { vector_Sl_long_Sg____delslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___delitem__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___delitem__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); try { vector_Sl_long_Sg____delitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; std::vector< long,std::allocator< long > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___getitem__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { result = (std::vector< long,std::allocator< long > > *)vector_Sl_long_Sg____getitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; std::vector< long,std::allocator< long > > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___setitem__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } { std::vector > *ptr = (std::vector > *)0; res3 = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckintlist___setitem__" "', argument " "3"" of type '" "std::vector< long,std::allocator< long > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckintlist___setitem__" "', argument " "3"" of type '" "std::vector< long,std::allocator< long > > const &""'"); } arg3 = ptr; } try { vector_Sl_long_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< long,std::allocator< long > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist___setitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___setitem__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_long_Sg____setitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___delitem__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_long_Sg____delitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___delitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckintlist___delitem____SWIG_1(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist___delitem____SWIG_0(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist___delitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::__delitem__(vector< long >::difference_type)\n" " vector< long >::__delitem__(PySliceObject *)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< long >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___getitem__" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___getitem__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); try { result = (vector< long >::value_type *) &vector_Sl_long_Sg____getitem____SWIG_1((vector< long > const *)arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_From_long(static_cast< long >(*result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___getitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckintlist___getitem____SWIG_0(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist___getitem____SWIG_1(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist___getitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::__getitem__(PySliceObject *)\n" " vector< long >::__getitem__(vector< long >::difference_type) const\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::difference_type arg2 ; vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; vector< long >::value_type temp3 ; long val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist___setitem__" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist___setitem__" "', argument " "2"" of type '" "vector< long >::difference_type""'"); } arg2 = static_cast< vector< long >::difference_type >(val2); ecode3 = SWIG_AsVal_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist___setitem__" "', argument " "3"" of type '" "vector< long >::value_type""'"); } temp3 = static_cast< vector< long >::value_type >(val3); arg3 = &temp3; try { vector_Sl_long_Sg____setitem____SWIG_2(arg1,arg2,(long const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist___setitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckintlist___setitem____SWIG_1(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { int res = swig::asptr(argv[2], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckintlist___setitem____SWIG_0(self, args); } } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_long(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist___setitem____SWIG_2(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist___setitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::__setitem__(PySliceObject *,std::vector< long,std::allocator< long > > const &)\n" " vector< long >::__setitem__(PySliceObject *)\n" " vector< long >::__setitem__(vector< long >::difference_type,vector< long >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; vector< long >::value_type temp2 ; long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist_append",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_append" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist_append" "', argument " "2"" of type '" "vector< long >::value_type""'"); } temp2 = static_cast< vector< long >::value_type >(val2); arg2 = &temp2; vector_Sl_long_Sg__append(arg1,(long const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckintlist__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_ckintlist")) SWIG_fail; result = (vector< long > *)new vector< long >(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckintlist__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; std::vector< long > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; vector< long > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckintlist",&obj0)) SWIG_fail; { std::vector > *ptr = (std::vector > *)0; res1 = swig::asptr(obj0, &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ckintlist" "', argument " "1"" of type '" "std::vector< long > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ckintlist" "', argument " "1"" of type '" "std::vector< long > const &""'"); } arg1 = ptr; } result = (vector< long > *)new vector< long >((std::vector< long > const &)*arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_empty",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_empty" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (bool)((vector< long > const *)arg1)->empty(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_size",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_size" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = ((vector< long > const *)arg1)->size(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_clear",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_clear" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); (arg1)->clear(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; std::vector< long > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist_swap",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_swap" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckintlist_swap" "', argument " "2"" of type '" "std::vector< long > &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckintlist_swap" "', argument " "2"" of type '" "std::vector< long > &""'"); } arg2 = reinterpret_cast< std::vector< long > * >(argp2); (arg1)->swap(*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; SwigValueWrapper< std::allocator< long > > result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_get_allocator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_get_allocator" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = ((vector< long > const *)arg1)->get_allocator(); resultobj = SWIG_NewPointerObj((new vector< long >::allocator_type(static_cast< const vector< long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_long_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_begin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_begin" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (arg1)->begin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_end",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_end" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (arg1)->end(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_rbegin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_rbegin" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (arg1)->rbegin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_rend",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_rend" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (arg1)->rend(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckintlist__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long >::size_type arg1 ; size_t val1 ; int ecode1 = 0 ; PyObject * obj0 = 0 ; vector< long > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckintlist",&obj0)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckintlist" "', argument " "1"" of type '" "vector< long >::size_type""'"); } arg1 = static_cast< vector< long >::size_type >(val1); result = (vector< long > *)new vector< long >(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_pop_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_pop_back" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); (arg1)->pop_back(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist_resize",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_resize" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist_resize" "', argument " "2"" of type '" "vector< long >::size_type""'"); } arg2 = static_cast< vector< long >::size_type >(val2); (arg1)->resize(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::iterator arg2 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< long >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist_erase",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_erase" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_erase" "', argument " "2"" of type '" "vector< long >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_erase" "', argument " "2"" of type '" "vector< long >::iterator""'"); } } result = (arg1)->erase(arg2); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::iterator arg2 ; vector< long >::iterator arg3 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; swig::SwigPyIterator *iter3 = 0 ; int res3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< long >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist_erase",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_erase" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_erase" "', argument " "2"" of type '" "vector< long >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_erase" "', argument " "2"" of type '" "vector< long >::iterator""'"); } } res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res3) || !iter3) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_erase" "', argument " "3"" of type '" "vector< long >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); if (iter_t) { arg3 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_erase" "', argument " "3"" of type '" "vector< long >::iterator""'"); } } result = (arg1)->erase(arg2,arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_erase(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckintlist_erase__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckintlist_erase__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist_erase'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::erase(vector< long >::iterator)\n" " vector< long >::erase(vector< long >::iterator,vector< long >::iterator)\n"); return 0; } SWIGINTERN PyObject *_wrap_new_ckintlist__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long >::size_type arg1 ; vector< long >::value_type *arg2 = 0 ; size_t val1 ; int ecode1 = 0 ; vector< long >::value_type temp2 ; long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< long > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:new_ckintlist",&obj0,&obj1)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckintlist" "', argument " "1"" of type '" "vector< long >::size_type""'"); } arg1 = static_cast< vector< long >::size_type >(val1); ecode2 = SWIG_AsVal_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ckintlist" "', argument " "2"" of type '" "vector< long >::value_type""'"); } temp2 = static_cast< vector< long >::value_type >(val2); arg2 = &temp2; result = (vector< long > *)new vector< long >(arg1,(vector< long >::value_type const &)*arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckintlist(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 0) { return _wrap_new_ckintlist__SWIG_0(self, args); } if (argc == 1) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_new_ckintlist__SWIG_2(self, args); } } if (argc == 1) { int _v; int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ckintlist__SWIG_1(self, args); } } if (argc == 2) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_long(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_new_ckintlist__SWIG_3(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ckintlist'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::vector()\n" " vector< long >::vector(std::vector< long > const &)\n" " vector< long >::vector(vector< long >::size_type)\n" " vector< long >::vector(vector< long >::size_type,vector< long >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; vector< long >::value_type temp2 ; long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist_push_back",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_push_back" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist_push_back" "', argument " "2"" of type '" "vector< long >::value_type""'"); } temp2 = static_cast< vector< long >::value_type >(val2); arg2 = &temp2; (arg1)->push_back((vector< long >::value_type const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_front",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_front" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (vector< long >::value_type *) &((vector< long > const *)arg1)->front(); resultobj = SWIG_From_long(static_cast< long >(*result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_back" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = (vector< long >::value_type *) &((vector< long > const *)arg1)->back(); resultobj = SWIG_From_long(static_cast< long >(*result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::size_type arg2 ; vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; vector< long >::value_type temp3 ; long val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist_assign",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_assign" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist_assign" "', argument " "2"" of type '" "vector< long >::size_type""'"); } arg2 = static_cast< vector< long >::size_type >(val2); ecode3 = SWIG_AsVal_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist_assign" "', argument " "3"" of type '" "vector< long >::value_type""'"); } temp3 = static_cast< vector< long >::value_type >(val3); arg3 = &temp3; (arg1)->assign(arg2,(vector< long >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::size_type arg2 ; vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; vector< long >::value_type temp3 ; long val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist_resize",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_resize" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist_resize" "', argument " "2"" of type '" "vector< long >::size_type""'"); } arg2 = static_cast< vector< long >::size_type >(val2); ecode3 = SWIG_AsVal_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist_resize" "', argument " "3"" of type '" "vector< long >::value_type""'"); } temp3 = static_cast< vector< long >::value_type >(val3); arg3 = &temp3; (arg1)->resize(arg2,(vector< long >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_resize(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist_resize__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_long(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist_resize__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist_resize'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::resize(vector< long >::size_type)\n" " vector< long >::resize(vector< long >::size_type,vector< long >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::iterator arg2 ; vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; vector< long >::value_type temp3 ; long val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< long >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckintlist_insert",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_insert" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_insert" "', argument " "2"" of type '" "vector< long >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_insert" "', argument " "2"" of type '" "vector< long >::iterator""'"); } } ecode3 = SWIG_AsVal_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist_insert" "', argument " "3"" of type '" "vector< long >::value_type""'"); } temp3 = static_cast< vector< long >::value_type >(val3); arg3 = &temp3; result = (arg1)->insert(arg2,(vector< long >::value_type const &)*arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< long >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::iterator arg2 ; vector< long >::size_type arg3 ; vector< long >::value_type *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; size_t val3 ; int ecode3 = 0 ; vector< long >::value_type temp4 ; long val4 ; int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckintlist_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_insert" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_insert" "', argument " "2"" of type '" "vector< long >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckintlist_insert" "', argument " "2"" of type '" "vector< long >::iterator""'"); } } ecode3 = SWIG_AsVal_size_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckintlist_insert" "', argument " "3"" of type '" "vector< long >::size_type""'"); } arg3 = static_cast< vector< long >::size_type >(val3); ecode4 = SWIG_AsVal_long(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ckintlist_insert" "', argument " "4"" of type '" "vector< long >::value_type""'"); } temp4 = static_cast< vector< long >::value_type >(val4); arg4 = &temp4; (arg1)->insert(arg2,arg3,(vector< long >::value_type const &)*arg4); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_insert(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { { int res = SWIG_AsVal_long(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist_insert__SWIG_0(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { { int res = SWIG_AsVal_size_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_long(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckintlist_insert__SWIG_1(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckintlist_insert'.\n" " Possible C/C++ prototypes are:\n" " vector< long >::insert(vector< long >::iterator,vector< long >::value_type const &)\n" " vector< long >::insert(vector< long >::iterator,vector< long >::size_type,vector< long >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckintlist_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; vector< long >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckintlist_reserve",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_reserve" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckintlist_reserve" "', argument " "2"" of type '" "vector< long >::size_type""'"); } arg2 = static_cast< vector< long >::size_type >(val2); (arg1)->reserve(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckintlist_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< long >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckintlist_capacity",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckintlist_capacity" "', argument " "1"" of type '" "vector< long > const *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); result = ((vector< long > const *)arg1)->capacity(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_ckintlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< long > *arg1 = (vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_ckintlist",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ckintlist" "', argument " "1"" of type '" "vector< long > *""'"); } arg1 = reinterpret_cast< vector< long > * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *ckintlist_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_ckbytelist_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; PyObject **arg2 = (PyObject **) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; arg2 = &obj0; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_iterator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_iterator" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (swig::SwigPyIterator *)vector_Sl_unsigned_SS_char_Sg__iterator(arg1,arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist___nonzero__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___nonzero__" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (bool)vector_Sl_unsigned_SS_char_Sg____nonzero__((vector< unsigned char > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist___bool__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___bool__" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (bool)vector_Sl_unsigned_SS_char_Sg____bool__((vector< unsigned char > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist___len__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___len__" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = vector_Sl_unsigned_SS_char_Sg____len__((vector< unsigned char > const *)arg1); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::value_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_pop",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_pop" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); try { result = (vector< unsigned char >::value_type)vector_Sl_unsigned_SS_char_Sg__pop(arg1); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; vector< unsigned char >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; std::vector< unsigned char,std::allocator< unsigned char > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___getslice__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___getslice__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist___getslice__" "', argument " "3"" of type '" "vector< unsigned char >::difference_type""'"); } arg3 = static_cast< vector< unsigned char >::difference_type >(val3); try { result = (std::vector< unsigned char,std::allocator< unsigned char > > *)vector_Sl_unsigned_SS_char_Sg____getslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; vector< unsigned char >::difference_type arg3 ; std::vector< unsigned char,std::allocator< unsigned char > > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; int res4 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckbytelist___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___setslice__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___setslice__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist___setslice__" "', argument " "3"" of type '" "vector< unsigned char >::difference_type""'"); } arg3 = static_cast< vector< unsigned char >::difference_type >(val3); { std::vector > *ptr = (std::vector > *)0; res4 = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ckbytelist___setslice__" "', argument " "4"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckbytelist___setslice__" "', argument " "4"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); } arg4 = ptr; } try { vector_Sl_unsigned_SS_char_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< unsigned char,std::allocator< unsigned char > > const &)*arg4); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: if (SWIG_IsNewObj(res4)) delete arg4; return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; vector< unsigned char >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___setslice__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___setslice__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist___setslice__" "', argument " "3"" of type '" "vector< unsigned char >::difference_type""'"); } arg3 = static_cast< vector< unsigned char >::difference_type >(val3); try { vector_Sl_unsigned_SS_char_Sg____setslice____SWIG_0(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___setslice__(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist___setslice____SWIG_1(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = swig::asptr(argv[3], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckbytelist___setslice____SWIG_0(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist___setslice__'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::__setslice__(vector< unsigned char >::difference_type,vector< unsigned char >::difference_type,std::vector< unsigned char,std::allocator< unsigned char > > const &)\n" " vector< unsigned char >::__setslice__(vector< unsigned char >::difference_type,vector< unsigned char >::difference_type)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; vector< unsigned char >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___delslice__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___delslice__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist___delslice__" "', argument " "3"" of type '" "vector< unsigned char >::difference_type""'"); } arg3 = static_cast< vector< unsigned char >::difference_type >(val3); try { vector_Sl_unsigned_SS_char_Sg____delslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___delitem__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___delitem__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); try { vector_Sl_unsigned_SS_char_Sg____delitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; std::vector< unsigned char,std::allocator< unsigned char > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___getitem__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { result = (std::vector< unsigned char,std::allocator< unsigned char > > *)vector_Sl_unsigned_SS_char_Sg____getitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; std::vector< unsigned char,std::allocator< unsigned char > > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___setitem__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } { std::vector > *ptr = (std::vector > *)0; res3 = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckbytelist___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckbytelist___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); } arg3 = ptr; } try { vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< unsigned char,std::allocator< unsigned char > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist___setitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___setitem__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___delitem__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_unsigned_SS_char_Sg____delitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___delitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckbytelist___delitem____SWIG_1(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist___delitem____SWIG_0(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist___delitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::__delitem__(vector< unsigned char >::difference_type)\n" " vector< unsigned char >::__delitem__(PySliceObject *)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< unsigned char >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___getitem__" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___getitem__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); try { result = (vector< unsigned char >::value_type *) &vector_Sl_unsigned_SS_char_Sg____getitem____SWIG_1((vector< unsigned char > const *)arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___getitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckbytelist___getitem____SWIG_0(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist___getitem____SWIG_1(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist___getitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::__getitem__(PySliceObject *)\n" " vector< unsigned char >::__getitem__(vector< unsigned char >::difference_type) const\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::difference_type arg2 ; vector< unsigned char >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; vector< unsigned char >::value_type temp3 ; unsigned char val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist___setitem__" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist___setitem__" "', argument " "2"" of type '" "vector< unsigned char >::difference_type""'"); } arg2 = static_cast< vector< unsigned char >::difference_type >(val2); ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist___setitem__" "', argument " "3"" of type '" "vector< unsigned char >::value_type""'"); } temp3 = static_cast< vector< unsigned char >::value_type >(val3); arg3 = &temp3; try { vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_2(arg1,arg2,(unsigned char const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist___setitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckbytelist___setitem____SWIG_1(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { int res = swig::asptr(argv[2], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckbytelist___setitem____SWIG_0(self, args); } } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist___setitem____SWIG_2(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist___setitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::__setitem__(PySliceObject *,std::vector< unsigned char,std::allocator< unsigned char > > const &)\n" " vector< unsigned char >::__setitem__(PySliceObject *)\n" " vector< unsigned char >::__setitem__(vector< unsigned char >::difference_type,vector< unsigned char >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; vector< unsigned char >::value_type temp2 ; unsigned char val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist_append",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_append" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist_append" "', argument " "2"" of type '" "vector< unsigned char >::value_type""'"); } temp2 = static_cast< vector< unsigned char >::value_type >(val2); arg2 = &temp2; vector_Sl_unsigned_SS_char_Sg__append(arg1,(unsigned char const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckbytelist__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_ckbytelist")) SWIG_fail; result = (vector< unsigned char > *)new vector< unsigned char >(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckbytelist__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; std::vector< unsigned char > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; vector< unsigned char > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckbytelist",&obj0)) SWIG_fail; { std::vector > *ptr = (std::vector > *)0; res1 = swig::asptr(obj0, &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ckbytelist" "', argument " "1"" of type '" "std::vector< unsigned char > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ckbytelist" "', argument " "1"" of type '" "std::vector< unsigned char > const &""'"); } arg1 = ptr; } result = (vector< unsigned char > *)new vector< unsigned char >((std::vector< unsigned char > const &)*arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 ); if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_empty",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_empty" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (bool)((vector< unsigned char > const *)arg1)->empty(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_size",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_size" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = ((vector< unsigned char > const *)arg1)->size(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_clear",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_clear" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); (arg1)->clear(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; std::vector< unsigned char > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist_swap",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_swap" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckbytelist_swap" "', argument " "2"" of type '" "std::vector< unsigned char > &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckbytelist_swap" "', argument " "2"" of type '" "std::vector< unsigned char > &""'"); } arg2 = reinterpret_cast< std::vector< unsigned char > * >(argp2); (arg1)->swap(*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; SwigValueWrapper< std::allocator< unsigned char > > result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_get_allocator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_get_allocator" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = ((vector< unsigned char > const *)arg1)->get_allocator(); resultobj = SWIG_NewPointerObj((new vector< unsigned char >::allocator_type(static_cast< const vector< unsigned char >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_char_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_begin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_begin" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (arg1)->begin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_end",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_end" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (arg1)->end(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_rbegin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_rbegin" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (arg1)->rbegin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_rend",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_rend" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (arg1)->rend(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckbytelist__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char >::size_type arg1 ; size_t val1 ; int ecode1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckbytelist",&obj0)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckbytelist" "', argument " "1"" of type '" "vector< unsigned char >::size_type""'"); } arg1 = static_cast< vector< unsigned char >::size_type >(val1); result = (vector< unsigned char > *)new vector< unsigned char >(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_pop_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_pop_back" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); (arg1)->pop_back(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist_resize",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_resize" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist_resize" "', argument " "2"" of type '" "vector< unsigned char >::size_type""'"); } arg2 = static_cast< vector< unsigned char >::size_type >(val2); (arg1)->resize(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::iterator arg2 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< unsigned char >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist_erase",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_erase" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_erase" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_erase" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } } result = (arg1)->erase(arg2); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::iterator arg2 ; vector< unsigned char >::iterator arg3 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; swig::SwigPyIterator *iter3 = 0 ; int res3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< unsigned char >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist_erase",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_erase" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_erase" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_erase" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } } res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res3) || !iter3) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_erase" "', argument " "3"" of type '" "vector< unsigned char >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); if (iter_t) { arg3 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_erase" "', argument " "3"" of type '" "vector< unsigned char >::iterator""'"); } } result = (arg1)->erase(arg2,arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_erase(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckbytelist_erase__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckbytelist_erase__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist_erase'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::erase(vector< unsigned char >::iterator)\n" " vector< unsigned char >::erase(vector< unsigned char >::iterator,vector< unsigned char >::iterator)\n"); return 0; } SWIGINTERN PyObject *_wrap_new_ckbytelist__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char >::size_type arg1 ; vector< unsigned char >::value_type *arg2 = 0 ; size_t val1 ; int ecode1 = 0 ; vector< unsigned char >::value_type temp2 ; unsigned char val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< unsigned char > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:new_ckbytelist",&obj0,&obj1)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckbytelist" "', argument " "1"" of type '" "vector< unsigned char >::size_type""'"); } arg1 = static_cast< vector< unsigned char >::size_type >(val1); ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ckbytelist" "', argument " "2"" of type '" "vector< unsigned char >::value_type""'"); } temp2 = static_cast< vector< unsigned char >::value_type >(val2); arg2 = &temp2; result = (vector< unsigned char > *)new vector< unsigned char >(arg1,(vector< unsigned char >::value_type const &)*arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckbytelist(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 0) { return _wrap_new_ckbytelist__SWIG_0(self, args); } if (argc == 1) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_new_ckbytelist__SWIG_2(self, args); } } if (argc == 1) { int _v; int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ckbytelist__SWIG_1(self, args); } } if (argc == 2) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_new_ckbytelist__SWIG_3(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ckbytelist'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::vector()\n" " vector< unsigned char >::vector(std::vector< unsigned char > const &)\n" " vector< unsigned char >::vector(vector< unsigned char >::size_type)\n" " vector< unsigned char >::vector(vector< unsigned char >::size_type,vector< unsigned char >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; vector< unsigned char >::value_type temp2 ; unsigned char val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist_push_back",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_push_back" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist_push_back" "', argument " "2"" of type '" "vector< unsigned char >::value_type""'"); } temp2 = static_cast< vector< unsigned char >::value_type >(val2); arg2 = &temp2; (arg1)->push_back((vector< unsigned char >::value_type const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_front",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_front" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (vector< unsigned char >::value_type *) &((vector< unsigned char > const *)arg1)->front(); resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_back" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = (vector< unsigned char >::value_type *) &((vector< unsigned char > const *)arg1)->back(); resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::size_type arg2 ; vector< unsigned char >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; vector< unsigned char >::value_type temp3 ; unsigned char val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist_assign",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_assign" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist_assign" "', argument " "2"" of type '" "vector< unsigned char >::size_type""'"); } arg2 = static_cast< vector< unsigned char >::size_type >(val2); ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist_assign" "', argument " "3"" of type '" "vector< unsigned char >::value_type""'"); } temp3 = static_cast< vector< unsigned char >::value_type >(val3); arg3 = &temp3; (arg1)->assign(arg2,(vector< unsigned char >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::size_type arg2 ; vector< unsigned char >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; vector< unsigned char >::value_type temp3 ; unsigned char val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist_resize",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_resize" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist_resize" "', argument " "2"" of type '" "vector< unsigned char >::size_type""'"); } arg2 = static_cast< vector< unsigned char >::size_type >(val2); ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist_resize" "', argument " "3"" of type '" "vector< unsigned char >::value_type""'"); } temp3 = static_cast< vector< unsigned char >::value_type >(val3); arg3 = &temp3; (arg1)->resize(arg2,(vector< unsigned char >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_resize(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist_resize__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist_resize__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist_resize'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::resize(vector< unsigned char >::size_type)\n" " vector< unsigned char >::resize(vector< unsigned char >::size_type,vector< unsigned char >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::iterator arg2 ; vector< unsigned char >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; vector< unsigned char >::value_type temp3 ; unsigned char val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< unsigned char >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckbytelist_insert",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_insert" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_insert" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_insert" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } } ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist_insert" "', argument " "3"" of type '" "vector< unsigned char >::value_type""'"); } temp3 = static_cast< vector< unsigned char >::value_type >(val3); arg3 = &temp3; result = (arg1)->insert(arg2,(vector< unsigned char >::value_type const &)*arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< unsigned char >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::iterator arg2 ; vector< unsigned char >::size_type arg3 ; vector< unsigned char >::value_type *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; size_t val3 ; int ecode3 = 0 ; vector< unsigned char >::value_type temp4 ; unsigned char val4 ; int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckbytelist_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_insert" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_insert" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckbytelist_insert" "', argument " "2"" of type '" "vector< unsigned char >::iterator""'"); } } ecode3 = SWIG_AsVal_size_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckbytelist_insert" "', argument " "3"" of type '" "vector< unsigned char >::size_type""'"); } arg3 = static_cast< vector< unsigned char >::size_type >(val3); ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ckbytelist_insert" "', argument " "4"" of type '" "vector< unsigned char >::value_type""'"); } temp4 = static_cast< vector< unsigned char >::value_type >(val4); arg4 = &temp4; (arg1)->insert(arg2,arg3,(vector< unsigned char >::value_type const &)*arg4); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_insert(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { { int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist_insert__SWIG_0(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { { int res = SWIG_AsVal_size_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckbytelist_insert__SWIG_1(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckbytelist_insert'.\n" " Possible C/C++ prototypes are:\n" " vector< unsigned char >::insert(vector< unsigned char >::iterator,vector< unsigned char >::value_type const &)\n" " vector< unsigned char >::insert(vector< unsigned char >::iterator,vector< unsigned char >::size_type,vector< unsigned char >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckbytelist_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; vector< unsigned char >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckbytelist_reserve",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_reserve" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckbytelist_reserve" "', argument " "2"" of type '" "vector< unsigned char >::size_type""'"); } arg2 = static_cast< vector< unsigned char >::size_type >(val2); (arg1)->reserve(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckbytelist_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< unsigned char >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckbytelist_capacity",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckbytelist_capacity" "', argument " "1"" of type '" "vector< unsigned char > const *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); result = ((vector< unsigned char > const *)arg1)->capacity(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_ckbytelist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< unsigned char > *arg1 = (vector< unsigned char > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_ckbytelist",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ckbytelist" "', argument " "1"" of type '" "vector< unsigned char > *""'"); } arg1 = reinterpret_cast< vector< unsigned char > * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *ckbytelist_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_ckattrlist_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; PyObject **arg2 = (PyObject **) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; arg2 = &obj0; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_iterator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_iterator" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (swig::SwigPyIterator *)vector_Sl_CK_ATTRIBUTE_SMART_Sg__iterator(arg1,arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist___nonzero__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___nonzero__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (bool)vector_Sl_CK_ATTRIBUTE_SMART_Sg____nonzero__((vector< CK_ATTRIBUTE_SMART > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist___bool__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___bool__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (bool)vector_Sl_CK_ATTRIBUTE_SMART_Sg____bool__((vector< CK_ATTRIBUTE_SMART > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist___len__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___len__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = vector_Sl_CK_ATTRIBUTE_SMART_Sg____len__((vector< CK_ATTRIBUTE_SMART > const *)arg1); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::value_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_pop",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_pop" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); try { result = vector_Sl_CK_ATTRIBUTE_SMART_Sg__pop(arg1); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj((new vector< CK_ATTRIBUTE_SMART >::value_type(static_cast< const vector< CK_ATTRIBUTE_SMART >::value_type& >(result))), SWIGTYPE_p_CK_ATTRIBUTE_SMART, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___getslice__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___getslice__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckattrlist___getslice__" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg3 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val3); try { result = (std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *)vector_Sl_CK_ATTRIBUTE_SMART_Sg____getslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg3 ; std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; int res4 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckattrlist___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___setslice__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___setslice__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckattrlist___setslice__" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg3 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val3); { std::vector > *ptr = (std::vector > *)0; res4 = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ckattrlist___setslice__" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist___setslice__" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &""'"); } arg4 = ptr; } try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &)*arg4); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: if (SWIG_IsNewObj(res4)) delete arg4; return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___setslice__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___setslice__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckattrlist___setslice__" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg3 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val3); try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____setslice____SWIG_0(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___setslice__(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckattrlist___setslice____SWIG_1(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = swig::asptr(argv[3], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckattrlist___setslice____SWIG_0(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist___setslice__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::__setslice__(vector< CK_ATTRIBUTE_SMART >::difference_type,vector< CK_ATTRIBUTE_SMART >::difference_type,std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &)\n" " vector< CK_ATTRIBUTE_SMART >::__setslice__(vector< CK_ATTRIBUTE_SMART >::difference_type,vector< CK_ATTRIBUTE_SMART >::difference_type)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___delslice__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___delslice__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckattrlist___delslice__" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg3 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val3); try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____delslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___delitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___delitem__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____delitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___getitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { result = (std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *)vector_Sl_CK_ATTRIBUTE_SMART_Sg____getitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___setitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } { std::vector > *ptr = (std::vector > *)0; res3 = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckattrlist___setitem__" "', argument " "3"" of type '" "std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist___setitem__" "', argument " "3"" of type '" "std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &""'"); } arg3 = ptr; } try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist___setitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___setitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____setitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___delitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____delitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___delitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckattrlist___delitem____SWIG_1(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckattrlist___delitem____SWIG_0(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist___delitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::__delitem__(vector< CK_ATTRIBUTE_SMART >::difference_type)\n" " vector< CK_ATTRIBUTE_SMART >::__delitem__(PySliceObject *)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< CK_ATTRIBUTE_SMART >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___getitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___getitem__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); try { result = (vector< CK_ATTRIBUTE_SMART >::value_type *) &vector_Sl_CK_ATTRIBUTE_SMART_Sg____getitem____SWIG_1((vector< CK_ATTRIBUTE_SMART > const *)arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___getitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckattrlist___getitem____SWIG_0(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckattrlist___getitem____SWIG_1(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist___getitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::__getitem__(PySliceObject *)\n" " vector< CK_ATTRIBUTE_SMART >::__getitem__(vector< CK_ATTRIBUTE_SMART >::difference_type) const\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::difference_type arg2 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist___setitem__" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist___setitem__" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::difference_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::difference_type >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckattrlist___setitem__" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist___setitem__" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp3); try { vector_Sl_CK_ATTRIBUTE_SMART_Sg____setitem____SWIG_2(arg1,arg2,(CK_ATTRIBUTE_SMART const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist___setitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckattrlist___setitem____SWIG_1(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { int res = swig::asptr(argv[2], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckattrlist___setitem____SWIG_0(self, args); } } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckattrlist___setitem____SWIG_2(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist___setitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::__setitem__(PySliceObject *,std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > const &)\n" " vector< CK_ATTRIBUTE_SMART >::__setitem__(PySliceObject *)\n" " vector< CK_ATTRIBUTE_SMART >::__setitem__(vector< CK_ATTRIBUTE_SMART >::difference_type,vector< CK_ATTRIBUTE_SMART >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist_append",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_append" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckattrlist_append" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_append" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg2 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp2); vector_Sl_CK_ATTRIBUTE_SMART_Sg__append(arg1,(CK_ATTRIBUTE_SMART const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckattrlist__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_ckattrlist")) SWIG_fail; result = (vector< CK_ATTRIBUTE_SMART > *)new vector< CK_ATTRIBUTE_SMART >(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckattrlist__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; std::vector< CK_ATTRIBUTE_SMART > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckattrlist",&obj0)) SWIG_fail; { std::vector > *ptr = (std::vector > *)0; res1 = swig::asptr(obj0, &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ckattrlist" "', argument " "1"" of type '" "std::vector< CK_ATTRIBUTE_SMART > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ckattrlist" "', argument " "1"" of type '" "std::vector< CK_ATTRIBUTE_SMART > const &""'"); } arg1 = ptr; } result = (vector< CK_ATTRIBUTE_SMART > *)new vector< CK_ATTRIBUTE_SMART >((std::vector< CK_ATTRIBUTE_SMART > const &)*arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_POINTER_NEW | 0 ); if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_empty",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_empty" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (bool)((vector< CK_ATTRIBUTE_SMART > const *)arg1)->empty(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_size",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_size" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = ((vector< CK_ATTRIBUTE_SMART > const *)arg1)->size(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_clear",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_clear" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); (arg1)->clear(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; std::vector< CK_ATTRIBUTE_SMART > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist_swap",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_swap" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckattrlist_swap" "', argument " "2"" of type '" "std::vector< CK_ATTRIBUTE_SMART > &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_swap" "', argument " "2"" of type '" "std::vector< CK_ATTRIBUTE_SMART > &""'"); } arg2 = reinterpret_cast< std::vector< CK_ATTRIBUTE_SMART > * >(argp2); (arg1)->swap(*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; SwigValueWrapper< std::allocator< CK_ATTRIBUTE_SMART > > result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_get_allocator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_get_allocator" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = ((vector< CK_ATTRIBUTE_SMART > const *)arg1)->get_allocator(); resultobj = SWIG_NewPointerObj((new vector< CK_ATTRIBUTE_SMART >::allocator_type(static_cast< const vector< CK_ATTRIBUTE_SMART >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_CK_ATTRIBUTE_SMART_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_begin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_begin" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (arg1)->begin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_end",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_end" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (arg1)->end(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_rbegin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_rbegin" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (arg1)->rbegin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_rend",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_rend" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (arg1)->rend(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckattrlist__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART >::size_type arg1 ; size_t val1 ; int ecode1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckattrlist",&obj0)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckattrlist" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg1 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val1); result = (vector< CK_ATTRIBUTE_SMART > *)new vector< CK_ATTRIBUTE_SMART >(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_pop_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_pop_back" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); (arg1)->pop_back(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist_resize",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_resize" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist_resize" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val2); (arg1)->resize(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::iterator arg2 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< CK_ATTRIBUTE_SMART >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist_erase",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_erase" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_erase" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_erase" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } } result = (arg1)->erase(arg2); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::iterator arg2 ; vector< CK_ATTRIBUTE_SMART >::iterator arg3 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; swig::SwigPyIterator *iter3 = 0 ; int res3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< CK_ATTRIBUTE_SMART >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist_erase",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_erase" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_erase" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_erase" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } } res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res3) || !iter3) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_erase" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); if (iter_t) { arg3 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_erase" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } } result = (arg1)->erase(arg2,arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_erase(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckattrlist_erase__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckattrlist_erase__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist_erase'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::erase(vector< CK_ATTRIBUTE_SMART >::iterator)\n" " vector< CK_ATTRIBUTE_SMART >::erase(vector< CK_ATTRIBUTE_SMART >::iterator,vector< CK_ATTRIBUTE_SMART >::iterator)\n"); return 0; } SWIGINTERN PyObject *_wrap_new_ckattrlist__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART >::size_type arg1 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg2 = 0 ; size_t val1 ; int ecode1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< CK_ATTRIBUTE_SMART > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:new_ckattrlist",&obj0,&obj1)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckattrlist" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg1 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ckattrlist" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ckattrlist" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg2 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp2); result = (vector< CK_ATTRIBUTE_SMART > *)new vector< CK_ATTRIBUTE_SMART >(arg1,(vector< CK_ATTRIBUTE_SMART >::value_type const &)*arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckattrlist(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 0) { return _wrap_new_ckattrlist__SWIG_0(self, args); } if (argc == 1) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_new_ckattrlist__SWIG_2(self, args); } } if (argc == 1) { int _v; int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ckattrlist__SWIG_1(self, args); } } if (argc == 2) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ckattrlist__SWIG_3(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ckattrlist'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::vector()\n" " vector< CK_ATTRIBUTE_SMART >::vector(std::vector< CK_ATTRIBUTE_SMART > const &)\n" " vector< CK_ATTRIBUTE_SMART >::vector(vector< CK_ATTRIBUTE_SMART >::size_type)\n" " vector< CK_ATTRIBUTE_SMART >::vector(vector< CK_ATTRIBUTE_SMART >::size_type,vector< CK_ATTRIBUTE_SMART >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist_push_back",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_push_back" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckattrlist_push_back" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_push_back" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg2 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp2); (arg1)->push_back((vector< CK_ATTRIBUTE_SMART >::value_type const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_front",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_front" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (vector< CK_ATTRIBUTE_SMART >::value_type *) &((vector< CK_ATTRIBUTE_SMART > const *)arg1)->front(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_back" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = (vector< CK_ATTRIBUTE_SMART >::value_type *) &((vector< CK_ATTRIBUTE_SMART > const *)arg1)->back(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::size_type arg2 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist_assign",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_assign" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist_assign" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckattrlist_assign" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_assign" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp3); (arg1)->assign(arg2,(vector< CK_ATTRIBUTE_SMART >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::size_type arg2 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist_resize",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_resize" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist_resize" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckattrlist_resize" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_resize" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp3); (arg1)->resize(arg2,(vector< CK_ATTRIBUTE_SMART >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_resize(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckattrlist_resize__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckattrlist_resize__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist_resize'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::resize(vector< CK_ATTRIBUTE_SMART >::size_type)\n" " vector< CK_ATTRIBUTE_SMART >::resize(vector< CK_ATTRIBUTE_SMART >::size_type,vector< CK_ATTRIBUTE_SMART >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::iterator arg2 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< CK_ATTRIBUTE_SMART >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckattrlist_insert",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_insert" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_insert" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_insert" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckattrlist_insert" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_insert" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp3); result = (arg1)->insert(arg2,(vector< CK_ATTRIBUTE_SMART >::value_type const &)*arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_ATTRIBUTE_SMART >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::iterator arg2 ; vector< CK_ATTRIBUTE_SMART >::size_type arg3 ; vector< CK_ATTRIBUTE_SMART >::value_type *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; size_t val3 ; int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckattrlist_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_insert" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_insert" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckattrlist_insert" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::iterator""'"); } } ecode3 = SWIG_AsVal_size_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckattrlist_insert" "', argument " "3"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg3 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val3); res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ckattrlist_insert" "', argument " "4"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckattrlist_insert" "', argument " "4"" of type '" "vector< CK_ATTRIBUTE_SMART >::value_type const &""'"); } arg4 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART >::value_type * >(argp4); (arg1)->insert(arg2,arg3,(vector< CK_ATTRIBUTE_SMART >::value_type const &)*arg4); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_insert(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckattrlist_insert__SWIG_0(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { { int res = SWIG_AsVal_size_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckattrlist_insert__SWIG_1(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckattrlist_insert'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_ATTRIBUTE_SMART >::insert(vector< CK_ATTRIBUTE_SMART >::iterator,vector< CK_ATTRIBUTE_SMART >::value_type const &)\n" " vector< CK_ATTRIBUTE_SMART >::insert(vector< CK_ATTRIBUTE_SMART >::iterator,vector< CK_ATTRIBUTE_SMART >::size_type,vector< CK_ATTRIBUTE_SMART >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckattrlist_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; vector< CK_ATTRIBUTE_SMART >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckattrlist_reserve",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_reserve" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckattrlist_reserve" "', argument " "2"" of type '" "vector< CK_ATTRIBUTE_SMART >::size_type""'"); } arg2 = static_cast< vector< CK_ATTRIBUTE_SMART >::size_type >(val2); (arg1)->reserve(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckattrlist_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_ATTRIBUTE_SMART >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckattrlist_capacity",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckattrlist_capacity" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > const *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); result = ((vector< CK_ATTRIBUTE_SMART > const *)arg1)->capacity(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_ckattrlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_ATTRIBUTE_SMART > *arg1 = (vector< CK_ATTRIBUTE_SMART > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_ckattrlist",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ckattrlist" "', argument " "1"" of type '" "vector< CK_ATTRIBUTE_SMART > *""'"); } arg1 = reinterpret_cast< vector< CK_ATTRIBUTE_SMART > * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *ckattrlist_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_ckobjlist_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; PyObject **arg2 = (PyObject **) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; swig::SwigPyIterator *result = 0 ; arg2 = &obj0; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_iterator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_iterator" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (swig::SwigPyIterator *)vector_Sl_CK_OBJECT_HANDLE_Sg__iterator(arg1,arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist___nonzero__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___nonzero__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (bool)vector_Sl_CK_OBJECT_HANDLE_Sg____nonzero__((vector< CK_OBJECT_HANDLE > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist___bool__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___bool__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (bool)vector_Sl_CK_OBJECT_HANDLE_Sg____bool__((vector< CK_OBJECT_HANDLE > const *)arg1); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist___len__",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___len__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = vector_Sl_CK_OBJECT_HANDLE_Sg____len__((vector< CK_OBJECT_HANDLE > const *)arg1); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_pop",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_pop" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); try { result = vector_Sl_CK_OBJECT_HANDLE_Sg__pop(arg1); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj((new vector< CK_OBJECT_HANDLE >::value_type(static_cast< const vector< CK_OBJECT_HANDLE >::value_type& >(result))), SWIGTYPE_p_CK_OBJECT_HANDLE, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; vector< CK_OBJECT_HANDLE >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___getslice__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___getslice__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckobjlist___getslice__" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg3 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val3); try { result = (std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *)vector_Sl_CK_OBJECT_HANDLE_Sg____getslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; vector< CK_OBJECT_HANDLE >::difference_type arg3 ; std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; int res4 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckobjlist___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___setslice__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___setslice__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckobjlist___setslice__" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg3 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val3); { std::vector > *ptr = (std::vector > *)0; res4 = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ckobjlist___setslice__" "', argument " "4"" of type '" "std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist___setslice__" "', argument " "4"" of type '" "std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &""'"); } arg4 = ptr; } try { vector_Sl_CK_OBJECT_HANDLE_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &)*arg4); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: if (SWIG_IsNewObj(res4)) delete arg4; return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; vector< CK_OBJECT_HANDLE >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist___setslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___setslice__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___setslice__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckobjlist___setslice__" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg3 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val3); try { vector_Sl_CK_OBJECT_HANDLE_Sg____setslice____SWIG_0(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___setslice__(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckobjlist___setslice____SWIG_1(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = swig::asptr(argv[3], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckobjlist___setslice____SWIG_0(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist___setslice__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::__setslice__(vector< CK_OBJECT_HANDLE >::difference_type,vector< CK_OBJECT_HANDLE >::difference_type,std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &)\n" " vector< CK_OBJECT_HANDLE >::__setslice__(vector< CK_OBJECT_HANDLE >::difference_type,vector< CK_OBJECT_HANDLE >::difference_type)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; vector< CK_OBJECT_HANDLE >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; ptrdiff_t val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___delslice__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___delslice__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckobjlist___delslice__" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg3 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val3); try { vector_Sl_CK_OBJECT_HANDLE_Sg____delslice__(arg1,arg2,arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___delitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___delitem__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); try { vector_Sl_CK_OBJECT_HANDLE_Sg____delitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___getitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist___getitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { result = (std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *)vector_Sl_CK_OBJECT_HANDLE_Sg____getitem____SWIG_0(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___setitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } { std::vector > *ptr = (std::vector > *)0; res3 = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckobjlist___setitem__" "', argument " "3"" of type '" "std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist___setitem__" "', argument " "3"" of type '" "std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &""'"); } arg3 = ptr; } try { vector_Sl_CK_OBJECT_HANDLE_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } catch(std::invalid_argument &_e) { SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); } resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist___setitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___setitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist___setitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_CK_OBJECT_HANDLE_Sg____setitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist___delitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___delitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); { if (!PySlice_Check(obj1)) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist___delitem__" "', argument " "2"" of type '" "PySliceObject *""'"); } arg2 = (PySliceObject *) obj1; } try { vector_Sl_CK_OBJECT_HANDLE_Sg____delitem____SWIG_1(arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___delitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckobjlist___delitem____SWIG_1(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckobjlist___delitem____SWIG_0(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist___delitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::__delitem__(vector< CK_OBJECT_HANDLE >::difference_type)\n" " vector< CK_OBJECT_HANDLE >::__delitem__(PySliceObject *)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< CK_OBJECT_HANDLE >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___getitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___getitem__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); try { result = (vector< CK_OBJECT_HANDLE >::value_type *) &vector_Sl_CK_OBJECT_HANDLE_Sg____getitem____SWIG_1((vector< CK_OBJECT_HANDLE > const *)arg1,arg2); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___getitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckobjlist___getitem____SWIG_0(self, args); } } } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckobjlist___getitem____SWIG_1(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist___getitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::__getitem__(PySliceObject *)\n" " vector< CK_OBJECT_HANDLE >::__getitem__(vector< CK_OBJECT_HANDLE >::difference_type) const\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::difference_type arg2 ; vector< CK_OBJECT_HANDLE >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; ptrdiff_t val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist___setitem__" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist___setitem__" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::difference_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::difference_type >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckobjlist___setitem__" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist___setitem__" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp3); try { vector_Sl_CK_OBJECT_HANDLE_Sg____setitem____SWIG_2(arg1,arg2,(CK_OBJECT_HANDLE const &)*arg3); } catch(std::out_of_range &_e) { SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist___setitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { return _wrap_ckobjlist___setitem____SWIG_1(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { _v = PySlice_Check(argv[1]); } if (_v) { int res = swig::asptr(argv[2], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckobjlist___setitem____SWIG_0(self, args); } } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CK_OBJECT_HANDLE, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckobjlist___setitem____SWIG_2(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist___setitem__'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::__setitem__(PySliceObject *,std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > const &)\n" " vector< CK_OBJECT_HANDLE >::__setitem__(PySliceObject *)\n" " vector< CK_OBJECT_HANDLE >::__setitem__(vector< CK_OBJECT_HANDLE >::difference_type,vector< CK_OBJECT_HANDLE >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist_append",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_append" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckobjlist_append" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_append" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg2 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp2); vector_Sl_CK_OBJECT_HANDLE_Sg__append(arg1,(CK_OBJECT_HANDLE const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckobjlist__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_ckobjlist")) SWIG_fail; result = (vector< CK_OBJECT_HANDLE > *)new vector< CK_OBJECT_HANDLE >(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckobjlist__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; std::vector< CK_OBJECT_HANDLE > *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckobjlist",&obj0)) SWIG_fail; { std::vector > *ptr = (std::vector > *)0; res1 = swig::asptr(obj0, &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ckobjlist" "', argument " "1"" of type '" "std::vector< CK_OBJECT_HANDLE > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ckobjlist" "', argument " "1"" of type '" "std::vector< CK_OBJECT_HANDLE > const &""'"); } arg1 = ptr; } result = (vector< CK_OBJECT_HANDLE > *)new vector< CK_OBJECT_HANDLE >((std::vector< CK_OBJECT_HANDLE > const &)*arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_POINTER_NEW | 0 ); if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: if (SWIG_IsNewObj(res1)) delete arg1; return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_empty",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_empty" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (bool)((vector< CK_OBJECT_HANDLE > const *)arg1)->empty(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_size",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_size" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = ((vector< CK_OBJECT_HANDLE > const *)arg1)->size(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_clear",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_clear" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); (arg1)->clear(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; std::vector< CK_OBJECT_HANDLE > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist_swap",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_swap" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckobjlist_swap" "', argument " "2"" of type '" "std::vector< CK_OBJECT_HANDLE > &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_swap" "', argument " "2"" of type '" "std::vector< CK_OBJECT_HANDLE > &""'"); } arg2 = reinterpret_cast< std::vector< CK_OBJECT_HANDLE > * >(argp2); (arg1)->swap(*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; SwigValueWrapper< std::allocator< CK_OBJECT_HANDLE > > result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_get_allocator",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_get_allocator" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = ((vector< CK_OBJECT_HANDLE > const *)arg1)->get_allocator(); resultobj = SWIG_NewPointerObj((new vector< CK_OBJECT_HANDLE >::allocator_type(static_cast< const vector< CK_OBJECT_HANDLE >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_CK_OBJECT_HANDLE_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_begin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_begin" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (arg1)->begin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_end",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_end" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (arg1)->end(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_rbegin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_rbegin" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (arg1)->rbegin(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::reverse_iterator result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_rend",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_rend" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (arg1)->rend(); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::reverse_iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckobjlist__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE >::size_type arg1 ; size_t val1 ; int ecode1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_ckobjlist",&obj0)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckobjlist" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg1 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val1); result = (vector< CK_OBJECT_HANDLE > *)new vector< CK_OBJECT_HANDLE >(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_pop_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_pop_back" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); (arg1)->pop_back(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist_resize",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_resize" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist_resize" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val2); (arg1)->resize(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::iterator arg2 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< CK_OBJECT_HANDLE >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist_erase",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_erase" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_erase" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_erase" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } } result = (arg1)->erase(arg2); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::iterator arg2 ; vector< CK_OBJECT_HANDLE >::iterator arg3 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; swig::SwigPyIterator *iter3 = 0 ; int res3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< CK_OBJECT_HANDLE >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist_erase",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_erase" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_erase" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_erase" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } } res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res3) || !iter3) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_erase" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); if (iter_t) { arg3 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_erase" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } } result = (arg1)->erase(arg2,arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_erase(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckobjlist_erase__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { return _wrap_ckobjlist_erase__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist_erase'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::erase(vector< CK_OBJECT_HANDLE >::iterator)\n" " vector< CK_OBJECT_HANDLE >::erase(vector< CK_OBJECT_HANDLE >::iterator,vector< CK_OBJECT_HANDLE >::iterator)\n"); return 0; } SWIGINTERN PyObject *_wrap_new_ckobjlist__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE >::size_type arg1 ; vector< CK_OBJECT_HANDLE >::value_type *arg2 = 0 ; size_t val1 ; int ecode1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; vector< CK_OBJECT_HANDLE > *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:new_ckobjlist",&obj0,&obj1)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ckobjlist" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg1 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ckobjlist" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ckobjlist" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg2 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp2); result = (vector< CK_OBJECT_HANDLE > *)new vector< CK_OBJECT_HANDLE >(arg1,(vector< CK_OBJECT_HANDLE >::value_type const &)*arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_ckobjlist(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 0) { return _wrap_new_ckobjlist__SWIG_0(self, args); } if (argc == 1) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_new_ckobjlist__SWIG_2(self, args); } } if (argc == 1) { int _v; int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ckobjlist__SWIG_1(self, args); } } if (argc == 2) { int _v; { int res = SWIG_AsVal_size_t(argv[0], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_CK_OBJECT_HANDLE, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ckobjlist__SWIG_3(self, args); } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ckobjlist'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::vector()\n" " vector< CK_OBJECT_HANDLE >::vector(std::vector< CK_OBJECT_HANDLE > const &)\n" " vector< CK_OBJECT_HANDLE >::vector(vector< CK_OBJECT_HANDLE >::size_type)\n" " vector< CK_OBJECT_HANDLE >::vector(vector< CK_OBJECT_HANDLE >::size_type,vector< CK_OBJECT_HANDLE >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist_push_back",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_push_back" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckobjlist_push_back" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_push_back" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg2 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp2); (arg1)->push_back((vector< CK_OBJECT_HANDLE >::value_type const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_front",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_front" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (vector< CK_OBJECT_HANDLE >::value_type *) &((vector< CK_OBJECT_HANDLE > const *)arg1)->front(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::value_type *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_back",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_back" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = (vector< CK_OBJECT_HANDLE >::value_type *) &((vector< CK_OBJECT_HANDLE > const *)arg1)->back(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::size_type arg2 ; vector< CK_OBJECT_HANDLE >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist_assign",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_assign" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist_assign" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckobjlist_assign" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_assign" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp3); (arg1)->assign(arg2,(vector< CK_OBJECT_HANDLE >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::size_type arg2 ; vector< CK_OBJECT_HANDLE >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist_resize",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_resize" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist_resize" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckobjlist_resize" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_resize" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp3); (arg1)->resize(arg2,(vector< CK_OBJECT_HANDLE >::value_type const &)*arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_resize(PyObject *self, PyObject *args) { int argc; PyObject *argv[4]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { return _wrap_ckobjlist_resize__SWIG_0(self, args); } } } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_size_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CK_OBJECT_HANDLE, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckobjlist_resize__SWIG_1(self, args); } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist_resize'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::resize(vector< CK_OBJECT_HANDLE >::size_type)\n" " vector< CK_OBJECT_HANDLE >::resize(vector< CK_OBJECT_HANDLE >::size_type,vector< CK_OBJECT_HANDLE >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::iterator arg2 ; vector< CK_OBJECT_HANDLE >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; vector< CK_OBJECT_HANDLE >::iterator result; if (!PyArg_ParseTuple(args,(char *)"OOO:ckobjlist_insert",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_insert" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_insert" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_insert" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ckobjlist_insert" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_insert" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg3 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp3); result = (arg1)->insert(arg2,(vector< CK_OBJECT_HANDLE >::value_type const &)*arg3); resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const vector< CK_OBJECT_HANDLE >::iterator & >(result)), swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::iterator arg2 ; vector< CK_OBJECT_HANDLE >::size_type arg3 ; vector< CK_OBJECT_HANDLE >::value_type *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; swig::SwigPyIterator *iter2 = 0 ; int res2 ; size_t val3 ; int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOOO:ckobjlist_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_insert" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); if (!SWIG_IsOK(res2) || !iter2) { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_insert" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } else { swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); if (iter_t) { arg2 = iter_t->get_current(); } else { SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ckobjlist_insert" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::iterator""'"); } } ecode3 = SWIG_AsVal_size_t(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckobjlist_insert" "', argument " "3"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg3 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val3); res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ckobjlist_insert" "', argument " "4"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ckobjlist_insert" "', argument " "4"" of type '" "vector< CK_OBJECT_HANDLE >::value_type const &""'"); } arg4 = reinterpret_cast< vector< CK_OBJECT_HANDLE >::value_type * >(argp4); (arg1)->insert(arg2,arg3,(vector< CK_OBJECT_HANDLE >::value_type const &)*arg4); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_insert(PyObject *self, PyObject *args) { int argc; PyObject *argv[5]; int ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? (int)PyObject_Length(args) : 0; for (ii = 0; (ii < 4) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CK_OBJECT_HANDLE, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckobjlist_insert__SWIG_0(self, args); } } } } if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0); _v = SWIG_CheckState(res); if (_v) { swig::SwigPyIterator *iter = 0; int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); if (_v) { { int res = SWIG_AsVal_size_t(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CK_OBJECT_HANDLE, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_ckobjlist_insert__SWIG_1(self, args); } } } } } fail: SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ckobjlist_insert'.\n" " Possible C/C++ prototypes are:\n" " vector< CK_OBJECT_HANDLE >::insert(vector< CK_OBJECT_HANDLE >::iterator,vector< CK_OBJECT_HANDLE >::value_type const &)\n" " vector< CK_OBJECT_HANDLE >::insert(vector< CK_OBJECT_HANDLE >::iterator,vector< CK_OBJECT_HANDLE >::size_type,vector< CK_OBJECT_HANDLE >::value_type const &)\n"); return 0; } SWIGINTERN PyObject *_wrap_ckobjlist_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; vector< CK_OBJECT_HANDLE >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:ckobjlist_reserve",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_reserve" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckobjlist_reserve" "', argument " "2"" of type '" "vector< CK_OBJECT_HANDLE >::size_type""'"); } arg2 = static_cast< vector< CK_OBJECT_HANDLE >::size_type >(val2); (arg1)->reserve(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_ckobjlist_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; vector< CK_OBJECT_HANDLE >::size_type result; if (!PyArg_ParseTuple(args,(char *)"O:ckobjlist_capacity",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ckobjlist_capacity" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > const *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); result = ((vector< CK_OBJECT_HANDLE > const *)arg1)->capacity(); resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_ckobjlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; vector< CK_OBJECT_HANDLE > *arg1 = (vector< CK_OBJECT_HANDLE > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_ckobjlist",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ckobjlist" "', argument " "1"" of type '" "vector< CK_OBJECT_HANDLE > *""'"); } arg1 = reinterpret_cast< vector< CK_OBJECT_HANDLE > * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *ckobjlist_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_new_CK_SESSION_HANDLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_HANDLE *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_SESSION_HANDLE")) SWIG_fail; result = (CK_SESSION_HANDLE *)new_CK_SESSION_HANDLE(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_SESSION_HANDLE, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_SESSION_HANDLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_HANDLE *arg1 = (CK_SESSION_HANDLE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_SESSION_HANDLE",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_HANDLE, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_SESSION_HANDLE" "', argument " "1"" of type '" "CK_SESSION_HANDLE *""'"); } arg1 = reinterpret_cast< CK_SESSION_HANDLE * >(argp1); delete_CK_SESSION_HANDLE(arg1); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_HANDLE_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_HANDLE *arg1 = (CK_SESSION_HANDLE *) 0 ; unsigned long arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_SESSION_HANDLE_assign",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_HANDLE_assign" "', argument " "1"" of type '" "CK_SESSION_HANDLE *""'"); } arg1 = reinterpret_cast< CK_SESSION_HANDLE * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_SESSION_HANDLE_assign" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); CK_SESSION_HANDLE_assign(arg1,arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_HANDLE_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_HANDLE *arg1 = (CK_SESSION_HANDLE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_HANDLE_value",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_HANDLE_value" "', argument " "1"" of type '" "CK_SESSION_HANDLE *""'"); } arg1 = reinterpret_cast< CK_SESSION_HANDLE * >(argp1); result = (unsigned long)CK_SESSION_HANDLE_value(arg1); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_HANDLE_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_HANDLE *arg1 = (CK_SESSION_HANDLE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_HANDLE_cast",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_HANDLE_cast" "', argument " "1"" of type '" "CK_SESSION_HANDLE *""'"); } arg1 = reinterpret_cast< CK_SESSION_HANDLE * >(argp1); result = (unsigned long *)CK_SESSION_HANDLE_cast(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_HANDLE_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; unsigned long *arg1 = (unsigned long *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_SESSION_HANDLE *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_HANDLE_frompointer",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_long, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_HANDLE_frompointer" "', argument " "1"" of type '" "unsigned long *""'"); } arg1 = reinterpret_cast< unsigned long * >(argp1); result = (CK_SESSION_HANDLE *)CK_SESSION_HANDLE_frompointer(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_SESSION_HANDLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_SESSION_HANDLE, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_new_CK_OBJECT_HANDLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_OBJECT_HANDLE *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_OBJECT_HANDLE")) SWIG_fail; result = (CK_OBJECT_HANDLE *)new_CK_OBJECT_HANDLE(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_OBJECT_HANDLE, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_OBJECT_HANDLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_OBJECT_HANDLE *arg1 = (CK_OBJECT_HANDLE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_OBJECT_HANDLE",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_OBJECT_HANDLE, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_OBJECT_HANDLE" "', argument " "1"" of type '" "CK_OBJECT_HANDLE *""'"); } arg1 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp1); delete_CK_OBJECT_HANDLE(arg1); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_OBJECT_HANDLE_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_OBJECT_HANDLE *arg1 = (CK_OBJECT_HANDLE *) 0 ; unsigned long arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_OBJECT_HANDLE_assign",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_OBJECT_HANDLE_assign" "', argument " "1"" of type '" "CK_OBJECT_HANDLE *""'"); } arg1 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_OBJECT_HANDLE_assign" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); CK_OBJECT_HANDLE_assign(arg1,arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_OBJECT_HANDLE_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_OBJECT_HANDLE *arg1 = (CK_OBJECT_HANDLE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_OBJECT_HANDLE_value",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_OBJECT_HANDLE_value" "', argument " "1"" of type '" "CK_OBJECT_HANDLE *""'"); } arg1 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp1); result = (unsigned long)CK_OBJECT_HANDLE_value(arg1); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_OBJECT_HANDLE_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_OBJECT_HANDLE *arg1 = (CK_OBJECT_HANDLE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_OBJECT_HANDLE_cast",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_OBJECT_HANDLE_cast" "', argument " "1"" of type '" "CK_OBJECT_HANDLE *""'"); } arg1 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp1); result = (unsigned long *)CK_OBJECT_HANDLE_cast(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_OBJECT_HANDLE_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; unsigned long *arg1 = (unsigned long *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_OBJECT_HANDLE *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_OBJECT_HANDLE_frompointer",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_long, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_OBJECT_HANDLE_frompointer" "', argument " "1"" of type '" "unsigned long *""'"); } arg1 = reinterpret_cast< unsigned long * >(argp1); result = (CK_OBJECT_HANDLE *)CK_OBJECT_HANDLE_frompointer(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_OBJECT_HANDLE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_OBJECT_HANDLE, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_new_byteArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; size_t arg1 ; size_t val1 ; int ecode1 = 0 ; PyObject * obj0 = 0 ; byteArray *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:new_byteArray",&obj0)) SWIG_fail; ecode1 = SWIG_AsVal_size_t(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_byteArray" "', argument " "1"" of type '" "size_t""'"); } arg1 = static_cast< size_t >(val1); result = (byteArray *)new_byteArray(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_byteArray, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_byteArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; byteArray *arg1 = (byteArray *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_byteArray",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_byteArray, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_byteArray" "', argument " "1"" of type '" "byteArray *""'"); } arg1 = reinterpret_cast< byteArray * >(argp1); delete_byteArray(arg1); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_byteArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; byteArray *arg1 = (byteArray *) 0 ; size_t arg2 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; char result; if (!PyArg_ParseTuple(args,(char *)"OO:byteArray___getitem__",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_byteArray, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "byteArray___getitem__" "', argument " "1"" of type '" "byteArray *""'"); } arg1 = reinterpret_cast< byteArray * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "byteArray___getitem__" "', argument " "2"" of type '" "size_t""'"); } arg2 = static_cast< size_t >(val2); result = (char)byteArray___getitem__(arg1,arg2); resultobj = SWIG_From_char(static_cast< char >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_byteArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; byteArray *arg1 = (byteArray *) 0 ; size_t arg2 ; char arg3 ; void *argp1 = 0 ; int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; char val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:byteArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_byteArray, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "byteArray___setitem__" "', argument " "1"" of type '" "byteArray *""'"); } arg1 = reinterpret_cast< byteArray * >(argp1); ecode2 = SWIG_AsVal_size_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "byteArray___setitem__" "', argument " "2"" of type '" "size_t""'"); } arg2 = static_cast< size_t >(val2); ecode3 = SWIG_AsVal_char(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "byteArray___setitem__" "', argument " "3"" of type '" "char""'"); } arg3 = static_cast< char >(val3); byteArray___setitem__(arg1,arg2,arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_byteArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; byteArray *arg1 = (byteArray *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; char *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:byteArray_cast",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_byteArray, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "byteArray_cast" "', argument " "1"" of type '" "byteArray *""'"); } arg1 = reinterpret_cast< byteArray * >(argp1); result = (char *)byteArray_cast(arg1); resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_byteArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; PyObject * obj0 = 0 ; byteArray *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:byteArray_frompointer",&obj0)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "byteArray_frompointer" "', argument " "1"" of type '" "char *""'"); } arg1 = reinterpret_cast< char * >(buf1); result = (byteArray *)byteArray_frompointer(arg1); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_byteArray, 0 | 0 ); if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return resultobj; fail: if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } SWIGINTERN PyObject *byteArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_byteArray, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_VERSION_major_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_VERSION *arg1 = (CK_VERSION *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned char result; if (!PyArg_ParseTuple(args,(char *)"O:CK_VERSION_major_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_VERSION, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_VERSION_major_get" "', argument " "1"" of type '" "CK_VERSION *""'"); } arg1 = reinterpret_cast< CK_VERSION * >(argp1); result = (unsigned char) ((arg1)->major); resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_VERSION_minor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_VERSION *arg1 = (CK_VERSION *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned char result; if (!PyArg_ParseTuple(args,(char *)"O:CK_VERSION_minor_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_VERSION, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_VERSION_minor_get" "', argument " "1"" of type '" "CK_VERSION *""'"); } arg1 = reinterpret_cast< CK_VERSION * >(argp1); result = (unsigned char) ((arg1)->minor); resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_VERSION(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_VERSION")) SWIG_fail; result = (CK_VERSION *)new CK_VERSION(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_VERSION(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_VERSION *arg1 = (CK_VERSION *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_VERSION",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_VERSION, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_VERSION" "', argument " "1"" of type '" "CK_VERSION *""'"); } arg1 = reinterpret_cast< CK_VERSION * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_VERSION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_VERSION, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_INFO_cryptokiVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_cryptokiVersion_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_cryptokiVersion_get" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = (CK_VERSION *)& ((arg1)->cryptokiVersion); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_manufacturerID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned char *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_manufacturerID_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_manufacturerID_get" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = (unsigned char *)(unsigned char *) ((arg1)->manufacturerID); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_flags_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_flags_get" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = (unsigned long) ((arg1)->flags); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_libraryDescription_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned char *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_libraryDescription_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_libraryDescription_get" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = (unsigned char *)(unsigned char *) ((arg1)->libraryDescription); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_libraryVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_libraryVersion_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_libraryVersion_get" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = (CK_VERSION *)& ((arg1)->libraryVersion); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_GetManufacturerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_GetManufacturerID",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_GetManufacturerID" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = CK_INFO_GetManufacturerID(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_GetLibraryDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_GetLibraryDescription",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_GetLibraryDescription" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = CK_INFO_GetLibraryDescription(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_INFO_GetLibraryVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_INFO_GetLibraryVersion",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_INFO_GetLibraryVersion" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); result = CK_INFO_GetLibraryVersion(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_INFO")) SWIG_fail; result = (CK_INFO *)new CK_INFO(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_INFO, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_INFO *arg1 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_INFO",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_INFO, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_INFO" "', argument " "1"" of type '" "CK_INFO *""'"); } arg1 = reinterpret_cast< CK_INFO * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_INFO_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_INFO, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_flags_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_flags_get" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = (unsigned long) ((arg1)->flags); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_hardwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_hardwareVersion_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_hardwareVersion_get" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = (CK_VERSION *)& ((arg1)->hardwareVersion); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_firmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_firmwareVersion_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_firmwareVersion_get" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = (CK_VERSION *)& ((arg1)->firmwareVersion); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_GetManufacturerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_GetManufacturerID",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_GetManufacturerID" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = CK_SLOT_INFO_GetManufacturerID(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_GetSlotDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_GetSlotDescription",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_GetSlotDescription" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = CK_SLOT_INFO_GetSlotDescription(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_GetHardwareVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_GetHardwareVersion",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_GetHardwareVersion" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = CK_SLOT_INFO_GetHardwareVersion(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SLOT_INFO_GetFirmwareVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SLOT_INFO_GetFirmwareVersion",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SLOT_INFO_GetFirmwareVersion" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); result = CK_SLOT_INFO_GetFirmwareVersion(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_SLOT_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_SLOT_INFO")) SWIG_fail; result = (CK_SLOT_INFO *)new CK_SLOT_INFO(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_SLOT_INFO, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_SLOT_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SLOT_INFO *arg1 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_SLOT_INFO",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SLOT_INFO, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_SLOT_INFO" "', argument " "1"" of type '" "CK_SLOT_INFO *""'"); } arg1 = reinterpret_cast< CK_SLOT_INFO * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_SLOT_INFO_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_SLOT_INFO, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_flags_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_flags_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->flags); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulMaxSessionCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulMaxSessionCount_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulMaxSessionCount_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulMaxSessionCount); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulSessionCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulSessionCount_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulSessionCount_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulSessionCount); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulMaxRwSessionCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulMaxRwSessionCount_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulMaxRwSessionCount_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulMaxRwSessionCount); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulRwSessionCount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulRwSessionCount_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulRwSessionCount_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulRwSessionCount); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulMaxPinLen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulMaxPinLen_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulMaxPinLen_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulMaxPinLen); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulMinPinLen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulMinPinLen_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulMinPinLen_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulMinPinLen); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulTotalPublicMemory_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulTotalPublicMemory_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulTotalPublicMemory_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulTotalPublicMemory); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulFreePublicMemory_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulFreePublicMemory_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulFreePublicMemory_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulFreePublicMemory); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulTotalPrivateMemory_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulTotalPrivateMemory_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulTotalPrivateMemory_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulTotalPrivateMemory); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_ulFreePrivateMemory_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_ulFreePrivateMemory_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_ulFreePrivateMemory_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (unsigned long) ((arg1)->ulFreePrivateMemory); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_hardwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_hardwareVersion_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_hardwareVersion_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (CK_VERSION *)& ((arg1)->hardwareVersion); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_firmwareVersion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_VERSION *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_firmwareVersion_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_firmwareVersion_get" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = (CK_VERSION *)& ((arg1)->firmwareVersion); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_VERSION, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_GetLabel",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_GetLabel" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = CK_TOKEN_INFO_GetLabel(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_GetManufacturerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_GetManufacturerID",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_GetManufacturerID" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = CK_TOKEN_INFO_GetManufacturerID(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_GetModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_GetModel",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_GetModel" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = CK_TOKEN_INFO_GetModel(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_GetSerialNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_GetSerialNumber",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_GetSerialNumber" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = CK_TOKEN_INFO_GetSerialNumber(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_GetFirmwareVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_GetFirmwareVersion",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_GetFirmwareVersion" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = CK_TOKEN_INFO_GetFirmwareVersion(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_TOKEN_INFO_GetUtcTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_TOKEN_INFO_GetUtcTime",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_TOKEN_INFO_GetUtcTime" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); result = CK_TOKEN_INFO_GetUtcTime(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_TOKEN_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_TOKEN_INFO")) SWIG_fail; result = (CK_TOKEN_INFO *)new CK_TOKEN_INFO(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_TOKEN_INFO, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_TOKEN_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_TOKEN_INFO *arg1 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_TOKEN_INFO",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_TOKEN_INFO, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_TOKEN_INFO" "', argument " "1"" of type '" "CK_TOKEN_INFO *""'"); } arg1 = reinterpret_cast< CK_TOKEN_INFO * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_TOKEN_INFO_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_TOKEN_INFO, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_SESSION_INFO_slotID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_INFO *arg1 = (CK_SESSION_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_INFO_slotID_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_INFO_slotID_get" "', argument " "1"" of type '" "CK_SESSION_INFO *""'"); } arg1 = reinterpret_cast< CK_SESSION_INFO * >(argp1); result = (unsigned long) ((arg1)->slotID); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_INFO_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_INFO *arg1 = (CK_SESSION_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_INFO_state_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_INFO_state_get" "', argument " "1"" of type '" "CK_SESSION_INFO *""'"); } arg1 = reinterpret_cast< CK_SESSION_INFO * >(argp1); result = (unsigned long) ((arg1)->state); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_INFO_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_INFO *arg1 = (CK_SESSION_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_INFO_flags_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_INFO_flags_get" "', argument " "1"" of type '" "CK_SESSION_INFO *""'"); } arg1 = reinterpret_cast< CK_SESSION_INFO * >(argp1); result = (unsigned long) ((arg1)->flags); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_SESSION_INFO_ulDeviceError_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_INFO *arg1 = (CK_SESSION_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_SESSION_INFO_ulDeviceError_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_SESSION_INFO_ulDeviceError_get" "', argument " "1"" of type '" "CK_SESSION_INFO *""'"); } arg1 = reinterpret_cast< CK_SESSION_INFO * >(argp1); result = (unsigned long) ((arg1)->ulDeviceError); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_SESSION_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_INFO *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_SESSION_INFO")) SWIG_fail; result = (CK_SESSION_INFO *)new CK_SESSION_INFO(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_SESSION_INFO, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_SESSION_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_SESSION_INFO *arg1 = (CK_SESSION_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_SESSION_INFO",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_SESSION_INFO, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_SESSION_INFO" "', argument " "1"" of type '" "CK_SESSION_INFO *""'"); } arg1 = reinterpret_cast< CK_SESSION_INFO * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_SESSION_INFO_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_SESSION_INFO, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_DATE_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_DATE *arg1 = (CK_DATE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_DATE_GetYear",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_DATE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_DATE_GetYear" "', argument " "1"" of type '" "CK_DATE *""'"); } arg1 = reinterpret_cast< CK_DATE * >(argp1); result = CK_DATE_GetYear(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_DATE_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_DATE *arg1 = (CK_DATE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_DATE_GetMonth",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_DATE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_DATE_GetMonth" "', argument " "1"" of type '" "CK_DATE *""'"); } arg1 = reinterpret_cast< CK_DATE * >(argp1); result = CK_DATE_GetMonth(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_DATE_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_DATE *arg1 = (CK_DATE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_DATE_GetDay",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_DATE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_DATE_GetDay" "', argument " "1"" of type '" "CK_DATE *""'"); } arg1 = reinterpret_cast< CK_DATE * >(argp1); result = CK_DATE_GetDay(arg1); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_DATE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_DATE *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_DATE")) SWIG_fail; result = (CK_DATE *)new CK_DATE(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_DATE, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_DATE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_DATE *arg1 = (CK_DATE *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_DATE",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_DATE, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_DATE" "', argument " "1"" of type '" "CK_DATE *""'"); } arg1 = reinterpret_cast< CK_DATE * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_DATE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_DATE, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_MECHANISM_mechanism_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; unsigned long arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_MECHANISM_mechanism_set",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_mechanism_set" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_MECHANISM_mechanism_set" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); if (arg1) (arg1)->mechanism = arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_mechanism_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_MECHANISM_mechanism_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_mechanism_get" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); result = (unsigned long) ((arg1)->mechanism); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_pParameter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_MECHANISM_pParameter_set",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_pParameter_set" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CK_MECHANISM_pParameter_set" "', argument " "2"" of type '" "void *""'"); } if (arg1) (arg1)->pParameter = arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_pParameter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; void *result = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_MECHANISM_pParameter_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_pParameter_get" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); result = (void *) ((arg1)->pParameter); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_ulParameterLen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; unsigned long arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_MECHANISM_ulParameterLen_set",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_ulParameterLen_set" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_MECHANISM_ulParameterLen_set" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); if (arg1) (arg1)->ulParameterLen = arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_ulParameterLen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_MECHANISM_ulParameterLen_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_ulParameterLen_get" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); result = (unsigned long) ((arg1)->ulParameterLen); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_MECHANISM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_MECHANISM")) SWIG_fail; result = (CK_MECHANISM *)new_CK_MECHANISM(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_MECHANISM, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_MECHANISM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM *arg1 = (CK_MECHANISM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_MECHANISM",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_MECHANISM" "', argument " "1"" of type '" "CK_MECHANISM *""'"); } arg1 = reinterpret_cast< CK_MECHANISM * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_MECHANISM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_MECHANISM, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_MECHANISM_INFO_ulMinKeySize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM_INFO *arg1 = (CK_MECHANISM_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_MECHANISM_INFO_ulMinKeySize_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_INFO_ulMinKeySize_get" "', argument " "1"" of type '" "CK_MECHANISM_INFO *""'"); } arg1 = reinterpret_cast< CK_MECHANISM_INFO * >(argp1); result = (unsigned long) ((arg1)->ulMinKeySize); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_INFO_ulMaxKeySize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM_INFO *arg1 = (CK_MECHANISM_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_MECHANISM_INFO_ulMaxKeySize_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_INFO_ulMaxKeySize_get" "', argument " "1"" of type '" "CK_MECHANISM_INFO *""'"); } arg1 = reinterpret_cast< CK_MECHANISM_INFO * >(argp1); result = (unsigned long) ((arg1)->ulMaxKeySize); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_MECHANISM_INFO_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM_INFO *arg1 = (CK_MECHANISM_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_MECHANISM_INFO_flags_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM_INFO, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_MECHANISM_INFO_flags_get" "', argument " "1"" of type '" "CK_MECHANISM_INFO *""'"); } arg1 = reinterpret_cast< CK_MECHANISM_INFO * >(argp1); result = (unsigned long) ((arg1)->flags); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_new_CK_MECHANISM_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM_INFO *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_MECHANISM_INFO")) SWIG_fail; result = (CK_MECHANISM_INFO *)new CK_MECHANISM_INFO(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_MECHANISM_INFO, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_MECHANISM_INFO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_MECHANISM_INFO *arg1 = (CK_MECHANISM_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_MECHANISM_INFO",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_MECHANISM_INFO, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_MECHANISM_INFO" "', argument " "1"" of type '" "CK_MECHANISM_INFO *""'"); } arg1 = reinterpret_cast< CK_MECHANISM_INFO * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_MECHANISM_INFO_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_MECHANISM_INFO, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_new_CPKCS11Lib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CPKCS11Lib")) SWIG_fail; result = (CPKCS11Lib *)new CPKCS11Lib(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPKCS11Lib, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CPKCS11Lib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CPKCS11Lib",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPKCS11Lib" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; char *arg2 = (char *) 0 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; bool val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_Load",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_Load" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_Load" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); ecode3 = SWIG_AsVal_bool(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CPKCS11Lib_Load" "', argument " "3"" of type '" "bool""'"); } arg3 = static_cast< bool >(val3); result = (bool)(arg1)->Load((char const *)arg2,arg3); resultobj = SWIG_From_bool(static_cast< bool >(result)); if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_Unload(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:CPKCS11Lib_Unload",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_Unload" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); result = (bool)(arg1)->Unload(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"O:CPKCS11Lib_C_Initialize",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Initialize" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); result = (CK_RV)(arg1)->C_Initialize(); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"O:CPKCS11Lib_C_Finalize",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Finalize" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); result = (CK_RV)(arg1)->C_Finalize(); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; CK_INFO *arg2 = (CK_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OO:CPKCS11Lib_C_GetInfo",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetInfo" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CK_INFO, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GetInfo" "', argument " "2"" of type '" "CK_INFO *""'"); } arg2 = reinterpret_cast< CK_INFO * >(argp2); result = (CK_RV)(arg1)->C_GetInfo(arg2); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetSlotList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned char arg2 ; std::vector< long > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned char val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_GetSlotList",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetSlotList" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_GetSlotList" "', argument " "2"" of type '" "unsigned char""'"); } arg2 = static_cast< unsigned char >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetSlotList" "', argument " "3"" of type '" "std::vector< long > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetSlotList" "', argument " "3"" of type '" "std::vector< long > &""'"); } arg3 = reinterpret_cast< std::vector< long > * >(argp3); result = (CK_RV)(arg1)->C_GetSlotList(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetSlotInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; CK_SLOT_INFO *arg3 = (CK_SLOT_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_GetSlotInfo",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetSlotInfo" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_GetSlotInfo" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_SLOT_INFO, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetSlotInfo" "', argument " "3"" of type '" "CK_SLOT_INFO *""'"); } arg3 = reinterpret_cast< CK_SLOT_INFO * >(argp3); result = (CK_RV)(arg1)->C_GetSlotInfo(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetTokenInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; CK_TOKEN_INFO *arg3 = (CK_TOKEN_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_GetTokenInfo",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetTokenInfo" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_GetTokenInfo" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_TOKEN_INFO, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetTokenInfo" "', argument " "3"" of type '" "CK_TOKEN_INFO *""'"); } arg3 = reinterpret_cast< CK_TOKEN_INFO * >(argp3); result = (CK_RV)(arg1)->C_GetTokenInfo(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_InitToken(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; char *arg3 = (char *) 0 ; unsigned long arg4 ; char *arg5 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; int res3 ; char *buf3 = 0 ; size_t size3 = 0 ; int alloc3 = 0 ; int res5 ; char *buf5 = 0 ; int alloc5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_InitToken",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_InitToken" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_InitToken" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, &size3, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_InitToken" "', argument " "3"" of type '" "char *""'"); } arg3 = reinterpret_cast< char * >(buf3); arg4 = static_cast< unsigned long >(size3 - 1); res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CPKCS11Lib_C_InitToken" "', argument " "5"" of type '" "char const *""'"); } arg5 = reinterpret_cast< char * >(buf5); result = (CK_RV)(arg1)->C_InitToken(arg2,arg3,arg4,(char const *)arg5); { resultobj = PyInt_FromLong((long)result); } if (alloc3 == SWIG_NEWOBJ) delete[] buf3; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return resultobj; fail: if (alloc3 == SWIG_NEWOBJ) delete[] buf3; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_InitPIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; char *arg3 = (char *) 0 ; unsigned long arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; int res3 ; char *buf3 = 0 ; size_t size3 = 0 ; int alloc3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_InitPIN",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_InitPIN" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_InitPIN" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_InitPIN" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, &size3, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_InitPIN" "', argument " "3"" of type '" "char *""'"); } arg3 = reinterpret_cast< char * >(buf3); arg4 = static_cast< unsigned long >(size3 - 1); result = (CK_RV)(arg1)->C_InitPIN(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return resultobj; fail: if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_SetPIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; char *arg3 = (char *) 0 ; unsigned long arg4 ; char *arg5 = (char *) 0 ; unsigned long arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; int res3 ; char *buf3 = 0 ; size_t size3 = 0 ; int alloc3 = 0 ; int res5 ; char *buf5 = 0 ; size_t size5 = 0 ; int alloc5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_SetPIN",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_SetPIN" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_SetPIN" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SetPIN" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, &size3, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_SetPIN" "', argument " "3"" of type '" "char *""'"); } arg3 = reinterpret_cast< char * >(buf3); arg4 = static_cast< unsigned long >(size3 - 1); res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, &size5, &alloc5); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CPKCS11Lib_C_SetPIN" "', argument " "5"" of type '" "char *""'"); } arg5 = reinterpret_cast< char * >(buf5); arg6 = static_cast< unsigned long >(size5 - 1); result = (CK_RV)(arg1)->C_SetPIN(arg2,arg3,arg4,arg5,arg6); { resultobj = PyInt_FromLong((long)result); } if (alloc3 == SWIG_NEWOBJ) delete[] buf3; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return resultobj; fail: if (alloc3 == SWIG_NEWOBJ) delete[] buf3; if (alloc5 == SWIG_NEWOBJ) delete[] buf5; return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_OpenSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; unsigned long arg3 ; CK_SESSION_HANDLE *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; unsigned long val3 ; int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_OpenSession",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_OpenSession" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_OpenSession" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CPKCS11Lib_C_OpenSession" "', argument " "3"" of type '" "unsigned long""'"); } arg3 = static_cast< unsigned long >(val3); res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_SESSION_HANDLE, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_OpenSession" "', argument " "4"" of type '" "CK_SESSION_HANDLE &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_OpenSession" "', argument " "4"" of type '" "CK_SESSION_HANDLE &""'"); } arg4 = reinterpret_cast< CK_SESSION_HANDLE * >(argp4); result = (CK_RV)(arg1)->C_OpenSession(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_CloseSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OO:CPKCS11Lib_C_CloseSession",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_CloseSession" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_CloseSession" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_CloseSession" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } result = (CK_RV)(arg1)->C_CloseSession(arg2); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_CloseAllSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OO:CPKCS11Lib_C_CloseAllSessions",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_CloseAllSessions" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_CloseAllSessions" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); result = (CK_RV)(arg1)->C_CloseAllSessions(arg2); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetSessionInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_SESSION_INFO *arg3 = (CK_SESSION_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_GetSessionInfo",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetSessionInfo" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GetSessionInfo" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetSessionInfo" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_SESSION_INFO, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetSessionInfo" "', argument " "3"" of type '" "CK_SESSION_INFO *""'"); } arg3 = reinterpret_cast< CK_SESSION_INFO * >(argp3); result = (CK_RV)(arg1)->C_GetSessionInfo(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Login(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; unsigned long arg3 ; char *arg4 = (char *) 0 ; unsigned long arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; unsigned long val3 ; int ecode3 = 0 ; int res4 ; char *buf4 = 0 ; size_t size4 = 0 ; int alloc4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_Login",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Login" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Login" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Login" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CPKCS11Lib_C_Login" "', argument " "3"" of type '" "unsigned long""'"); } arg3 = static_cast< unsigned long >(val3); res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, &size4, &alloc4); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_Login" "', argument " "4"" of type '" "char *""'"); } arg4 = reinterpret_cast< char * >(buf4); arg5 = static_cast< unsigned long >(size4 - 1); result = (CK_RV)(arg1)->C_Login(arg2,arg3,arg4,arg5); { resultobj = PyInt_FromLong((long)result); } if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return resultobj; fail: if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Logout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OO:CPKCS11Lib_C_Logout",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Logout" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Logout" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Logout" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } result = (CK_RV)(arg1)->C_Logout(arg2); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_CreateObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< CK_ATTRIBUTE_SMART > arg3 ; CK_OBJECT_HANDLE *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_CreateObject",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_CreateObject" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_CreateObject" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_CreateObject" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_CreateObject" "', argument " "3"" of type '" "std::vector< CK_ATTRIBUTE_SMART >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_CreateObject" "', argument " "4"" of type '" "CK_OBJECT_HANDLE &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_CreateObject" "', argument " "4"" of type '" "CK_OBJECT_HANDLE &""'"); } arg4 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); result = (CK_RV)(arg1)->C_CreateObject(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DestroyObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_DestroyObject",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DestroyObject" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DestroyObject" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DestroyObject" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_DestroyObject" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DestroyObject" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp3); arg3 = *temp; if (SWIG_IsNewObj(res3)) delete temp; } } result = (CK_RV)(arg1)->C_DestroyObject(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetObjectSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg3 ; unsigned long *arg4 = (unsigned long *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_GetObjectSize",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetObjectSize" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GetObjectSize" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetObjectSize" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetObjectSize" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetObjectSize" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp3); arg3 = *temp; if (SWIG_IsNewObj(res3)) delete temp; } } res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_long, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_GetObjectSize" "', argument " "4"" of type '" "unsigned long *""'"); } arg4 = reinterpret_cast< unsigned long * >(argp4); result = (CK_RV)(arg1)->C_GetObjectSize(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetAttributeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg3 ; std::vector< CK_ATTRIBUTE_SMART > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_GetAttributeValue",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp3); arg3 = *temp; if (SWIG_IsNewObj(res3)) delete temp; } } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetAttributeValue" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART > &""'"); } arg4 = reinterpret_cast< std::vector< CK_ATTRIBUTE_SMART > * >(argp4); result = (CK_RV)(arg1)->C_GetAttributeValue(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_SetAttributeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg3 ; std::vector< CK_ATTRIBUTE_SMART > arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_SetAttributeValue",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_SetAttributeValue" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_SetAttributeValue" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SetAttributeValue" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_SetAttributeValue" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SetAttributeValue" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp3); arg3 = *temp; if (SWIG_IsNewObj(res3)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_SetAttributeValue" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART >""'"); } arg4 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_SetAttributeValue(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_FindObjectsInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< CK_ATTRIBUTE_SMART > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_FindObjectsInit",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_FindObjectsInit" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_FindObjectsInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_FindObjectsInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_FindObjectsInit" "', argument " "3"" of type '" "std::vector< CK_ATTRIBUTE_SMART > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_FindObjectsInit" "', argument " "3"" of type '" "std::vector< CK_ATTRIBUTE_SMART > &""'"); } arg3 = reinterpret_cast< std::vector< CK_ATTRIBUTE_SMART > * >(argp3); result = (CK_RV)(arg1)->C_FindObjectsInit(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_FindObjects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< CK_OBJECT_HANDLE > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_FindObjects",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_FindObjects" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_FindObjects" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_FindObjects" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_FindObjects" "', argument " "3"" of type '" "std::vector< CK_OBJECT_HANDLE > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_FindObjects" "', argument " "3"" of type '" "std::vector< CK_OBJECT_HANDLE > &""'"); } arg3 = reinterpret_cast< std::vector< CK_OBJECT_HANDLE > * >(argp3); result = (CK_RV)(arg1)->C_FindObjects(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_FindObjectsFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OO:CPKCS11Lib_C_FindObjectsFinal",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_FindObjectsFinal" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_FindObjectsFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_FindObjectsFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } result = (CK_RV)(arg1)->C_FindObjectsFinal(arg2); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_EncryptInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_EncryptInit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_EncryptInit" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_EncryptInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_EncryptInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_EncryptInit" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_EncryptInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_EncryptInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); arg4 = *temp; if (SWIG_IsNewObj(res4)) delete temp; } } result = (CK_RV)(arg1)->C_EncryptInit(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_Encrypt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Encrypt" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Encrypt" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Encrypt" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_Encrypt" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_Encrypt" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Encrypt" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } arg4 = reinterpret_cast< std::vector< unsigned char > * >(argp4); result = (CK_RV)(arg1)->C_Encrypt(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_EncryptUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_EncryptUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_EncryptUpdate" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_EncryptUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_EncryptUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_EncryptUpdate" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_EncryptUpdate" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_EncryptUpdate" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } arg4 = reinterpret_cast< std::vector< unsigned char > * >(argp4); result = (CK_RV)(arg1)->C_EncryptUpdate(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_EncryptFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_EncryptFinal",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_EncryptFinal" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_EncryptFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_EncryptFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_EncryptFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_EncryptFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } arg3 = reinterpret_cast< std::vector< unsigned char > * >(argp3); result = (CK_RV)(arg1)->C_EncryptFinal(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DecryptInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_DecryptInit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DecryptInit" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DecryptInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DecryptInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_DecryptInit" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_DecryptInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DecryptInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); arg4 = *temp; if (SWIG_IsNewObj(res4)) delete temp; } } result = (CK_RV)(arg1)->C_DecryptInit(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_Decrypt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Decrypt" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Decrypt" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Decrypt" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_Decrypt" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_Decrypt" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Decrypt" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } arg4 = reinterpret_cast< std::vector< unsigned char > * >(argp4); result = (CK_RV)(arg1)->C_Decrypt(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DecryptUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_DecryptUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DecryptUpdate" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DecryptUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DecryptUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_DecryptUpdate" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_DecryptUpdate" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DecryptUpdate" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } arg4 = reinterpret_cast< std::vector< unsigned char > * >(argp4); result = (CK_RV)(arg1)->C_DecryptUpdate(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DecryptFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_DecryptFinal",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DecryptFinal" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DecryptFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DecryptFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_DecryptFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DecryptFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } arg3 = reinterpret_cast< std::vector< unsigned char > * >(argp3); result = (CK_RV)(arg1)->C_DecryptFinal(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DigestInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_DigestInit",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DigestInit" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DigestInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DigestInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_DigestInit" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); result = (CK_RV)(arg1)->C_DigestInit(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Digest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_Digest",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Digest" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Digest" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Digest" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_Digest" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_Digest" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Digest" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } arg4 = reinterpret_cast< std::vector< unsigned char > * >(argp4); result = (CK_RV)(arg1)->C_Digest(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DigestUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_DigestUpdate",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DigestUpdate" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DigestUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DigestUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_DigestUpdate" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_DigestUpdate(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DigestKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_DigestKey",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DigestKey" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DigestKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DigestKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_DigestKey" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DigestKey" "', argument " "3"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp3); arg3 = *temp; if (SWIG_IsNewObj(res3)) delete temp; } } result = (CK_RV)(arg1)->C_DigestKey(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_DigestFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_DigestFinal",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_DigestFinal" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_DigestFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DigestFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_DigestFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_DigestFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } arg3 = reinterpret_cast< std::vector< unsigned char > * >(argp3); result = (CK_RV)(arg1)->C_DigestFinal(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_SignInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_SignInit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_SignInit" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_SignInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SignInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_SignInit" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_SignInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SignInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); arg4 = *temp; if (SWIG_IsNewObj(res4)) delete temp; } } result = (CK_RV)(arg1)->C_SignInit(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_Sign",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Sign" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Sign" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Sign" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_Sign" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_Sign" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Sign" "', argument " "4"" of type '" "std::vector< unsigned char > &""'"); } arg4 = reinterpret_cast< std::vector< unsigned char > * >(argp4); result = (CK_RV)(arg1)->C_Sign(arg2,arg3,*arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_SignUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_SignUpdate",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_SignUpdate" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_SignUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SignUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_SignUpdate" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_SignUpdate(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_SignFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_SignFinal",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_SignFinal" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_SignFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SignFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_SignFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SignFinal" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } arg3 = reinterpret_cast< std::vector< unsigned char > * >(argp3); result = (CK_RV)(arg1)->C_SignFinal(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_VerifyInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_VerifyInit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_VerifyInit" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_VerifyInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_VerifyInit" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_VerifyInit" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_VerifyInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_VerifyInit" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); arg4 = *temp; if (SWIG_IsNewObj(res4)) delete temp; } } result = (CK_RV)(arg1)->C_VerifyInit(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; std::vector< unsigned char > arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_Verify",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_Verify" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_Verify" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_Verify" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_Verify" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_Verify" "', argument " "4"" of type '" "std::vector< unsigned char >""'"); } arg4 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_Verify(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_VerifyUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_VerifyUpdate",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_VerifyUpdate" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_VerifyUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_VerifyUpdate" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_VerifyUpdate" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_VerifyUpdate(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_VerifyFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_VerifyFinal",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_VerifyFinal" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_VerifyFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_VerifyFinal" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_VerifyFinal" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_VerifyFinal(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GenerateKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; std::vector< CK_ATTRIBUTE_SMART > arg4 ; CK_OBJECT_HANDLE *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp5 = 0 ; int res5 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOOO:CPKCS11Lib_C_GenerateKey",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART >""'"); } arg4 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "5"" of type '" "CK_OBJECT_HANDLE &""'"); } if (!argp5) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateKey" "', argument " "5"" of type '" "CK_OBJECT_HANDLE &""'"); } arg5 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp5); result = (CK_RV)(arg1)->C_GenerateKey(arg2,arg3,arg4,*arg5); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GenerateKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; std::vector< CK_ATTRIBUTE_SMART > arg4 ; std::vector< CK_ATTRIBUTE_SMART > arg5 ; CK_OBJECT_HANDLE *arg6 = 0 ; CK_OBJECT_HANDLE *arg7 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp6 = 0 ; int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; PyObject * obj6 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CPKCS11Lib_C_GenerateKeyPair",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj3, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "4"" of type '" "std::vector< CK_ATTRIBUTE_SMART >""'"); } arg4 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj4, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "5"" of type '" "std::vector< CK_ATTRIBUTE_SMART >""'"); } arg5 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "6"" of type '" "CK_OBJECT_HANDLE &""'"); } if (!argp6) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "6"" of type '" "CK_OBJECT_HANDLE &""'"); } arg6 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp6); res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "7"" of type '" "CK_OBJECT_HANDLE &""'"); } if (!argp7) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateKeyPair" "', argument " "7"" of type '" "CK_OBJECT_HANDLE &""'"); } arg7 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp7); result = (CK_RV)(arg1)->C_GenerateKeyPair(arg2,arg3,arg4,arg5,*arg6,*arg7); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_WrapKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg4 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg5 ; std::vector< unsigned char > *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; void *argp5 ; int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CPKCS11Lib_C_WrapKey",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); arg4 = *temp; if (SWIG_IsNewObj(res4)) delete temp; } } { res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "5"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp5) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "5"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp5); arg5 = *temp; if (SWIG_IsNewObj(res5)) delete temp; } } res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "6"" of type '" "std::vector< unsigned char > &""'"); } if (!argp6) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_WrapKey" "', argument " "6"" of type '" "std::vector< unsigned char > &""'"); } arg6 = reinterpret_cast< std::vector< unsigned char > * >(argp6); result = (CK_RV)(arg1)->C_WrapKey(arg2,arg3,arg4,arg5,*arg6); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_UnwrapKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; CK_MECHANISM *arg3 = (CK_MECHANISM *) 0 ; SwigValueWrapper< CK_OBJECT_HANDLE > arg4 ; std::vector< unsigned char > arg5 ; std::vector< CK_ATTRIBUTE_SMART > arg6 ; CK_OBJECT_HANDLE *arg7 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 ; int res4 = 0 ; void *argp7 = 0 ; int res7 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; PyObject * obj4 = 0 ; PyObject * obj5 = 0 ; PyObject * obj6 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CPKCS11Lib_C_UnwrapKey",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CK_MECHANISM, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "3"" of type '" "CK_MECHANISM *""'"); } arg3 = reinterpret_cast< CK_MECHANISM * >(argp3); { res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } if (!argp4) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "4"" of type '" "CK_OBJECT_HANDLE""'"); } else { CK_OBJECT_HANDLE * temp = reinterpret_cast< CK_OBJECT_HANDLE * >(argp4); arg4 = *temp; if (SWIG_IsNewObj(res4)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj4, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "5"" of type '" "std::vector< unsigned char >""'"); } arg5 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj5, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "6"" of type '" "std::vector< CK_ATTRIBUTE_SMART >""'"); } arg6 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CK_OBJECT_HANDLE, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "7"" of type '" "CK_OBJECT_HANDLE &""'"); } if (!argp7) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_UnwrapKey" "', argument " "7"" of type '" "CK_OBJECT_HANDLE &""'"); } arg7 = reinterpret_cast< CK_OBJECT_HANDLE * >(argp7); result = (CK_RV)(arg1)->C_UnwrapKey(arg2,arg3,arg4,arg5,arg6,*arg7); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_SeedRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_SeedRandom",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_SeedRandom" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_SeedRandom" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_SeedRandom" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } { std::vector > *ptr = (std::vector > *)0; int res = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "CPKCS11Lib_C_SeedRandom" "', argument " "3"" of type '" "std::vector< unsigned char >""'"); } arg3 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } result = (CK_RV)(arg1)->C_SeedRandom(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GenerateRandom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; SwigValueWrapper< CK_SESSION_HANDLE > arg2 ; std::vector< unsigned char > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_GenerateRandom",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GenerateRandom" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); { res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CK_SESSION_HANDLE, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPKCS11Lib_C_GenerateRandom" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateRandom" "', argument " "2"" of type '" "CK_SESSION_HANDLE""'"); } else { CK_SESSION_HANDLE * temp = reinterpret_cast< CK_SESSION_HANDLE * >(argp2); arg2 = *temp; if (SWIG_IsNewObj(res2)) delete temp; } } res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GenerateRandom" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GenerateRandom" "', argument " "3"" of type '" "std::vector< unsigned char > &""'"); } arg3 = reinterpret_cast< std::vector< unsigned char > * >(argp3); result = (CK_RV)(arg1)->C_GenerateRandom(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_WaitForSlotEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; unsigned long *arg3 = (unsigned long *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; unsigned long temp3 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_WaitForSlotEvent",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_WaitForSlotEvent" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_WaitForSlotEvent" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_unsigned_long,0))))) { unsigned long val; int ecode = SWIG_AsVal_unsigned_SS_long(obj2, &val); if (!SWIG_IsOK(ecode)) { SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "CPKCS11Lib_C_WaitForSlotEvent" "', argument " "3"" of type '" "unsigned long""'"); } temp3 = static_cast< unsigned long >(val); arg3 = &temp3; res3 = SWIG_AddTmpMask(ecode); } result = (CK_RV)(arg1)->C_WaitForSlotEvent(arg2,arg3); { resultobj = PyInt_FromLong((long)result); } if (SWIG_IsTmpObj(res3)) { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_long((*arg3))); } else { int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_long, new_flags)); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetMechanismList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; std::vector< long > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOO:CPKCS11Lib_C_GetMechanismList",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetMechanismList" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_GetMechanismList" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPKCS11Lib_C_GetMechanismList" "', argument " "3"" of type '" "std::vector< long > &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPKCS11Lib_C_GetMechanismList" "', argument " "3"" of type '" "std::vector< long > &""'"); } arg3 = reinterpret_cast< std::vector< long > * >(argp3); result = (CK_RV)(arg1)->C_GetMechanismList(arg2,*arg3); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CPKCS11Lib_C_GetMechanismInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CPKCS11Lib *arg1 = (CPKCS11Lib *) 0 ; unsigned long arg2 ; unsigned long arg3 ; CK_MECHANISM_INFO *arg4 = (CK_MECHANISM_INFO *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; unsigned long val3 ; int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; CK_RV result; if (!PyArg_ParseTuple(args,(char *)"OOOO:CPKCS11Lib_C_GetMechanismInfo",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CPKCS11Lib, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPKCS11Lib_C_GetMechanismInfo" "', argument " "1"" of type '" "CPKCS11Lib *""'"); } arg1 = reinterpret_cast< CPKCS11Lib * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CPKCS11Lib_C_GetMechanismInfo" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CPKCS11Lib_C_GetMechanismInfo" "', argument " "3"" of type '" "unsigned long""'"); } arg3 = static_cast< unsigned long >(val3); res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CK_MECHANISM_INFO, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CPKCS11Lib_C_GetMechanismInfo" "', argument " "4"" of type '" "CK_MECHANISM_INFO *""'"); } arg4 = reinterpret_cast< CK_MECHANISM_INFO * >(argp4); result = (CK_RV)(arg1)->C_GetMechanismInfo(arg2,arg3,arg4); { resultobj = PyInt_FromLong((long)result); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *CPKCS11Lib_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CPKCS11Lib, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_Reset",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_Reset" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); (arg1)->Reset(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_ResetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_ResetValue",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_ResetValue" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); (arg1)->ResetValue(); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; long arg2 ; void *argp1 = 0 ; int res1 = 0 ; long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_ATTRIBUTE_SMART_Reserve",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_Reserve" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); ecode2 = SWIG_AsVal_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_ATTRIBUTE_SMART_Reserve" "', argument " "2"" of type '" "long""'"); } arg2 = static_cast< long >(val2); (arg1)->Reserve(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; unsigned long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_GetType",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_GetType" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (unsigned long)((CK_ATTRIBUTE_SMART const *)arg1)->GetType(); resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; unsigned long arg2 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OO:CK_ATTRIBUTE_SMART_SetType",&obj0,&obj1)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_SetType" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_ATTRIBUTE_SMART_SetType" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); (arg1)->SetType(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_GetLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; int result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_GetLen",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_GetLen" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (int)((CK_ATTRIBUTE_SMART const *)arg1)->GetLen(); resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_IsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_IsString",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_IsString" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (bool)((CK_ATTRIBUTE_SMART const *)arg1)->IsString(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_IsBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_IsBool",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_IsBool" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (bool)((CK_ATTRIBUTE_SMART const *)arg1)->IsBool(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_IsNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_IsNum",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_IsNum" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (bool)((CK_ATTRIBUTE_SMART const *)arg1)->IsNum(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_IsBin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_IsBin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_IsBin" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (bool)((CK_ATTRIBUTE_SMART const *)arg1)->IsBin(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; PyKCS11String result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_GetString",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_GetString" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = ((CK_ATTRIBUTE_SMART const *)arg1)->GetString(); { resultobj = PyString_FromStringAndSize((const char*)((&result)->m_str.c_str()),(int)((&result)->m_str.size())); } return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; unsigned long arg2 ; char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:CK_ATTRIBUTE_SMART_SetString",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_SetString" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_ATTRIBUTE_SMART_SetString" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CK_ATTRIBUTE_SMART_SetString" "', argument " "3"" of type '" "char const *""'"); } arg3 = reinterpret_cast< char * >(buf3); (arg1)->SetString(arg2,(char const *)arg3); resultobj = SWIG_Py_Void(); if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return resultobj; fail: if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_GetNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; long result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_GetNum",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_GetNum" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (long)((CK_ATTRIBUTE_SMART const *)arg1)->GetNum(); resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_SetNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; unsigned long arg2 ; unsigned long arg3 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; unsigned long val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:CK_ATTRIBUTE_SMART_SetNum",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_SetNum" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_ATTRIBUTE_SMART_SetNum" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CK_ATTRIBUTE_SMART_SetNum" "', argument " "3"" of type '" "unsigned long""'"); } arg3 = static_cast< unsigned long >(val3); (arg1)->SetNum(arg2,arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_GetBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; bool result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_GetBool",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_GetBool" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART const *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (bool)((CK_ATTRIBUTE_SMART const *)arg1)->GetBool(); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_SetBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; unsigned long arg2 ; bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:CK_ATTRIBUTE_SMART_SetBool",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_SetBool" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_ATTRIBUTE_SMART_SetBool" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); ecode3 = SWIG_AsVal_bool(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CK_ATTRIBUTE_SMART_SetBool" "', argument " "3"" of type '" "bool""'"); } arg3 = static_cast< bool >(val3); (arg1)->SetBool(arg2,arg3); resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_GetBin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; std::vector< unsigned char > result; if (!PyArg_ParseTuple(args,(char *)"O:CK_ATTRIBUTE_SMART_GetBin",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_GetBin" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); result = (arg1)->GetBin(); resultobj = swig::from(static_cast< std::vector > >(result)); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_CK_ATTRIBUTE_SMART_SetBin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; unsigned long arg2 ; std::vector< unsigned char > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; unsigned long val2 ; int ecode2 = 0 ; int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; if (!PyArg_ParseTuple(args,(char *)"OOO:CK_ATTRIBUTE_SMART_SetBin",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CK_ATTRIBUTE_SMART_SetBin" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CK_ATTRIBUTE_SMART_SetBin" "', argument " "2"" of type '" "unsigned long""'"); } arg2 = static_cast< unsigned long >(val2); { std::vector > *ptr = (std::vector > *)0; res3 = swig::asptr(obj2, &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CK_ATTRIBUTE_SMART_SetBin" "', argument " "3"" of type '" "std::vector< unsigned char > const &""'"); } if (!ptr) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CK_ATTRIBUTE_SMART_SetBin" "', argument " "3"" of type '" "std::vector< unsigned char > const &""'"); } arg3 = ptr; } (arg1)->SetBin(arg2,(std::vector< unsigned char > const &)*arg3); resultobj = SWIG_Py_Void(); if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } SWIGINTERN PyObject *_wrap_new_CK_ATTRIBUTE_SMART(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *result = 0 ; if (!PyArg_ParseTuple(args,(char *)":new_CK_ATTRIBUTE_SMART")) SWIG_fail; result = (CK_ATTRIBUTE_SMART *)new CK_ATTRIBUTE_SMART(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CK_ATTRIBUTE_SMART, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } SWIGINTERN PyObject *_wrap_delete_CK_ATTRIBUTE_SMART(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; CK_ATTRIBUTE_SMART *arg1 = (CK_ATTRIBUTE_SMART *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; if (!PyArg_ParseTuple(args,(char *)"O:delete_CK_ATTRIBUTE_SMART",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CK_ATTRIBUTE_SMART, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CK_ATTRIBUTE_SMART" "', argument " "1"" of type '" "CK_ATTRIBUTE_SMART *""'"); } arg1 = reinterpret_cast< CK_ATTRIBUTE_SMART * >(argp1); delete arg1; resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } SWIGINTERN PyObject *CK_ATTRIBUTE_SMART_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_CK_ATTRIBUTE_SMART, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } static PyMethodDef SwigMethods[] = { { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, { (char *)"cdata", _wrap_cdata, METH_VARARGS, NULL}, { (char *)"memmove", _wrap_memmove, METH_VARARGS, NULL}, { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL}, { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL}, { (char *)"ckintlist_iterator", _wrap_ckintlist_iterator, METH_VARARGS, NULL}, { (char *)"ckintlist___nonzero__", _wrap_ckintlist___nonzero__, METH_VARARGS, NULL}, { (char *)"ckintlist___bool__", _wrap_ckintlist___bool__, METH_VARARGS, NULL}, { (char *)"ckintlist___len__", _wrap_ckintlist___len__, METH_VARARGS, NULL}, { (char *)"ckintlist_pop", _wrap_ckintlist_pop, METH_VARARGS, NULL}, { (char *)"ckintlist___getslice__", _wrap_ckintlist___getslice__, METH_VARARGS, NULL}, { (char *)"ckintlist___setslice__", _wrap_ckintlist___setslice__, METH_VARARGS, NULL}, { (char *)"ckintlist___delslice__", _wrap_ckintlist___delslice__, METH_VARARGS, NULL}, { (char *)"ckintlist___delitem__", _wrap_ckintlist___delitem__, METH_VARARGS, NULL}, { (char *)"ckintlist___getitem__", _wrap_ckintlist___getitem__, METH_VARARGS, NULL}, { (char *)"ckintlist___setitem__", _wrap_ckintlist___setitem__, METH_VARARGS, NULL}, { (char *)"ckintlist_append", _wrap_ckintlist_append, METH_VARARGS, NULL}, { (char *)"ckintlist_empty", _wrap_ckintlist_empty, METH_VARARGS, NULL}, { (char *)"ckintlist_size", _wrap_ckintlist_size, METH_VARARGS, NULL}, { (char *)"ckintlist_clear", _wrap_ckintlist_clear, METH_VARARGS, NULL}, { (char *)"ckintlist_swap", _wrap_ckintlist_swap, METH_VARARGS, NULL}, { (char *)"ckintlist_get_allocator", _wrap_ckintlist_get_allocator, METH_VARARGS, NULL}, { (char *)"ckintlist_begin", _wrap_ckintlist_begin, METH_VARARGS, NULL}, { (char *)"ckintlist_end", _wrap_ckintlist_end, METH_VARARGS, NULL}, { (char *)"ckintlist_rbegin", _wrap_ckintlist_rbegin, METH_VARARGS, NULL}, { (char *)"ckintlist_rend", _wrap_ckintlist_rend, METH_VARARGS, NULL}, { (char *)"ckintlist_pop_back", _wrap_ckintlist_pop_back, METH_VARARGS, NULL}, { (char *)"ckintlist_erase", _wrap_ckintlist_erase, METH_VARARGS, NULL}, { (char *)"new_ckintlist", _wrap_new_ckintlist, METH_VARARGS, NULL}, { (char *)"ckintlist_push_back", _wrap_ckintlist_push_back, METH_VARARGS, NULL}, { (char *)"ckintlist_front", _wrap_ckintlist_front, METH_VARARGS, NULL}, { (char *)"ckintlist_back", _wrap_ckintlist_back, METH_VARARGS, NULL}, { (char *)"ckintlist_assign", _wrap_ckintlist_assign, METH_VARARGS, NULL}, { (char *)"ckintlist_resize", _wrap_ckintlist_resize, METH_VARARGS, NULL}, { (char *)"ckintlist_insert", _wrap_ckintlist_insert, METH_VARARGS, NULL}, { (char *)"ckintlist_reserve", _wrap_ckintlist_reserve, METH_VARARGS, NULL}, { (char *)"ckintlist_capacity", _wrap_ckintlist_capacity, METH_VARARGS, NULL}, { (char *)"delete_ckintlist", _wrap_delete_ckintlist, METH_VARARGS, NULL}, { (char *)"ckintlist_swigregister", ckintlist_swigregister, METH_VARARGS, NULL}, { (char *)"ckbytelist_iterator", _wrap_ckbytelist_iterator, METH_VARARGS, NULL}, { (char *)"ckbytelist___nonzero__", _wrap_ckbytelist___nonzero__, METH_VARARGS, NULL}, { (char *)"ckbytelist___bool__", _wrap_ckbytelist___bool__, METH_VARARGS, NULL}, { (char *)"ckbytelist___len__", _wrap_ckbytelist___len__, METH_VARARGS, NULL}, { (char *)"ckbytelist_pop", _wrap_ckbytelist_pop, METH_VARARGS, NULL}, { (char *)"ckbytelist___getslice__", _wrap_ckbytelist___getslice__, METH_VARARGS, NULL}, { (char *)"ckbytelist___setslice__", _wrap_ckbytelist___setslice__, METH_VARARGS, NULL}, { (char *)"ckbytelist___delslice__", _wrap_ckbytelist___delslice__, METH_VARARGS, NULL}, { (char *)"ckbytelist___delitem__", _wrap_ckbytelist___delitem__, METH_VARARGS, NULL}, { (char *)"ckbytelist___getitem__", _wrap_ckbytelist___getitem__, METH_VARARGS, NULL}, { (char *)"ckbytelist___setitem__", _wrap_ckbytelist___setitem__, METH_VARARGS, NULL}, { (char *)"ckbytelist_append", _wrap_ckbytelist_append, METH_VARARGS, NULL}, { (char *)"ckbytelist_empty", _wrap_ckbytelist_empty, METH_VARARGS, NULL}, { (char *)"ckbytelist_size", _wrap_ckbytelist_size, METH_VARARGS, NULL}, { (char *)"ckbytelist_clear", _wrap_ckbytelist_clear, METH_VARARGS, NULL}, { (char *)"ckbytelist_swap", _wrap_ckbytelist_swap, METH_VARARGS, NULL}, { (char *)"ckbytelist_get_allocator", _wrap_ckbytelist_get_allocator, METH_VARARGS, NULL}, { (char *)"ckbytelist_begin", _wrap_ckbytelist_begin, METH_VARARGS, NULL}, { (char *)"ckbytelist_end", _wrap_ckbytelist_end, METH_VARARGS, NULL}, { (char *)"ckbytelist_rbegin", _wrap_ckbytelist_rbegin, METH_VARARGS, NULL}, { (char *)"ckbytelist_rend", _wrap_ckbytelist_rend, METH_VARARGS, NULL}, { (char *)"ckbytelist_pop_back", _wrap_ckbytelist_pop_back, METH_VARARGS, NULL}, { (char *)"ckbytelist_erase", _wrap_ckbytelist_erase, METH_VARARGS, NULL}, { (char *)"new_ckbytelist", _wrap_new_ckbytelist, METH_VARARGS, NULL}, { (char *)"ckbytelist_push_back", _wrap_ckbytelist_push_back, METH_VARARGS, NULL}, { (char *)"ckbytelist_front", _wrap_ckbytelist_front, METH_VARARGS, NULL}, { (char *)"ckbytelist_back", _wrap_ckbytelist_back, METH_VARARGS, NULL}, { (char *)"ckbytelist_assign", _wrap_ckbytelist_assign, METH_VARARGS, NULL}, { (char *)"ckbytelist_resize", _wrap_ckbytelist_resize, METH_VARARGS, NULL}, { (char *)"ckbytelist_insert", _wrap_ckbytelist_insert, METH_VARARGS, NULL}, { (char *)"ckbytelist_reserve", _wrap_ckbytelist_reserve, METH_VARARGS, NULL}, { (char *)"ckbytelist_capacity", _wrap_ckbytelist_capacity, METH_VARARGS, NULL}, { (char *)"delete_ckbytelist", _wrap_delete_ckbytelist, METH_VARARGS, NULL}, { (char *)"ckbytelist_swigregister", ckbytelist_swigregister, METH_VARARGS, NULL}, { (char *)"ckattrlist_iterator", _wrap_ckattrlist_iterator, METH_VARARGS, NULL}, { (char *)"ckattrlist___nonzero__", _wrap_ckattrlist___nonzero__, METH_VARARGS, NULL}, { (char *)"ckattrlist___bool__", _wrap_ckattrlist___bool__, METH_VARARGS, NULL}, { (char *)"ckattrlist___len__", _wrap_ckattrlist___len__, METH_VARARGS, NULL}, { (char *)"ckattrlist_pop", _wrap_ckattrlist_pop, METH_VARARGS, NULL}, { (char *)"ckattrlist___getslice__", _wrap_ckattrlist___getslice__, METH_VARARGS, NULL}, { (char *)"ckattrlist___setslice__", _wrap_ckattrlist___setslice__, METH_VARARGS, NULL}, { (char *)"ckattrlist___delslice__", _wrap_ckattrlist___delslice__, METH_VARARGS, NULL}, { (char *)"ckattrlist___delitem__", _wrap_ckattrlist___delitem__, METH_VARARGS, NULL}, { (char *)"ckattrlist___getitem__", _wrap_ckattrlist___getitem__, METH_VARARGS, NULL}, { (char *)"ckattrlist___setitem__", _wrap_ckattrlist___setitem__, METH_VARARGS, NULL}, { (char *)"ckattrlist_append", _wrap_ckattrlist_append, METH_VARARGS, NULL}, { (char *)"ckattrlist_empty", _wrap_ckattrlist_empty, METH_VARARGS, NULL}, { (char *)"ckattrlist_size", _wrap_ckattrlist_size, METH_VARARGS, NULL}, { (char *)"ckattrlist_clear", _wrap_ckattrlist_clear, METH_VARARGS, NULL}, { (char *)"ckattrlist_swap", _wrap_ckattrlist_swap, METH_VARARGS, NULL}, { (char *)"ckattrlist_get_allocator", _wrap_ckattrlist_get_allocator, METH_VARARGS, NULL}, { (char *)"ckattrlist_begin", _wrap_ckattrlist_begin, METH_VARARGS, NULL}, { (char *)"ckattrlist_end", _wrap_ckattrlist_end, METH_VARARGS, NULL}, { (char *)"ckattrlist_rbegin", _wrap_ckattrlist_rbegin, METH_VARARGS, NULL}, { (char *)"ckattrlist_rend", _wrap_ckattrlist_rend, METH_VARARGS, NULL}, { (char *)"ckattrlist_pop_back", _wrap_ckattrlist_pop_back, METH_VARARGS, NULL}, { (char *)"ckattrlist_erase", _wrap_ckattrlist_erase, METH_VARARGS, NULL}, { (char *)"new_ckattrlist", _wrap_new_ckattrlist, METH_VARARGS, NULL}, { (char *)"ckattrlist_push_back", _wrap_ckattrlist_push_back, METH_VARARGS, NULL}, { (char *)"ckattrlist_front", _wrap_ckattrlist_front, METH_VARARGS, NULL}, { (char *)"ckattrlist_back", _wrap_ckattrlist_back, METH_VARARGS, NULL}, { (char *)"ckattrlist_assign", _wrap_ckattrlist_assign, METH_VARARGS, NULL}, { (char *)"ckattrlist_resize", _wrap_ckattrlist_resize, METH_VARARGS, NULL}, { (char *)"ckattrlist_insert", _wrap_ckattrlist_insert, METH_VARARGS, NULL}, { (char *)"ckattrlist_reserve", _wrap_ckattrlist_reserve, METH_VARARGS, NULL}, { (char *)"ckattrlist_capacity", _wrap_ckattrlist_capacity, METH_VARARGS, NULL}, { (char *)"delete_ckattrlist", _wrap_delete_ckattrlist, METH_VARARGS, NULL}, { (char *)"ckattrlist_swigregister", ckattrlist_swigregister, METH_VARARGS, NULL}, { (char *)"ckobjlist_iterator", _wrap_ckobjlist_iterator, METH_VARARGS, NULL}, { (char *)"ckobjlist___nonzero__", _wrap_ckobjlist___nonzero__, METH_VARARGS, NULL}, { (char *)"ckobjlist___bool__", _wrap_ckobjlist___bool__, METH_VARARGS, NULL}, { (char *)"ckobjlist___len__", _wrap_ckobjlist___len__, METH_VARARGS, NULL}, { (char *)"ckobjlist_pop", _wrap_ckobjlist_pop, METH_VARARGS, NULL}, { (char *)"ckobjlist___getslice__", _wrap_ckobjlist___getslice__, METH_VARARGS, NULL}, { (char *)"ckobjlist___setslice__", _wrap_ckobjlist___setslice__, METH_VARARGS, NULL}, { (char *)"ckobjlist___delslice__", _wrap_ckobjlist___delslice__, METH_VARARGS, NULL}, { (char *)"ckobjlist___delitem__", _wrap_ckobjlist___delitem__, METH_VARARGS, NULL}, { (char *)"ckobjlist___getitem__", _wrap_ckobjlist___getitem__, METH_VARARGS, NULL}, { (char *)"ckobjlist___setitem__", _wrap_ckobjlist___setitem__, METH_VARARGS, NULL}, { (char *)"ckobjlist_append", _wrap_ckobjlist_append, METH_VARARGS, NULL}, { (char *)"ckobjlist_empty", _wrap_ckobjlist_empty, METH_VARARGS, NULL}, { (char *)"ckobjlist_size", _wrap_ckobjlist_size, METH_VARARGS, NULL}, { (char *)"ckobjlist_clear", _wrap_ckobjlist_clear, METH_VARARGS, NULL}, { (char *)"ckobjlist_swap", _wrap_ckobjlist_swap, METH_VARARGS, NULL}, { (char *)"ckobjlist_get_allocator", _wrap_ckobjlist_get_allocator, METH_VARARGS, NULL}, { (char *)"ckobjlist_begin", _wrap_ckobjlist_begin, METH_VARARGS, NULL}, { (char *)"ckobjlist_end", _wrap_ckobjlist_end, METH_VARARGS, NULL}, { (char *)"ckobjlist_rbegin", _wrap_ckobjlist_rbegin, METH_VARARGS, NULL}, { (char *)"ckobjlist_rend", _wrap_ckobjlist_rend, METH_VARARGS, NULL}, { (char *)"ckobjlist_pop_back", _wrap_ckobjlist_pop_back, METH_VARARGS, NULL}, { (char *)"ckobjlist_erase", _wrap_ckobjlist_erase, METH_VARARGS, NULL}, { (char *)"new_ckobjlist", _wrap_new_ckobjlist, METH_VARARGS, NULL}, { (char *)"ckobjlist_push_back", _wrap_ckobjlist_push_back, METH_VARARGS, NULL}, { (char *)"ckobjlist_front", _wrap_ckobjlist_front, METH_VARARGS, NULL}, { (char *)"ckobjlist_back", _wrap_ckobjlist_back, METH_VARARGS, NULL}, { (char *)"ckobjlist_assign", _wrap_ckobjlist_assign, METH_VARARGS, NULL}, { (char *)"ckobjlist_resize", _wrap_ckobjlist_resize, METH_VARARGS, NULL}, { (char *)"ckobjlist_insert", _wrap_ckobjlist_insert, METH_VARARGS, NULL}, { (char *)"ckobjlist_reserve", _wrap_ckobjlist_reserve, METH_VARARGS, NULL}, { (char *)"ckobjlist_capacity", _wrap_ckobjlist_capacity, METH_VARARGS, NULL}, { (char *)"delete_ckobjlist", _wrap_delete_ckobjlist, METH_VARARGS, NULL}, { (char *)"ckobjlist_swigregister", ckobjlist_swigregister, METH_VARARGS, NULL}, { (char *)"new_CK_SESSION_HANDLE", _wrap_new_CK_SESSION_HANDLE, METH_VARARGS, NULL}, { (char *)"delete_CK_SESSION_HANDLE", _wrap_delete_CK_SESSION_HANDLE, METH_VARARGS, NULL}, { (char *)"CK_SESSION_HANDLE_assign", _wrap_CK_SESSION_HANDLE_assign, METH_VARARGS, NULL}, { (char *)"CK_SESSION_HANDLE_value", _wrap_CK_SESSION_HANDLE_value, METH_VARARGS, NULL}, { (char *)"CK_SESSION_HANDLE_cast", _wrap_CK_SESSION_HANDLE_cast, METH_VARARGS, NULL}, { (char *)"CK_SESSION_HANDLE_frompointer", _wrap_CK_SESSION_HANDLE_frompointer, METH_VARARGS, NULL}, { (char *)"CK_SESSION_HANDLE_swigregister", CK_SESSION_HANDLE_swigregister, METH_VARARGS, NULL}, { (char *)"new_CK_OBJECT_HANDLE", _wrap_new_CK_OBJECT_HANDLE, METH_VARARGS, NULL}, { (char *)"delete_CK_OBJECT_HANDLE", _wrap_delete_CK_OBJECT_HANDLE, METH_VARARGS, NULL}, { (char *)"CK_OBJECT_HANDLE_assign", _wrap_CK_OBJECT_HANDLE_assign, METH_VARARGS, NULL}, { (char *)"CK_OBJECT_HANDLE_value", _wrap_CK_OBJECT_HANDLE_value, METH_VARARGS, NULL}, { (char *)"CK_OBJECT_HANDLE_cast", _wrap_CK_OBJECT_HANDLE_cast, METH_VARARGS, NULL}, { (char *)"CK_OBJECT_HANDLE_frompointer", _wrap_CK_OBJECT_HANDLE_frompointer, METH_VARARGS, NULL}, { (char *)"CK_OBJECT_HANDLE_swigregister", CK_OBJECT_HANDLE_swigregister, METH_VARARGS, NULL}, { (char *)"new_byteArray", _wrap_new_byteArray, METH_VARARGS, NULL}, { (char *)"delete_byteArray", _wrap_delete_byteArray, METH_VARARGS, NULL}, { (char *)"byteArray___getitem__", _wrap_byteArray___getitem__, METH_VARARGS, NULL}, { (char *)"byteArray___setitem__", _wrap_byteArray___setitem__, METH_VARARGS, NULL}, { (char *)"byteArray_cast", _wrap_byteArray_cast, METH_VARARGS, NULL}, { (char *)"byteArray_frompointer", _wrap_byteArray_frompointer, METH_VARARGS, NULL}, { (char *)"byteArray_swigregister", byteArray_swigregister, METH_VARARGS, NULL}, { (char *)"CK_VERSION_major_get", _wrap_CK_VERSION_major_get, METH_VARARGS, NULL}, { (char *)"CK_VERSION_minor_get", _wrap_CK_VERSION_minor_get, METH_VARARGS, NULL}, { (char *)"new_CK_VERSION", _wrap_new_CK_VERSION, METH_VARARGS, NULL}, { (char *)"delete_CK_VERSION", _wrap_delete_CK_VERSION, METH_VARARGS, NULL}, { (char *)"CK_VERSION_swigregister", CK_VERSION_swigregister, METH_VARARGS, NULL}, { (char *)"CK_INFO_cryptokiVersion_get", _wrap_CK_INFO_cryptokiVersion_get, METH_VARARGS, NULL}, { (char *)"CK_INFO_manufacturerID_get", _wrap_CK_INFO_manufacturerID_get, METH_VARARGS, NULL}, { (char *)"CK_INFO_flags_get", _wrap_CK_INFO_flags_get, METH_VARARGS, NULL}, { (char *)"CK_INFO_libraryDescription_get", _wrap_CK_INFO_libraryDescription_get, METH_VARARGS, NULL}, { (char *)"CK_INFO_libraryVersion_get", _wrap_CK_INFO_libraryVersion_get, METH_VARARGS, NULL}, { (char *)"CK_INFO_GetManufacturerID", _wrap_CK_INFO_GetManufacturerID, METH_VARARGS, NULL}, { (char *)"CK_INFO_GetLibraryDescription", _wrap_CK_INFO_GetLibraryDescription, METH_VARARGS, NULL}, { (char *)"CK_INFO_GetLibraryVersion", _wrap_CK_INFO_GetLibraryVersion, METH_VARARGS, NULL}, { (char *)"new_CK_INFO", _wrap_new_CK_INFO, METH_VARARGS, NULL}, { (char *)"delete_CK_INFO", _wrap_delete_CK_INFO, METH_VARARGS, NULL}, { (char *)"CK_INFO_swigregister", CK_INFO_swigregister, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_flags_get", _wrap_CK_SLOT_INFO_flags_get, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_hardwareVersion_get", _wrap_CK_SLOT_INFO_hardwareVersion_get, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_firmwareVersion_get", _wrap_CK_SLOT_INFO_firmwareVersion_get, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_GetManufacturerID", _wrap_CK_SLOT_INFO_GetManufacturerID, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_GetSlotDescription", _wrap_CK_SLOT_INFO_GetSlotDescription, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_GetHardwareVersion", _wrap_CK_SLOT_INFO_GetHardwareVersion, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_GetFirmwareVersion", _wrap_CK_SLOT_INFO_GetFirmwareVersion, METH_VARARGS, NULL}, { (char *)"new_CK_SLOT_INFO", _wrap_new_CK_SLOT_INFO, METH_VARARGS, NULL}, { (char *)"delete_CK_SLOT_INFO", _wrap_delete_CK_SLOT_INFO, METH_VARARGS, NULL}, { (char *)"CK_SLOT_INFO_swigregister", CK_SLOT_INFO_swigregister, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_flags_get", _wrap_CK_TOKEN_INFO_flags_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulMaxSessionCount_get", _wrap_CK_TOKEN_INFO_ulMaxSessionCount_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulSessionCount_get", _wrap_CK_TOKEN_INFO_ulSessionCount_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulMaxRwSessionCount_get", _wrap_CK_TOKEN_INFO_ulMaxRwSessionCount_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulRwSessionCount_get", _wrap_CK_TOKEN_INFO_ulRwSessionCount_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulMaxPinLen_get", _wrap_CK_TOKEN_INFO_ulMaxPinLen_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulMinPinLen_get", _wrap_CK_TOKEN_INFO_ulMinPinLen_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulTotalPublicMemory_get", _wrap_CK_TOKEN_INFO_ulTotalPublicMemory_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulFreePublicMemory_get", _wrap_CK_TOKEN_INFO_ulFreePublicMemory_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulTotalPrivateMemory_get", _wrap_CK_TOKEN_INFO_ulTotalPrivateMemory_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_ulFreePrivateMemory_get", _wrap_CK_TOKEN_INFO_ulFreePrivateMemory_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_hardwareVersion_get", _wrap_CK_TOKEN_INFO_hardwareVersion_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_firmwareVersion_get", _wrap_CK_TOKEN_INFO_firmwareVersion_get, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_GetLabel", _wrap_CK_TOKEN_INFO_GetLabel, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_GetManufacturerID", _wrap_CK_TOKEN_INFO_GetManufacturerID, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_GetModel", _wrap_CK_TOKEN_INFO_GetModel, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_GetSerialNumber", _wrap_CK_TOKEN_INFO_GetSerialNumber, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_GetFirmwareVersion", _wrap_CK_TOKEN_INFO_GetFirmwareVersion, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_GetUtcTime", _wrap_CK_TOKEN_INFO_GetUtcTime, METH_VARARGS, NULL}, { (char *)"new_CK_TOKEN_INFO", _wrap_new_CK_TOKEN_INFO, METH_VARARGS, NULL}, { (char *)"delete_CK_TOKEN_INFO", _wrap_delete_CK_TOKEN_INFO, METH_VARARGS, NULL}, { (char *)"CK_TOKEN_INFO_swigregister", CK_TOKEN_INFO_swigregister, METH_VARARGS, NULL}, { (char *)"CK_SESSION_INFO_slotID_get", _wrap_CK_SESSION_INFO_slotID_get, METH_VARARGS, NULL}, { (char *)"CK_SESSION_INFO_state_get", _wrap_CK_SESSION_INFO_state_get, METH_VARARGS, NULL}, { (char *)"CK_SESSION_INFO_flags_get", _wrap_CK_SESSION_INFO_flags_get, METH_VARARGS, NULL}, { (char *)"CK_SESSION_INFO_ulDeviceError_get", _wrap_CK_SESSION_INFO_ulDeviceError_get, METH_VARARGS, NULL}, { (char *)"new_CK_SESSION_INFO", _wrap_new_CK_SESSION_INFO, METH_VARARGS, NULL}, { (char *)"delete_CK_SESSION_INFO", _wrap_delete_CK_SESSION_INFO, METH_VARARGS, NULL}, { (char *)"CK_SESSION_INFO_swigregister", CK_SESSION_INFO_swigregister, METH_VARARGS, NULL}, { (char *)"CK_DATE_GetYear", _wrap_CK_DATE_GetYear, METH_VARARGS, NULL}, { (char *)"CK_DATE_GetMonth", _wrap_CK_DATE_GetMonth, METH_VARARGS, NULL}, { (char *)"CK_DATE_GetDay", _wrap_CK_DATE_GetDay, METH_VARARGS, NULL}, { (char *)"new_CK_DATE", _wrap_new_CK_DATE, METH_VARARGS, NULL}, { (char *)"delete_CK_DATE", _wrap_delete_CK_DATE, METH_VARARGS, NULL}, { (char *)"CK_DATE_swigregister", CK_DATE_swigregister, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_mechanism_set", _wrap_CK_MECHANISM_mechanism_set, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_mechanism_get", _wrap_CK_MECHANISM_mechanism_get, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_pParameter_set", _wrap_CK_MECHANISM_pParameter_set, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_pParameter_get", _wrap_CK_MECHANISM_pParameter_get, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_ulParameterLen_set", _wrap_CK_MECHANISM_ulParameterLen_set, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_ulParameterLen_get", _wrap_CK_MECHANISM_ulParameterLen_get, METH_VARARGS, NULL}, { (char *)"new_CK_MECHANISM", _wrap_new_CK_MECHANISM, METH_VARARGS, NULL}, { (char *)"delete_CK_MECHANISM", _wrap_delete_CK_MECHANISM, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_swigregister", CK_MECHANISM_swigregister, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_INFO_ulMinKeySize_get", _wrap_CK_MECHANISM_INFO_ulMinKeySize_get, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_INFO_ulMaxKeySize_get", _wrap_CK_MECHANISM_INFO_ulMaxKeySize_get, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_INFO_flags_get", _wrap_CK_MECHANISM_INFO_flags_get, METH_VARARGS, NULL}, { (char *)"new_CK_MECHANISM_INFO", _wrap_new_CK_MECHANISM_INFO, METH_VARARGS, NULL}, { (char *)"delete_CK_MECHANISM_INFO", _wrap_delete_CK_MECHANISM_INFO, METH_VARARGS, NULL}, { (char *)"CK_MECHANISM_INFO_swigregister", CK_MECHANISM_INFO_swigregister, METH_VARARGS, NULL}, { (char *)"new_CPKCS11Lib", _wrap_new_CPKCS11Lib, METH_VARARGS, NULL}, { (char *)"delete_CPKCS11Lib", _wrap_delete_CPKCS11Lib, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_Load", _wrap_CPKCS11Lib_Load, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_Unload", _wrap_CPKCS11Lib_Unload, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Initialize", _wrap_CPKCS11Lib_C_Initialize, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Finalize", _wrap_CPKCS11Lib_C_Finalize, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetInfo", _wrap_CPKCS11Lib_C_GetInfo, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetSlotList", _wrap_CPKCS11Lib_C_GetSlotList, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetSlotInfo", _wrap_CPKCS11Lib_C_GetSlotInfo, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetTokenInfo", _wrap_CPKCS11Lib_C_GetTokenInfo, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_InitToken", _wrap_CPKCS11Lib_C_InitToken, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_InitPIN", _wrap_CPKCS11Lib_C_InitPIN, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_SetPIN", _wrap_CPKCS11Lib_C_SetPIN, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_OpenSession", _wrap_CPKCS11Lib_C_OpenSession, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_CloseSession", _wrap_CPKCS11Lib_C_CloseSession, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_CloseAllSessions", _wrap_CPKCS11Lib_C_CloseAllSessions, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetSessionInfo", _wrap_CPKCS11Lib_C_GetSessionInfo, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Login", _wrap_CPKCS11Lib_C_Login, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Logout", _wrap_CPKCS11Lib_C_Logout, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_CreateObject", _wrap_CPKCS11Lib_C_CreateObject, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DestroyObject", _wrap_CPKCS11Lib_C_DestroyObject, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetObjectSize", _wrap_CPKCS11Lib_C_GetObjectSize, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetAttributeValue", _wrap_CPKCS11Lib_C_GetAttributeValue, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_SetAttributeValue", _wrap_CPKCS11Lib_C_SetAttributeValue, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_FindObjectsInit", _wrap_CPKCS11Lib_C_FindObjectsInit, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_FindObjects", _wrap_CPKCS11Lib_C_FindObjects, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_FindObjectsFinal", _wrap_CPKCS11Lib_C_FindObjectsFinal, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_EncryptInit", _wrap_CPKCS11Lib_C_EncryptInit, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Encrypt", _wrap_CPKCS11Lib_C_Encrypt, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_EncryptUpdate", _wrap_CPKCS11Lib_C_EncryptUpdate, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_EncryptFinal", _wrap_CPKCS11Lib_C_EncryptFinal, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DecryptInit", _wrap_CPKCS11Lib_C_DecryptInit, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Decrypt", _wrap_CPKCS11Lib_C_Decrypt, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DecryptUpdate", _wrap_CPKCS11Lib_C_DecryptUpdate, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DecryptFinal", _wrap_CPKCS11Lib_C_DecryptFinal, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DigestInit", _wrap_CPKCS11Lib_C_DigestInit, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Digest", _wrap_CPKCS11Lib_C_Digest, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DigestUpdate", _wrap_CPKCS11Lib_C_DigestUpdate, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DigestKey", _wrap_CPKCS11Lib_C_DigestKey, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_DigestFinal", _wrap_CPKCS11Lib_C_DigestFinal, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_SignInit", _wrap_CPKCS11Lib_C_SignInit, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Sign", _wrap_CPKCS11Lib_C_Sign, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_SignUpdate", _wrap_CPKCS11Lib_C_SignUpdate, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_SignFinal", _wrap_CPKCS11Lib_C_SignFinal, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_VerifyInit", _wrap_CPKCS11Lib_C_VerifyInit, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_Verify", _wrap_CPKCS11Lib_C_Verify, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_VerifyUpdate", _wrap_CPKCS11Lib_C_VerifyUpdate, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_VerifyFinal", _wrap_CPKCS11Lib_C_VerifyFinal, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GenerateKey", _wrap_CPKCS11Lib_C_GenerateKey, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GenerateKeyPair", _wrap_CPKCS11Lib_C_GenerateKeyPair, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_WrapKey", _wrap_CPKCS11Lib_C_WrapKey, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_UnwrapKey", _wrap_CPKCS11Lib_C_UnwrapKey, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_SeedRandom", _wrap_CPKCS11Lib_C_SeedRandom, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GenerateRandom", _wrap_CPKCS11Lib_C_GenerateRandom, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_WaitForSlotEvent", _wrap_CPKCS11Lib_C_WaitForSlotEvent, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetMechanismList", _wrap_CPKCS11Lib_C_GetMechanismList, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_C_GetMechanismInfo", _wrap_CPKCS11Lib_C_GetMechanismInfo, METH_VARARGS, NULL}, { (char *)"CPKCS11Lib_swigregister", CPKCS11Lib_swigregister, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_Reset", _wrap_CK_ATTRIBUTE_SMART_Reset, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_ResetValue", _wrap_CK_ATTRIBUTE_SMART_ResetValue, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_Reserve", _wrap_CK_ATTRIBUTE_SMART_Reserve, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_GetType", _wrap_CK_ATTRIBUTE_SMART_GetType, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_SetType", _wrap_CK_ATTRIBUTE_SMART_SetType, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_GetLen", _wrap_CK_ATTRIBUTE_SMART_GetLen, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_IsString", _wrap_CK_ATTRIBUTE_SMART_IsString, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_IsBool", _wrap_CK_ATTRIBUTE_SMART_IsBool, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_IsNum", _wrap_CK_ATTRIBUTE_SMART_IsNum, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_IsBin", _wrap_CK_ATTRIBUTE_SMART_IsBin, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_GetString", _wrap_CK_ATTRIBUTE_SMART_GetString, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_SetString", _wrap_CK_ATTRIBUTE_SMART_SetString, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_GetNum", _wrap_CK_ATTRIBUTE_SMART_GetNum, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_SetNum", _wrap_CK_ATTRIBUTE_SMART_SetNum, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_GetBool", _wrap_CK_ATTRIBUTE_SMART_GetBool, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_SetBool", _wrap_CK_ATTRIBUTE_SMART_SetBool, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_GetBin", _wrap_CK_ATTRIBUTE_SMART_GetBin, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_SetBin", _wrap_CK_ATTRIBUTE_SMART_SetBin, METH_VARARGS, NULL}, { (char *)"new_CK_ATTRIBUTE_SMART", _wrap_new_CK_ATTRIBUTE_SMART, METH_VARARGS, NULL}, { (char *)"delete_CK_ATTRIBUTE_SMART", _wrap_delete_CK_ATTRIBUTE_SMART, METH_VARARGS, NULL}, { (char *)"CK_ATTRIBUTE_SMART_swigregister", CK_ATTRIBUTE_SMART_swigregister, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static void *_p_byteArrayTo_p_char(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((char *) ((byteArray *) x)); } static void *_p_CK_SESSION_HANDLETo_p_unsigned_long(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((unsigned long *) ((CK_SESSION_HANDLE *) x)); } static void *_p_CK_OBJECT_HANDLETo_p_unsigned_long(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((unsigned long *) ((CK_OBJECT_HANDLE *) x)); } static swig_type_info _swigt__p_CK_ATTRIBUTE_SMART = {"_p_CK_ATTRIBUTE_SMART", "CK_ATTRIBUTE_SMART *|vector< CK_ATTRIBUTE_SMART >::value_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_DATE = {"_p_CK_DATE", "CK_DATE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_INFO = {"_p_CK_INFO", "CK_INFO *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_MECHANISM = {"_p_CK_MECHANISM", "CK_MECHANISM *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_MECHANISM_INFO = {"_p_CK_MECHANISM_INFO", "CK_MECHANISM_INFO *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_OBJECT_HANDLE = {"_p_CK_OBJECT_HANDLE", "vector< CK_OBJECT_HANDLE >::value_type *|CK_OBJECT_HANDLE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_SESSION_HANDLE = {"_p_CK_SESSION_HANDLE", "CK_SESSION_HANDLE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_SESSION_INFO = {"_p_CK_SESSION_INFO", "CK_SESSION_INFO *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_SLOT_INFO = {"_p_CK_SLOT_INFO", "CK_SLOT_INFO *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_TOKEN_INFO = {"_p_CK_TOKEN_INFO", "CK_TOKEN_INFO *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CK_VERSION = {"_p_CK_VERSION", "CK_VERSION *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_CPKCS11Lib = {"_p_CPKCS11Lib", "CPKCS11Lib *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_byteArray = {"_p_byteArray", "byteArray *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__allocatorT_CK_ATTRIBUTE_SMART_t = {"_p_std__allocatorT_CK_ATTRIBUTE_SMART_t", "vector< CK_ATTRIBUTE_SMART >::allocator_type *|std::allocator< CK_ATTRIBUTE_SMART > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__allocatorT_CK_OBJECT_HANDLE_t = {"_p_std__allocatorT_CK_OBJECT_HANDLE_t", "vector< CK_OBJECT_HANDLE >::allocator_type *|std::allocator< CK_OBJECT_HANDLE > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__allocatorT_long_t = {"_p_std__allocatorT_long_t", "vector< long >::allocator_type *|std::allocator< long > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__allocatorT_unsigned_char_t = {"_p_std__allocatorT_unsigned_char_t", "vector< unsigned char >::allocator_type *|std::allocator< unsigned char > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t = {"_p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t", "std::vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *|vector< CK_ATTRIBUTE_SMART,std::allocator< CK_ATTRIBUTE_SMART > > *|vector< CK_ATTRIBUTE_SMART > *|std::vector< CK_ATTRIBUTE_SMART > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t = {"_p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t", "std::vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *|vector< CK_OBJECT_HANDLE > *|std::vector< CK_OBJECT_HANDLE > *|vector< CK_OBJECT_HANDLE,std::allocator< CK_OBJECT_HANDLE > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT__Tp__Alloc_t = {"_p_std__vectorT__Tp__Alloc_t", "std::vector< _Tp,_Alloc > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_long_std__allocatorT_long_t_t = {"_p_std__vectorT_long_std__allocatorT_long_t_t", "vector< long,std::allocator< long > > *|std::vector< long,std::allocator< long > > *|vector< long > *|std::vector< long > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t = {"_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t", "vector< unsigned char > *|std::vector< unsigned char > *|std::vector< unsigned char,std::allocator< unsigned char > > *|vector< unsigned char,std::allocator< unsigned char > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "CK_RV *|unsigned long *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_CK_ATTRIBUTE_SMART, &_swigt__p_CK_DATE, &_swigt__p_CK_INFO, &_swigt__p_CK_MECHANISM, &_swigt__p_CK_MECHANISM_INFO, &_swigt__p_CK_OBJECT_HANDLE, &_swigt__p_CK_SESSION_HANDLE, &_swigt__p_CK_SESSION_INFO, &_swigt__p_CK_SLOT_INFO, &_swigt__p_CK_TOKEN_INFO, &_swigt__p_CK_VERSION, &_swigt__p_CPKCS11Lib, &_swigt__p_allocator_type, &_swigt__p_byteArray, &_swigt__p_char, &_swigt__p_difference_type, &_swigt__p_p_PyObject, &_swigt__p_size_type, &_swigt__p_std__allocatorT_CK_ATTRIBUTE_SMART_t, &_swigt__p_std__allocatorT_CK_OBJECT_HANDLE_t, &_swigt__p_std__allocatorT_long_t, &_swigt__p_std__allocatorT_unsigned_char_t, &_swigt__p_std__invalid_argument, &_swigt__p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, &_swigt__p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, &_swigt__p_std__vectorT__Tp__Alloc_t, &_swigt__p_std__vectorT_long_std__allocatorT_long_t_t, &_swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, &_swigt__p_swig__SwigPyIterator, &_swigt__p_unsigned_char, &_swigt__p_unsigned_long, &_swigt__p_value_type, &_swigt__p_void, }; static swig_cast_info _swigc__p_CK_ATTRIBUTE_SMART[] = { {&_swigt__p_CK_ATTRIBUTE_SMART, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_DATE[] = { {&_swigt__p_CK_DATE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_INFO[] = { {&_swigt__p_CK_INFO, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_MECHANISM[] = { {&_swigt__p_CK_MECHANISM, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_MECHANISM_INFO[] = { {&_swigt__p_CK_MECHANISM_INFO, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_OBJECT_HANDLE[] = { {&_swigt__p_CK_OBJECT_HANDLE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_SESSION_HANDLE[] = { {&_swigt__p_CK_SESSION_HANDLE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_SESSION_INFO[] = { {&_swigt__p_CK_SESSION_INFO, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_SLOT_INFO[] = { {&_swigt__p_CK_SLOT_INFO, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_TOKEN_INFO[] = { {&_swigt__p_CK_TOKEN_INFO, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CK_VERSION[] = { {&_swigt__p_CK_VERSION, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_CPKCS11Lib[] = { {&_swigt__p_CPKCS11Lib, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_byteArray[] = { {&_swigt__p_byteArray, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_byteArray, _p_byteArrayTo_p_char, 0, 0}, {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__allocatorT_CK_ATTRIBUTE_SMART_t[] = { {&_swigt__p_std__allocatorT_CK_ATTRIBUTE_SMART_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__allocatorT_CK_OBJECT_HANDLE_t[] = { {&_swigt__p_std__allocatorT_CK_OBJECT_HANDLE_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__allocatorT_long_t[] = { {&_swigt__p_std__allocatorT_long_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__allocatorT_unsigned_char_t[] = { {&_swigt__p_std__allocatorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t[] = { {&_swigt__p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t[] = { {&_swigt__p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT__Tp__Alloc_t[] = { {&_swigt__p_std__vectorT__Tp__Alloc_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_long_std__allocatorT_long_t_t[] = { {&_swigt__p_std__vectorT_long_std__allocatorT_long_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t[] = { {&_swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0}, {&_swigt__p_CK_SESSION_HANDLE, _p_CK_SESSION_HANDLETo_p_unsigned_long, 0, 0}, {&_swigt__p_CK_OBJECT_HANDLE, _p_CK_OBJECT_HANDLETo_p_unsigned_long, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_CK_ATTRIBUTE_SMART, _swigc__p_CK_DATE, _swigc__p_CK_INFO, _swigc__p_CK_MECHANISM, _swigc__p_CK_MECHANISM_INFO, _swigc__p_CK_OBJECT_HANDLE, _swigc__p_CK_SESSION_HANDLE, _swigc__p_CK_SESSION_INFO, _swigc__p_CK_SLOT_INFO, _swigc__p_CK_TOKEN_INFO, _swigc__p_CK_VERSION, _swigc__p_CPKCS11Lib, _swigc__p_allocator_type, _swigc__p_byteArray, _swigc__p_char, _swigc__p_difference_type, _swigc__p_p_PyObject, _swigc__p_size_type, _swigc__p_std__allocatorT_CK_ATTRIBUTE_SMART_t, _swigc__p_std__allocatorT_CK_OBJECT_HANDLE_t, _swigc__p_std__allocatorT_long_t, _swigc__p_std__allocatorT_unsigned_char_t, _swigc__p_std__invalid_argument, _swigc__p_std__vectorT_CK_ATTRIBUTE_SMART_std__allocatorT_CK_ATTRIBUTE_SMART_t_t, _swigc__p_std__vectorT_CK_OBJECT_HANDLE_std__allocatorT_CK_OBJECT_HANDLE_t_t, _swigc__p_std__vectorT__Tp__Alloc_t, _swigc__p_std__vectorT_long_std__allocatorT_long_t_t, _swigc__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, _swigc__p_swig__SwigPyIterator, _swigc__p_unsigned_char, _swigc__p_unsigned_long, _swigc__p_value_type, _swigc__p_void, }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ static swig_const_info swig_const_table[] = { {0, 0, 0, 0.0, 0, 0}}; #ifdef __cplusplus } #endif /* ----------------------------------------------------------------------------- * Type initialization: * This problem is tough by the requirement that no dynamic * memory is used. Also, since swig_type_info structures store pointers to * swig_cast_info structures and swig_cast_info structures store pointers back * to swig_type_info structures, we need some lookup code at initialization. * The idea is that swig generates all the structures that are needed. * The runtime then collects these partially filled structures. * The SWIG_InitializeModule function takes these initial arrays out of * swig_module, and does all the lookup, filling in the swig_module.types * array with the correct data and linking the correct swig_cast_info * structures together. * * The generated swig_type_info structures are assigned staticly to an initial * array. We just loop through that array, and handle each type individually. * First we lookup if this type has been already loaded, and if so, use the * loaded structure instead of the generated one. Then we have to fill in the * cast linked list. The cast data is initially stored in something like a * two-dimensional array. Each row corresponds to a type (there are the same * number of rows as there are in the swig_type_initial array). Each entry in * a column is one of the swig_cast_info structures for that type. * The cast_initial array is actually an array of arrays, because each row has * a variable number of columns. So to actually build the cast linked list, * we find the array of casts associated with the type, and loop through it * adding the casts to the list. The one last trick we need to do is making * sure the type pointer in the swig_cast_info struct is correct. * * First off, we lookup the cast->type name to see if it is already loaded. * There are three cases to handle: * 1) If the cast->type has already been loaded AND the type we are adding * casting info to has not been loaded (it is in this module), THEN we * replace the cast->type pointer with the type pointer that has already * been loaded. * 2) If BOTH types (the one we are adding casting info to, and the * cast->type) are loaded, THEN the cast info has already been loaded by * the previous module so we just ignore it. * 3) Finally, if cast->type has not already been loaded, then we add that * swig_cast_info to the linked list (because the cast->type) pointer will * be correct. * ----------------------------------------------------------------------------- */ #ifdef __cplusplus extern "C" { #if 0 } /* c-mode */ #endif #endif #if 0 #define SWIGRUNTIME_DEBUG #endif SWIGRUNTIME void SWIG_InitializeModule(void *clientdata) { size_t i; swig_module_info *module_head, *iter; int found, init; clientdata = clientdata; /* check to see if the circular list has been setup, if not, set it up */ if (swig_module.next==0) { /* Initialize the swig_module */ swig_module.type_initial = swig_type_initial; swig_module.cast_initial = swig_cast_initial; swig_module.next = &swig_module; init = 1; } else { init = 0; } /* Try and load any already created modules */ module_head = SWIG_GetModule(clientdata); if (!module_head) { /* This is the first module loaded for this interpreter */ /* so set the swig module into the interpreter */ SWIG_SetModule(clientdata, &swig_module); module_head = &swig_module; } else { /* the interpreter has loaded a SWIG module, but has it loaded this one? */ found=0; iter=module_head; do { if (iter==&swig_module) { found=1; break; } iter=iter->next; } while (iter!= module_head); /* if the is found in the list, then all is done and we may leave */ if (found) return; /* otherwise we must add out module into the list */ swig_module.next = module_head->next; module_head->next = &swig_module; } /* When multiple interpeters are used, a module could have already been initialized in a different interpreter, but not yet have a pointer in this interpreter. In this case, we do not want to continue adding types... everything should be set up already */ if (init == 0) return; /* Now work on filling in swig_module.types */ #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: size %d\n", swig_module.size); #endif for (i = 0; i < swig_module.size; ++i) { swig_type_info *type = 0; swig_type_info *ret; swig_cast_info *cast; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); #endif /* if there is another module already loaded */ if (swig_module.next != &swig_module) { type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); } if (type) { /* Overwrite clientdata field */ #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: found type %s\n", type->name); #endif if (swig_module.type_initial[i]->clientdata) { type->clientdata = swig_module.type_initial[i]->clientdata; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); #endif } } else { type = swig_module.type_initial[i]; } /* Insert casting types */ cast = swig_module.cast_initial[i]; while (cast->type) { /* Don't need to add information already in the list */ ret = 0; #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); #endif if (swig_module.next != &swig_module) { ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); #ifdef SWIGRUNTIME_DEBUG if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); #endif } if (ret) { if (type == swig_module.type_initial[i]) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: skip old type %s\n", ret->name); #endif cast->type = ret; ret = 0; } else { /* Check for casting already in the list */ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); #ifdef SWIGRUNTIME_DEBUG if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); #endif if (!ocast) ret = 0; } } if (!ret) { #ifdef SWIGRUNTIME_DEBUG printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); #endif if (type->cast) { type->cast->prev = cast; cast->next = type->cast; } type->cast = cast; } cast++; } /* Set entry in modules->types array equal to the type */ swig_module.types[i] = type; } swig_module.types[i] = 0; #ifdef SWIGRUNTIME_DEBUG printf("**** SWIG_InitializeModule: Cast List ******\n"); for (i = 0; i < swig_module.size; ++i) { int j = 0; swig_cast_info *cast = swig_module.cast_initial[i]; printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); while (cast->type) { printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); cast++; ++j; } printf("---- Total casts: %d\n",j); } printf("**** SWIG_InitializeModule: Cast List ******\n"); #endif } /* This function will propagate the clientdata field of type to * any new swig_type_info structures that have been added into the list * of equivalent types. It is like calling * SWIG_TypeClientData(type, clientdata) a second time. */ SWIGRUNTIME void SWIG_PropagateClientData(void) { size_t i; swig_cast_info *equiv; static int init_run = 0; if (init_run) return; init_run = 1; for (i = 0; i < swig_module.size; i++) { if (swig_module.types[i]->clientdata) { equiv = swig_module.types[i]->cast; while (equiv) { if (!equiv->converter) { if (equiv->type && !equiv->type->clientdata) SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); } equiv = equiv->next; } } } } #ifdef __cplusplus #if 0 { /* c-mode */ #endif } #endif #ifdef __cplusplus extern "C" { #endif /* Python-specific SWIG API */ #define SWIG_newvarlink() SWIG_Python_newvarlink() #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) /* ----------------------------------------------------------------------------- * global variable support code. * ----------------------------------------------------------------------------- */ typedef struct swig_globalvar { char *name; /* Name of global variable */ PyObject *(*get_attr)(void); /* Return the current value */ int (*set_attr)(PyObject *); /* Set the value */ struct swig_globalvar *next; } swig_globalvar; typedef struct swig_varlinkobject { PyObject_HEAD swig_globalvar *vars; } swig_varlinkobject; SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { #if PY_VERSION_HEX >= 0x03000000 return PyUnicode_InternFromString(""); #else return PyString_FromString(""); #endif } SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v) { #if PY_VERSION_HEX >= 0x03000000 PyObject *str = PyUnicode_InternFromString("("); PyObject *tail; PyObject *joined; swig_globalvar *var; for (var = v->vars; var; var=var->next) { tail = PyUnicode_FromString(var->name); joined = PyUnicode_Concat(str, tail); Py_DecRef(str); Py_DecRef(tail); str = joined; if (var->next) { tail = PyUnicode_InternFromString(", "); joined = PyUnicode_Concat(str, tail); Py_DecRef(str); Py_DecRef(tail); str = joined; } } tail = PyUnicode_InternFromString(")"); joined = PyUnicode_Concat(str, tail); Py_DecRef(str); Py_DecRef(tail); str = joined; #else PyObject *str = PyString_FromString("("); swig_globalvar *var; for (var = v->vars; var; var=var->next) { PyString_ConcatAndDel(&str,PyString_FromString(var->name)); if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); } PyString_ConcatAndDel(&str,PyString_FromString(")")); #endif return str; } SWIGINTERN int swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { char *tmp; PyObject *str = swig_varlink_str(v); fprintf(fp,"Swig global variables "); fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); SWIG_Python_str_DelForPy3(tmp); Py_DECREF(str); return 0; } SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v) { swig_globalvar *var = v->vars; while (var) { swig_globalvar *n = var->next; free(var->name); free(var); var = n; } } SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n) { PyObject *res = NULL; swig_globalvar *var = v->vars; while (var) { if (strcmp(var->name,n) == 0) { res = (*var->get_attr)(); break; } var = var->next; } if (res == NULL && !PyErr_Occurred()) { PyErr_SetString(PyExc_NameError,"Unknown C global variable"); } return res; } SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { int res = 1; swig_globalvar *var = v->vars; while (var) { if (strcmp(var->name,n) == 0) { res = (*var->set_attr)(p); break; } var = var->next; } if (res == 1 && !PyErr_Occurred()) { PyErr_SetString(PyExc_NameError,"Unknown C global variable"); } return res; } SWIGINTERN PyTypeObject* swig_varlink_type(void) { static char varlink__doc__[] = "Swig var link object"; static PyTypeObject varlink_type; static int type_init = 0; if (!type_init) { const PyTypeObject tmp = { /* PyObject header changed in Python 3 */ #if PY_VERSION_HEX >= 0x03000000 PyVarObject_HEAD_INIT(NULL, 0) #else PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif (char *)"swigvarlink", /* tp_name */ sizeof(swig_varlinkobject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) swig_varlink_dealloc, /* tp_dealloc */ (printfunc) swig_varlink_print, /* tp_print */ (getattrfunc) swig_varlink_getattr, /* tp_getattr */ (setattrfunc) swig_varlink_setattr, /* tp_setattr */ 0, /* tp_compare */ (reprfunc) swig_varlink_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ (reprfunc) swig_varlink_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ 0, /* tp_flags */ varlink__doc__, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ #endif #if PY_VERSION_HEX >= 0x02060000 0, /* tp_version */ #endif #ifdef COUNT_ALLOCS 0,0,0,0 /* tp_alloc -> tp_next */ #endif }; varlink_type = tmp; type_init = 1; #if PY_VERSION_HEX < 0x02020000 varlink_type.ob_type = &PyType_Type; #else if (PyType_Ready(&varlink_type) < 0) return NULL; #endif } return &varlink_type; } /* Create a variable linking object for use later */ SWIGINTERN PyObject * SWIG_Python_newvarlink(void) { swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); if (result) { result->vars = 0; } return ((PyObject*) result); } SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { swig_varlinkobject *v = (swig_varlinkobject *) p; swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); if (gv) { size_t size = strlen(name)+1; gv->name = (char *)malloc(size); if (gv->name) { strncpy(gv->name,name,size); gv->get_attr = get_attr; gv->set_attr = set_attr; gv->next = v->vars; } } v->vars = gv; } SWIGINTERN PyObject * SWIG_globals(void) { static PyObject *_SWIG_globals = 0; if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); return _SWIG_globals; } /* ----------------------------------------------------------------------------- * constants/methods manipulation * ----------------------------------------------------------------------------- */ /* Install Constants */ SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { PyObject *obj = 0; size_t i; for (i = 0; constants[i].type; ++i) { switch(constants[i].type) { case SWIG_PY_POINTER: obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); break; case SWIG_PY_BINARY: obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); break; default: obj = 0; break; } if (obj) { PyDict_SetItemString(d, constants[i].name, obj); Py_DECREF(obj); } } } /* -----------------------------------------------------------------------------*/ /* Fix SwigMethods to carry the callback ptrs when needed */ /* -----------------------------------------------------------------------------*/ SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) { size_t i; for (i = 0; methods[i].ml_name; ++i) { const char *c = methods[i].ml_doc; if (c && (c = strstr(c, "swig_ptr: "))) { int j; swig_const_info *ci = 0; const char *name = c + 10; for (j = 0; const_table[j].type; ++j) { if (strncmp(const_table[j].name, name, strlen(const_table[j].name)) == 0) { ci = &(const_table[j]); break; } } if (ci) { void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; if (ptr) { size_t shift = (ci->ptype) - types; swig_type_info *ty = types_initial[shift]; size_t ldoc = (c - methods[i].ml_doc); size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; char *ndoc = (char*)malloc(ldoc + lptr + 10); if (ndoc) { char *buff = ndoc; strncpy(buff, methods[i].ml_doc, ldoc); buff += ldoc; strncpy(buff, "swig_ptr: ", 10); buff += 10; SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); methods[i].ml_doc = ndoc; } } } } } } #ifdef __cplusplus } #endif /* -----------------------------------------------------------------------------* * Partial Init method * -----------------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" #endif SWIGEXPORT #if PY_VERSION_HEX >= 0x03000000 PyObject* #else void #endif SWIG_init(void) { PyObject *m, *d, *md; #if PY_VERSION_HEX >= 0x03000000 static struct PyModuleDef SWIG_module = { # if PY_VERSION_HEX >= 0x03020000 PyModuleDef_HEAD_INIT, # else { PyObject_HEAD_INIT(NULL) NULL, /* m_init */ 0, /* m_index */ NULL, /* m_copy */ }, # endif (char *) SWIG_name, NULL, -1, SwigMethods, NULL, NULL, NULL, NULL }; #endif #if defined(SWIGPYTHON_BUILTIN) static SwigPyClientData SwigPyObject_clientdata = { 0, 0, 0, 0, 0, 0, 0 }; static PyGetSetDef this_getset_def = { (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL }; static SwigPyGetSet thisown_getset_closure = { (PyCFunction) SwigPyObject_own, (PyCFunction) SwigPyObject_own }; static PyGetSetDef thisown_getset_def = { (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure }; PyObject *metatype_args; PyTypeObject *builtin_pytype; int builtin_base_count; swig_type_info *builtin_basetype; PyObject *tuple; PyGetSetDescrObject *static_getset; PyTypeObject *metatype; SwigPyClientData *cd; PyObject *public_interface, *public_symbol; PyObject *this_descr; PyObject *thisown_descr; int i; (void)builtin_pytype; (void)builtin_base_count; (void)builtin_basetype; (void)tuple; (void)static_getset; /* metatype is used to implement static member variables. */ metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type); assert(metatype_args); metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL); assert(metatype); Py_DECREF(metatype_args); metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro; assert(PyType_Ready(metatype) >= 0); #endif /* Fix SwigMethods to carry the callback ptrs when needed */ SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); #if PY_VERSION_HEX >= 0x03000000 m = PyModule_Create(&SWIG_module); #else m = Py_InitModule((char *) SWIG_name, SwigMethods); #endif md = d = PyModule_GetDict(m); SWIG_InitializeModule(0); #ifdef SWIGPYTHON_BUILTIN SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); assert(SwigPyObject_stype); cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; if (!cd) { SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce(); } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) { PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); # if PY_VERSION_HEX >= 0x03000000 return NULL; # else return; # endif } /* All objects have a 'this' attribute */ this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); (void)this_descr; /* All objects have a 'thisown' attribute */ thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); (void)thisown_descr; public_interface = PyList_New(0); public_symbol = 0; (void)public_symbol; PyDict_SetItemString(md, "__all__", public_interface); Py_DECREF(public_interface); for (i = 0; SwigMethods[i].ml_name != NULL; ++i) SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); for (i = 0; swig_const_table[i].name != 0; ++i) SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); #endif SWIG_InstallConstants(d,swig_const_table); SWIG_Python_SetConstant(d, "FALSE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "TRUE",SWIG_From_int(static_cast< int >(!(0)))); SWIG_Python_SetConstant(d, "CK_TRUE",SWIG_From_int(static_cast< int >(1))); SWIG_Python_SetConstant(d, "CK_FALSE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "CK_UNAVAILABLE_INFORMATION",SWIG_From_unsigned_SS_long(static_cast< unsigned long >((~0UL)))); SWIG_Python_SetConstant(d, "CK_EFFECTIVELY_INFINITE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "CK_INVALID_HANDLE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "CKN_SURRENDER",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "CKF_TOKEN_PRESENT",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKF_REMOVABLE_DEVICE",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKF_HW_SLOT",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKF_RNG",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKF_WRITE_PROTECTED",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKF_LOGIN_REQUIRED",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKF_USER_PIN_INITIALIZED",SWIG_From_int(static_cast< int >(0x00000008))); SWIG_Python_SetConstant(d, "CKF_RESTORE_KEY_NOT_NEEDED",SWIG_From_int(static_cast< int >(0x00000020))); SWIG_Python_SetConstant(d, "CKF_CLOCK_ON_TOKEN",SWIG_From_int(static_cast< int >(0x00000040))); SWIG_Python_SetConstant(d, "CKF_PROTECTED_AUTHENTICATION_PATH",SWIG_From_int(static_cast< int >(0x00000100))); SWIG_Python_SetConstant(d, "CKF_DUAL_CRYPTO_OPERATIONS",SWIG_From_int(static_cast< int >(0x00000200))); SWIG_Python_SetConstant(d, "CKF_TOKEN_INITIALIZED",SWIG_From_int(static_cast< int >(0x00000400))); SWIG_Python_SetConstant(d, "CKF_SECONDARY_AUTHENTICATION",SWIG_From_int(static_cast< int >(0x00000800))); SWIG_Python_SetConstant(d, "CKF_USER_PIN_COUNT_LOW",SWIG_From_int(static_cast< int >(0x00010000))); SWIG_Python_SetConstant(d, "CKF_USER_PIN_FINAL_TRY",SWIG_From_int(static_cast< int >(0x00020000))); SWIG_Python_SetConstant(d, "CKF_USER_PIN_LOCKED",SWIG_From_int(static_cast< int >(0x00040000))); SWIG_Python_SetConstant(d, "CKF_USER_PIN_TO_BE_CHANGED",SWIG_From_int(static_cast< int >(0x00080000))); SWIG_Python_SetConstant(d, "CKF_SO_PIN_COUNT_LOW",SWIG_From_int(static_cast< int >(0x00100000))); SWIG_Python_SetConstant(d, "CKF_SO_PIN_FINAL_TRY",SWIG_From_int(static_cast< int >(0x00200000))); SWIG_Python_SetConstant(d, "CKF_SO_PIN_LOCKED",SWIG_From_int(static_cast< int >(0x00400000))); SWIG_Python_SetConstant(d, "CKF_SO_PIN_TO_BE_CHANGED",SWIG_From_int(static_cast< int >(0x00800000))); SWIG_Python_SetConstant(d, "CKU_SO",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "CKU_USER",SWIG_From_int(static_cast< int >(1))); SWIG_Python_SetConstant(d, "CKS_RO_PUBLIC_SESSION",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "CKS_RO_USER_FUNCTIONS",SWIG_From_int(static_cast< int >(1))); SWIG_Python_SetConstant(d, "CKS_RW_PUBLIC_SESSION",SWIG_From_int(static_cast< int >(2))); SWIG_Python_SetConstant(d, "CKS_RW_USER_FUNCTIONS",SWIG_From_int(static_cast< int >(3))); SWIG_Python_SetConstant(d, "CKS_RW_SO_FUNCTIONS",SWIG_From_int(static_cast< int >(4))); SWIG_Python_SetConstant(d, "CKF_RW_SESSION",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKF_SERIAL_SESSION",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKO_DATA",SWIG_From_int(static_cast< int >(0x00000000))); SWIG_Python_SetConstant(d, "CKO_CERTIFICATE",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKO_PUBLIC_KEY",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKO_PRIVATE_KEY",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKO_SECRET_KEY",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKO_HW_FEATURE",SWIG_From_int(static_cast< int >(0x00000005))); SWIG_Python_SetConstant(d, "CKO_DOMAIN_PARAMETERS",SWIG_From_int(static_cast< int >(0x00000006))); SWIG_Python_SetConstant(d, "CKO_MECHANISM",SWIG_From_int(static_cast< int >(0x00000007))); SWIG_Python_SetConstant(d, "CKO_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKH_MONOTONIC_COUNTER",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKH_CLOCK",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKH_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKK_RSA",SWIG_From_int(static_cast< int >(0x00000000))); SWIG_Python_SetConstant(d, "CKK_DSA",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKK_DH",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKK_ECDSA",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKK_EC",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKK_X9_42_DH",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKK_KEA",SWIG_From_int(static_cast< int >(0x00000005))); SWIG_Python_SetConstant(d, "CKK_GENERIC_SECRET",SWIG_From_int(static_cast< int >(0x00000010))); SWIG_Python_SetConstant(d, "CKK_RC2",SWIG_From_int(static_cast< int >(0x00000011))); SWIG_Python_SetConstant(d, "CKK_RC4",SWIG_From_int(static_cast< int >(0x00000012))); SWIG_Python_SetConstant(d, "CKK_DES",SWIG_From_int(static_cast< int >(0x00000013))); SWIG_Python_SetConstant(d, "CKK_DES2",SWIG_From_int(static_cast< int >(0x00000014))); SWIG_Python_SetConstant(d, "CKK_DES3",SWIG_From_int(static_cast< int >(0x00000015))); SWIG_Python_SetConstant(d, "CKK_CAST",SWIG_From_int(static_cast< int >(0x00000016))); SWIG_Python_SetConstant(d, "CKK_CAST3",SWIG_From_int(static_cast< int >(0x00000017))); SWIG_Python_SetConstant(d, "CKK_CAST5",SWIG_From_int(static_cast< int >(0x00000018))); SWIG_Python_SetConstant(d, "CKK_CAST128",SWIG_From_int(static_cast< int >(0x00000018))); SWIG_Python_SetConstant(d, "CKK_RC5",SWIG_From_int(static_cast< int >(0x00000019))); SWIG_Python_SetConstant(d, "CKK_IDEA",SWIG_From_int(static_cast< int >(0x0000001A))); SWIG_Python_SetConstant(d, "CKK_SKIPJACK",SWIG_From_int(static_cast< int >(0x0000001B))); SWIG_Python_SetConstant(d, "CKK_BATON",SWIG_From_int(static_cast< int >(0x0000001C))); SWIG_Python_SetConstant(d, "CKK_JUNIPER",SWIG_From_int(static_cast< int >(0x0000001D))); SWIG_Python_SetConstant(d, "CKK_CDMF",SWIG_From_int(static_cast< int >(0x0000001E))); SWIG_Python_SetConstant(d, "CKK_AES",SWIG_From_int(static_cast< int >(0x0000001F))); SWIG_Python_SetConstant(d, "CKK_BLOWFISH",SWIG_From_int(static_cast< int >(0x00000020))); SWIG_Python_SetConstant(d, "CKK_TWOFISH",SWIG_From_int(static_cast< int >(0x00000021))); SWIG_Python_SetConstant(d, "CKK_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKC_X_509",SWIG_From_int(static_cast< int >(0x00000000))); SWIG_Python_SetConstant(d, "CKC_X_509_ATTR_CERT",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKC_WTLS",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKC_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKA_CLASS",SWIG_From_int(static_cast< int >(0x00000000))); SWIG_Python_SetConstant(d, "CKA_TOKEN",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKA_PRIVATE",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKA_LABEL",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKA_APPLICATION",SWIG_From_int(static_cast< int >(0x00000010))); SWIG_Python_SetConstant(d, "CKA_VALUE",SWIG_From_int(static_cast< int >(0x00000011))); SWIG_Python_SetConstant(d, "CKA_OBJECT_ID",SWIG_From_int(static_cast< int >(0x00000012))); SWIG_Python_SetConstant(d, "CKA_CERTIFICATE_TYPE",SWIG_From_int(static_cast< int >(0x00000080))); SWIG_Python_SetConstant(d, "CKA_ISSUER",SWIG_From_int(static_cast< int >(0x00000081))); SWIG_Python_SetConstant(d, "CKA_SERIAL_NUMBER",SWIG_From_int(static_cast< int >(0x00000082))); SWIG_Python_SetConstant(d, "CKA_AC_ISSUER",SWIG_From_int(static_cast< int >(0x00000083))); SWIG_Python_SetConstant(d, "CKA_OWNER",SWIG_From_int(static_cast< int >(0x00000084))); SWIG_Python_SetConstant(d, "CKA_ATTR_TYPES",SWIG_From_int(static_cast< int >(0x00000085))); SWIG_Python_SetConstant(d, "CKA_TRUSTED",SWIG_From_int(static_cast< int >(0x00000086))); SWIG_Python_SetConstant(d, "CKA_KEY_TYPE",SWIG_From_int(static_cast< int >(0x00000100))); SWIG_Python_SetConstant(d, "CKA_SUBJECT",SWIG_From_int(static_cast< int >(0x00000101))); SWIG_Python_SetConstant(d, "CKA_ID",SWIG_From_int(static_cast< int >(0x00000102))); SWIG_Python_SetConstant(d, "CKA_SENSITIVE",SWIG_From_int(static_cast< int >(0x00000103))); SWIG_Python_SetConstant(d, "CKA_ENCRYPT",SWIG_From_int(static_cast< int >(0x00000104))); SWIG_Python_SetConstant(d, "CKA_DECRYPT",SWIG_From_int(static_cast< int >(0x00000105))); SWIG_Python_SetConstant(d, "CKA_WRAP",SWIG_From_int(static_cast< int >(0x00000106))); SWIG_Python_SetConstant(d, "CKA_UNWRAP",SWIG_From_int(static_cast< int >(0x00000107))); SWIG_Python_SetConstant(d, "CKA_SIGN",SWIG_From_int(static_cast< int >(0x00000108))); SWIG_Python_SetConstant(d, "CKA_SIGN_RECOVER",SWIG_From_int(static_cast< int >(0x00000109))); SWIG_Python_SetConstant(d, "CKA_VERIFY",SWIG_From_int(static_cast< int >(0x0000010A))); SWIG_Python_SetConstant(d, "CKA_VERIFY_RECOVER",SWIG_From_int(static_cast< int >(0x0000010B))); SWIG_Python_SetConstant(d, "CKA_DERIVE",SWIG_From_int(static_cast< int >(0x0000010C))); SWIG_Python_SetConstant(d, "CKA_START_DATE",SWIG_From_int(static_cast< int >(0x00000110))); SWIG_Python_SetConstant(d, "CKA_END_DATE",SWIG_From_int(static_cast< int >(0x00000111))); SWIG_Python_SetConstant(d, "CKA_MODULUS",SWIG_From_int(static_cast< int >(0x00000120))); SWIG_Python_SetConstant(d, "CKA_MODULUS_BITS",SWIG_From_int(static_cast< int >(0x00000121))); SWIG_Python_SetConstant(d, "CKA_PUBLIC_EXPONENT",SWIG_From_int(static_cast< int >(0x00000122))); SWIG_Python_SetConstant(d, "CKA_PRIVATE_EXPONENT",SWIG_From_int(static_cast< int >(0x00000123))); SWIG_Python_SetConstant(d, "CKA_PRIME_1",SWIG_From_int(static_cast< int >(0x00000124))); SWIG_Python_SetConstant(d, "CKA_PRIME_2",SWIG_From_int(static_cast< int >(0x00000125))); SWIG_Python_SetConstant(d, "CKA_EXPONENT_1",SWIG_From_int(static_cast< int >(0x00000126))); SWIG_Python_SetConstant(d, "CKA_EXPONENT_2",SWIG_From_int(static_cast< int >(0x00000127))); SWIG_Python_SetConstant(d, "CKA_COEFFICIENT",SWIG_From_int(static_cast< int >(0x00000128))); SWIG_Python_SetConstant(d, "CKA_PRIME",SWIG_From_int(static_cast< int >(0x00000130))); SWIG_Python_SetConstant(d, "CKA_SUBPRIME",SWIG_From_int(static_cast< int >(0x00000131))); SWIG_Python_SetConstant(d, "CKA_BASE",SWIG_From_int(static_cast< int >(0x00000132))); SWIG_Python_SetConstant(d, "CKA_PRIME_BITS",SWIG_From_int(static_cast< int >(0x00000133))); SWIG_Python_SetConstant(d, "CKA_SUBPRIME_BITS",SWIG_From_int(static_cast< int >(0x00000134))); SWIG_Python_SetConstant(d, "CKA_SUB_PRIME_BITS",SWIG_From_int(static_cast< int >(0x00000134))); SWIG_Python_SetConstant(d, "CKA_VALUE_BITS",SWIG_From_int(static_cast< int >(0x00000160))); SWIG_Python_SetConstant(d, "CKA_VALUE_LEN",SWIG_From_int(static_cast< int >(0x00000161))); SWIG_Python_SetConstant(d, "CKA_EXTRACTABLE",SWIG_From_int(static_cast< int >(0x00000162))); SWIG_Python_SetConstant(d, "CKA_LOCAL",SWIG_From_int(static_cast< int >(0x00000163))); SWIG_Python_SetConstant(d, "CKA_NEVER_EXTRACTABLE",SWIG_From_int(static_cast< int >(0x00000164))); SWIG_Python_SetConstant(d, "CKA_ALWAYS_SENSITIVE",SWIG_From_int(static_cast< int >(0x00000165))); SWIG_Python_SetConstant(d, "CKA_KEY_GEN_MECHANISM",SWIG_From_int(static_cast< int >(0x00000166))); SWIG_Python_SetConstant(d, "CKA_MODIFIABLE",SWIG_From_int(static_cast< int >(0x00000170))); SWIG_Python_SetConstant(d, "CKA_ECDSA_PARAMS",SWIG_From_int(static_cast< int >(0x00000180))); SWIG_Python_SetConstant(d, "CKA_EC_PARAMS",SWIG_From_int(static_cast< int >(0x00000180))); SWIG_Python_SetConstant(d, "CKA_EC_POINT",SWIG_From_int(static_cast< int >(0x00000181))); SWIG_Python_SetConstant(d, "CKA_SECONDARY_AUTH",SWIG_From_int(static_cast< int >(0x00000200))); SWIG_Python_SetConstant(d, "CKA_AUTH_PIN_FLAGS",SWIG_From_int(static_cast< int >(0x00000201))); SWIG_Python_SetConstant(d, "CKA_HW_FEATURE_TYPE",SWIG_From_int(static_cast< int >(0x00000300))); SWIG_Python_SetConstant(d, "CKA_RESET_ON_INIT",SWIG_From_int(static_cast< int >(0x00000301))); SWIG_Python_SetConstant(d, "CKA_HAS_RESET",SWIG_From_int(static_cast< int >(0x00000302))); SWIG_Python_SetConstant(d, "CKA_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKM_RSA_PKCS_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00000000))); SWIG_Python_SetConstant(d, "CKM_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKM_RSA_9796",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKM_RSA_X_509",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKM_MD2_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKM_MD5_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000005))); SWIG_Python_SetConstant(d, "CKM_SHA1_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000006))); SWIG_Python_SetConstant(d, "CKM_RIPEMD128_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000007))); SWIG_Python_SetConstant(d, "CKM_RIPEMD160_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000008))); SWIG_Python_SetConstant(d, "CKM_RSA_PKCS_OAEP",SWIG_From_int(static_cast< int >(0x00000009))); SWIG_Python_SetConstant(d, "CKM_RSA_X9_31_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x0000000A))); SWIG_Python_SetConstant(d, "CKM_RSA_X9_31",SWIG_From_int(static_cast< int >(0x0000000B))); SWIG_Python_SetConstant(d, "CKM_SHA1_RSA_X9_31",SWIG_From_int(static_cast< int >(0x0000000C))); SWIG_Python_SetConstant(d, "CKM_RSA_PKCS_PSS",SWIG_From_int(static_cast< int >(0x0000000D))); SWIG_Python_SetConstant(d, "CKM_SHA1_RSA_PKCS_PSS",SWIG_From_int(static_cast< int >(0x0000000E))); SWIG_Python_SetConstant(d, "CKM_DSA_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00000010))); SWIG_Python_SetConstant(d, "CKM_DSA",SWIG_From_int(static_cast< int >(0x00000011))); SWIG_Python_SetConstant(d, "CKM_DSA_SHA1",SWIG_From_int(static_cast< int >(0x00000012))); SWIG_Python_SetConstant(d, "CKM_DH_PKCS_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00000020))); SWIG_Python_SetConstant(d, "CKM_DH_PKCS_DERIVE",SWIG_From_int(static_cast< int >(0x00000021))); SWIG_Python_SetConstant(d, "CKM_X9_42_DH_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00000030))); SWIG_Python_SetConstant(d, "CKM_X9_42_DH_DERIVE",SWIG_From_int(static_cast< int >(0x00000031))); SWIG_Python_SetConstant(d, "CKM_X9_42_DH_HYBRID_DERIVE",SWIG_From_int(static_cast< int >(0x00000032))); SWIG_Python_SetConstant(d, "CKM_X9_42_MQV_DERIVE",SWIG_From_int(static_cast< int >(0x00000033))); SWIG_Python_SetConstant(d, "CKM_SHA256_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000040))); SWIG_Python_SetConstant(d, "CKM_SHA384_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000041))); SWIG_Python_SetConstant(d, "CKM_SHA512_RSA_PKCS",SWIG_From_int(static_cast< int >(0x00000042))); SWIG_Python_SetConstant(d, "CKM_SHA256_RSA_PKCS_PSS",SWIG_From_int(static_cast< int >(0x00000043))); SWIG_Python_SetConstant(d, "CKM_SHA384_RSA_PKCS_PSS",SWIG_From_int(static_cast< int >(0x00000044))); SWIG_Python_SetConstant(d, "CKM_SHA512_RSA_PKCS_PSS",SWIG_From_int(static_cast< int >(0x00000045))); SWIG_Python_SetConstant(d, "CKM_RC2_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000100))); SWIG_Python_SetConstant(d, "CKM_RC2_ECB",SWIG_From_int(static_cast< int >(0x00000101))); SWIG_Python_SetConstant(d, "CKM_RC2_CBC",SWIG_From_int(static_cast< int >(0x00000102))); SWIG_Python_SetConstant(d, "CKM_RC2_MAC",SWIG_From_int(static_cast< int >(0x00000103))); SWIG_Python_SetConstant(d, "CKM_RC2_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000104))); SWIG_Python_SetConstant(d, "CKM_RC2_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000105))); SWIG_Python_SetConstant(d, "CKM_RC4_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000110))); SWIG_Python_SetConstant(d, "CKM_RC4",SWIG_From_int(static_cast< int >(0x00000111))); SWIG_Python_SetConstant(d, "CKM_DES_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000120))); SWIG_Python_SetConstant(d, "CKM_DES_ECB",SWIG_From_int(static_cast< int >(0x00000121))); SWIG_Python_SetConstant(d, "CKM_DES_CBC",SWIG_From_int(static_cast< int >(0x00000122))); SWIG_Python_SetConstant(d, "CKM_DES_MAC",SWIG_From_int(static_cast< int >(0x00000123))); SWIG_Python_SetConstant(d, "CKM_DES_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000124))); SWIG_Python_SetConstant(d, "CKM_DES_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000125))); SWIG_Python_SetConstant(d, "CKM_DES2_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000130))); SWIG_Python_SetConstant(d, "CKM_DES3_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000131))); SWIG_Python_SetConstant(d, "CKM_DES3_ECB",SWIG_From_int(static_cast< int >(0x00000132))); SWIG_Python_SetConstant(d, "CKM_DES3_CBC",SWIG_From_int(static_cast< int >(0x00000133))); SWIG_Python_SetConstant(d, "CKM_DES3_MAC",SWIG_From_int(static_cast< int >(0x00000134))); SWIG_Python_SetConstant(d, "CKM_DES3_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000135))); SWIG_Python_SetConstant(d, "CKM_DES3_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000136))); SWIG_Python_SetConstant(d, "CKM_CDMF_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000140))); SWIG_Python_SetConstant(d, "CKM_CDMF_ECB",SWIG_From_int(static_cast< int >(0x00000141))); SWIG_Python_SetConstant(d, "CKM_CDMF_CBC",SWIG_From_int(static_cast< int >(0x00000142))); SWIG_Python_SetConstant(d, "CKM_CDMF_MAC",SWIG_From_int(static_cast< int >(0x00000143))); SWIG_Python_SetConstant(d, "CKM_CDMF_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000144))); SWIG_Python_SetConstant(d, "CKM_CDMF_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000145))); SWIG_Python_SetConstant(d, "CKM_DES_OFB64",SWIG_From_int(static_cast< int >(0x00000150))); SWIG_Python_SetConstant(d, "CKM_DES_OFB8",SWIG_From_int(static_cast< int >(0x00000151))); SWIG_Python_SetConstant(d, "CKM_DES_CFB64",SWIG_From_int(static_cast< int >(0x00000152))); SWIG_Python_SetConstant(d, "CKM_DES_CFB8",SWIG_From_int(static_cast< int >(0x00000153))); SWIG_Python_SetConstant(d, "CKM_MD2",SWIG_From_int(static_cast< int >(0x00000200))); SWIG_Python_SetConstant(d, "CKM_MD2_HMAC",SWIG_From_int(static_cast< int >(0x00000201))); SWIG_Python_SetConstant(d, "CKM_MD2_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000202))); SWIG_Python_SetConstant(d, "CKM_MD5",SWIG_From_int(static_cast< int >(0x00000210))); SWIG_Python_SetConstant(d, "CKM_MD5_HMAC",SWIG_From_int(static_cast< int >(0x00000211))); SWIG_Python_SetConstant(d, "CKM_MD5_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000212))); SWIG_Python_SetConstant(d, "CKM_SHA_1",SWIG_From_int(static_cast< int >(0x00000220))); SWIG_Python_SetConstant(d, "CKM_SHA_1_HMAC",SWIG_From_int(static_cast< int >(0x00000221))); SWIG_Python_SetConstant(d, "CKM_SHA_1_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000222))); SWIG_Python_SetConstant(d, "CKM_RIPEMD128",SWIG_From_int(static_cast< int >(0x00000230))); SWIG_Python_SetConstant(d, "CKM_RIPEMD128_HMAC",SWIG_From_int(static_cast< int >(0x00000231))); SWIG_Python_SetConstant(d, "CKM_RIPEMD128_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000232))); SWIG_Python_SetConstant(d, "CKM_RIPEMD160",SWIG_From_int(static_cast< int >(0x00000240))); SWIG_Python_SetConstant(d, "CKM_RIPEMD160_HMAC",SWIG_From_int(static_cast< int >(0x00000241))); SWIG_Python_SetConstant(d, "CKM_RIPEMD160_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000242))); SWIG_Python_SetConstant(d, "CKM_SHA256",SWIG_From_int(static_cast< int >(0x00000250))); SWIG_Python_SetConstant(d, "CKM_SHA256_HMAC",SWIG_From_int(static_cast< int >(0x00000251))); SWIG_Python_SetConstant(d, "CKM_SHA256_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000252))); SWIG_Python_SetConstant(d, "CKM_SHA384",SWIG_From_int(static_cast< int >(0x00000260))); SWIG_Python_SetConstant(d, "CKM_SHA384_HMAC",SWIG_From_int(static_cast< int >(0x00000261))); SWIG_Python_SetConstant(d, "CKM_SHA384_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000262))); SWIG_Python_SetConstant(d, "CKM_SHA512",SWIG_From_int(static_cast< int >(0x00000270))); SWIG_Python_SetConstant(d, "CKM_SHA512_HMAC",SWIG_From_int(static_cast< int >(0x00000271))); SWIG_Python_SetConstant(d, "CKM_SHA512_HMAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000272))); SWIG_Python_SetConstant(d, "CKM_CAST_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000300))); SWIG_Python_SetConstant(d, "CKM_CAST_ECB",SWIG_From_int(static_cast< int >(0x00000301))); SWIG_Python_SetConstant(d, "CKM_CAST_CBC",SWIG_From_int(static_cast< int >(0x00000302))); SWIG_Python_SetConstant(d, "CKM_CAST_MAC",SWIG_From_int(static_cast< int >(0x00000303))); SWIG_Python_SetConstant(d, "CKM_CAST_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000304))); SWIG_Python_SetConstant(d, "CKM_CAST_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000305))); SWIG_Python_SetConstant(d, "CKM_CAST3_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000310))); SWIG_Python_SetConstant(d, "CKM_CAST3_ECB",SWIG_From_int(static_cast< int >(0x00000311))); SWIG_Python_SetConstant(d, "CKM_CAST3_CBC",SWIG_From_int(static_cast< int >(0x00000312))); SWIG_Python_SetConstant(d, "CKM_CAST3_MAC",SWIG_From_int(static_cast< int >(0x00000313))); SWIG_Python_SetConstant(d, "CKM_CAST3_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000314))); SWIG_Python_SetConstant(d, "CKM_CAST3_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000315))); SWIG_Python_SetConstant(d, "CKM_CAST5_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000320))); SWIG_Python_SetConstant(d, "CKM_CAST128_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000320))); SWIG_Python_SetConstant(d, "CKM_CAST5_ECB",SWIG_From_int(static_cast< int >(0x00000321))); SWIG_Python_SetConstant(d, "CKM_CAST128_ECB",SWIG_From_int(static_cast< int >(0x00000321))); SWIG_Python_SetConstant(d, "CKM_CAST5_CBC",SWIG_From_int(static_cast< int >(0x00000322))); SWIG_Python_SetConstant(d, "CKM_CAST128_CBC",SWIG_From_int(static_cast< int >(0x00000322))); SWIG_Python_SetConstant(d, "CKM_CAST5_MAC",SWIG_From_int(static_cast< int >(0x00000323))); SWIG_Python_SetConstant(d, "CKM_CAST128_MAC",SWIG_From_int(static_cast< int >(0x00000323))); SWIG_Python_SetConstant(d, "CKM_CAST5_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000324))); SWIG_Python_SetConstant(d, "CKM_CAST128_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000324))); SWIG_Python_SetConstant(d, "CKM_CAST5_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000325))); SWIG_Python_SetConstant(d, "CKM_CAST128_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000325))); SWIG_Python_SetConstant(d, "CKM_RC5_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000330))); SWIG_Python_SetConstant(d, "CKM_RC5_ECB",SWIG_From_int(static_cast< int >(0x00000331))); SWIG_Python_SetConstant(d, "CKM_RC5_CBC",SWIG_From_int(static_cast< int >(0x00000332))); SWIG_Python_SetConstant(d, "CKM_RC5_MAC",SWIG_From_int(static_cast< int >(0x00000333))); SWIG_Python_SetConstant(d, "CKM_RC5_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000334))); SWIG_Python_SetConstant(d, "CKM_RC5_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000335))); SWIG_Python_SetConstant(d, "CKM_IDEA_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000340))); SWIG_Python_SetConstant(d, "CKM_IDEA_ECB",SWIG_From_int(static_cast< int >(0x00000341))); SWIG_Python_SetConstant(d, "CKM_IDEA_CBC",SWIG_From_int(static_cast< int >(0x00000342))); SWIG_Python_SetConstant(d, "CKM_IDEA_MAC",SWIG_From_int(static_cast< int >(0x00000343))); SWIG_Python_SetConstant(d, "CKM_IDEA_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00000344))); SWIG_Python_SetConstant(d, "CKM_IDEA_CBC_PAD",SWIG_From_int(static_cast< int >(0x00000345))); SWIG_Python_SetConstant(d, "CKM_GENERIC_SECRET_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000350))); SWIG_Python_SetConstant(d, "CKM_CONCATENATE_BASE_AND_KEY",SWIG_From_int(static_cast< int >(0x00000360))); SWIG_Python_SetConstant(d, "CKM_CONCATENATE_BASE_AND_DATA",SWIG_From_int(static_cast< int >(0x00000362))); SWIG_Python_SetConstant(d, "CKM_CONCATENATE_DATA_AND_BASE",SWIG_From_int(static_cast< int >(0x00000363))); SWIG_Python_SetConstant(d, "CKM_XOR_BASE_AND_DATA",SWIG_From_int(static_cast< int >(0x00000364))); SWIG_Python_SetConstant(d, "CKM_EXTRACT_KEY_FROM_KEY",SWIG_From_int(static_cast< int >(0x00000365))); SWIG_Python_SetConstant(d, "CKM_SSL3_PRE_MASTER_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000370))); SWIG_Python_SetConstant(d, "CKM_SSL3_MASTER_KEY_DERIVE",SWIG_From_int(static_cast< int >(0x00000371))); SWIG_Python_SetConstant(d, "CKM_SSL3_KEY_AND_MAC_DERIVE",SWIG_From_int(static_cast< int >(0x00000372))); SWIG_Python_SetConstant(d, "CKM_SSL3_MASTER_KEY_DERIVE_DH",SWIG_From_int(static_cast< int >(0x00000373))); SWIG_Python_SetConstant(d, "CKM_TLS_PRE_MASTER_KEY_GEN",SWIG_From_int(static_cast< int >(0x00000374))); SWIG_Python_SetConstant(d, "CKM_TLS_MASTER_KEY_DERIVE",SWIG_From_int(static_cast< int >(0x00000375))); SWIG_Python_SetConstant(d, "CKM_TLS_KEY_AND_MAC_DERIVE",SWIG_From_int(static_cast< int >(0x00000376))); SWIG_Python_SetConstant(d, "CKM_TLS_MASTER_KEY_DERIVE_DH",SWIG_From_int(static_cast< int >(0x00000377))); SWIG_Python_SetConstant(d, "CKM_TLS_PRF",SWIG_From_int(static_cast< int >(0x00000378))); SWIG_Python_SetConstant(d, "CKM_SSL3_MD5_MAC",SWIG_From_int(static_cast< int >(0x00000380))); SWIG_Python_SetConstant(d, "CKM_SSL3_SHA1_MAC",SWIG_From_int(static_cast< int >(0x00000381))); SWIG_Python_SetConstant(d, "CKM_MD5_KEY_DERIVATION",SWIG_From_int(static_cast< int >(0x00000390))); SWIG_Python_SetConstant(d, "CKM_MD2_KEY_DERIVATION",SWIG_From_int(static_cast< int >(0x00000391))); SWIG_Python_SetConstant(d, "CKM_SHA1_KEY_DERIVATION",SWIG_From_int(static_cast< int >(0x00000392))); SWIG_Python_SetConstant(d, "CKM_SHA256_KEY_DERIVATION",SWIG_From_int(static_cast< int >(0x00000393))); SWIG_Python_SetConstant(d, "CKM_SHA384_KEY_DERIVATION",SWIG_From_int(static_cast< int >(0x00000394))); SWIG_Python_SetConstant(d, "CKM_SHA512_KEY_DERIVATION",SWIG_From_int(static_cast< int >(0x00000395))); SWIG_Python_SetConstant(d, "CKM_PBE_MD2_DES_CBC",SWIG_From_int(static_cast< int >(0x000003A0))); SWIG_Python_SetConstant(d, "CKM_PBE_MD5_DES_CBC",SWIG_From_int(static_cast< int >(0x000003A1))); SWIG_Python_SetConstant(d, "CKM_PBE_MD5_CAST_CBC",SWIG_From_int(static_cast< int >(0x000003A2))); SWIG_Python_SetConstant(d, "CKM_PBE_MD5_CAST3_CBC",SWIG_From_int(static_cast< int >(0x000003A3))); SWIG_Python_SetConstant(d, "CKM_PBE_MD5_CAST5_CBC",SWIG_From_int(static_cast< int >(0x000003A4))); SWIG_Python_SetConstant(d, "CKM_PBE_MD5_CAST128_CBC",SWIG_From_int(static_cast< int >(0x000003A4))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_CAST5_CBC",SWIG_From_int(static_cast< int >(0x000003A5))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_CAST128_CBC",SWIG_From_int(static_cast< int >(0x000003A5))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_RC4_128",SWIG_From_int(static_cast< int >(0x000003A6))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_RC4_40",SWIG_From_int(static_cast< int >(0x000003A7))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_DES3_EDE_CBC",SWIG_From_int(static_cast< int >(0x000003A8))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_DES2_EDE_CBC",SWIG_From_int(static_cast< int >(0x000003A9))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_RC2_128_CBC",SWIG_From_int(static_cast< int >(0x000003AA))); SWIG_Python_SetConstant(d, "CKM_PBE_SHA1_RC2_40_CBC",SWIG_From_int(static_cast< int >(0x000003AB))); SWIG_Python_SetConstant(d, "CKM_PKCS5_PBKD2",SWIG_From_int(static_cast< int >(0x000003B0))); SWIG_Python_SetConstant(d, "CKM_PBA_SHA1_WITH_SHA1_HMAC",SWIG_From_int(static_cast< int >(0x000003C0))); SWIG_Python_SetConstant(d, "CKM_WTLS_PRE_MASTER_KEY_GEN",SWIG_From_int(static_cast< int >(0x000003D0))); SWIG_Python_SetConstant(d, "CKM_WTLS_MASTER_KEY_DERIVE",SWIG_From_int(static_cast< int >(0x000003D1))); SWIG_Python_SetConstant(d, "CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC",SWIG_From_int(static_cast< int >(0x000003D2))); SWIG_Python_SetConstant(d, "CKM_WTLS_PRF",SWIG_From_int(static_cast< int >(0x000003D3))); SWIG_Python_SetConstant(d, "CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE",SWIG_From_int(static_cast< int >(0x000003D4))); SWIG_Python_SetConstant(d, "CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE",SWIG_From_int(static_cast< int >(0x000003D5))); SWIG_Python_SetConstant(d, "CKM_KEY_WRAP_LYNKS",SWIG_From_int(static_cast< int >(0x00000400))); SWIG_Python_SetConstant(d, "CKM_KEY_WRAP_SET_OAEP",SWIG_From_int(static_cast< int >(0x00000401))); SWIG_Python_SetConstant(d, "CKM_CMS_SIG",SWIG_From_int(static_cast< int >(0x00000500))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_KEY_GEN",SWIG_From_int(static_cast< int >(0x00001000))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_ECB64",SWIG_From_int(static_cast< int >(0x00001001))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_CBC64",SWIG_From_int(static_cast< int >(0x00001002))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_OFB64",SWIG_From_int(static_cast< int >(0x00001003))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_CFB64",SWIG_From_int(static_cast< int >(0x00001004))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_CFB32",SWIG_From_int(static_cast< int >(0x00001005))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_CFB16",SWIG_From_int(static_cast< int >(0x00001006))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_CFB8",SWIG_From_int(static_cast< int >(0x00001007))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_WRAP",SWIG_From_int(static_cast< int >(0x00001008))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_PRIVATE_WRAP",SWIG_From_int(static_cast< int >(0x00001009))); SWIG_Python_SetConstant(d, "CKM_SKIPJACK_RELAYX",SWIG_From_int(static_cast< int >(0x0000100a))); SWIG_Python_SetConstant(d, "CKM_KEA_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00001010))); SWIG_Python_SetConstant(d, "CKM_KEA_KEY_DERIVE",SWIG_From_int(static_cast< int >(0x00001011))); SWIG_Python_SetConstant(d, "CKM_FORTEZZA_TIMESTAMP",SWIG_From_int(static_cast< int >(0x00001020))); SWIG_Python_SetConstant(d, "CKM_BATON_KEY_GEN",SWIG_From_int(static_cast< int >(0x00001030))); SWIG_Python_SetConstant(d, "CKM_BATON_ECB128",SWIG_From_int(static_cast< int >(0x00001031))); SWIG_Python_SetConstant(d, "CKM_BATON_ECB96",SWIG_From_int(static_cast< int >(0x00001032))); SWIG_Python_SetConstant(d, "CKM_BATON_CBC128",SWIG_From_int(static_cast< int >(0x00001033))); SWIG_Python_SetConstant(d, "CKM_BATON_COUNTER",SWIG_From_int(static_cast< int >(0x00001034))); SWIG_Python_SetConstant(d, "CKM_BATON_SHUFFLE",SWIG_From_int(static_cast< int >(0x00001035))); SWIG_Python_SetConstant(d, "CKM_BATON_WRAP",SWIG_From_int(static_cast< int >(0x00001036))); SWIG_Python_SetConstant(d, "CKM_ECDSA_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00001040))); SWIG_Python_SetConstant(d, "CKM_EC_KEY_PAIR_GEN",SWIG_From_int(static_cast< int >(0x00001040))); SWIG_Python_SetConstant(d, "CKM_ECDSA",SWIG_From_int(static_cast< int >(0x00001041))); SWIG_Python_SetConstant(d, "CKM_ECDSA_SHA1",SWIG_From_int(static_cast< int >(0x00001042))); SWIG_Python_SetConstant(d, "CKM_ECDH1_DERIVE",SWIG_From_int(static_cast< int >(0x00001050))); SWIG_Python_SetConstant(d, "CKM_ECDH1_COFACTOR_DERIVE",SWIG_From_int(static_cast< int >(0x00001051))); SWIG_Python_SetConstant(d, "CKM_ECMQV_DERIVE",SWIG_From_int(static_cast< int >(0x00001052))); SWIG_Python_SetConstant(d, "CKM_JUNIPER_KEY_GEN",SWIG_From_int(static_cast< int >(0x00001060))); SWIG_Python_SetConstant(d, "CKM_JUNIPER_ECB128",SWIG_From_int(static_cast< int >(0x00001061))); SWIG_Python_SetConstant(d, "CKM_JUNIPER_CBC128",SWIG_From_int(static_cast< int >(0x00001062))); SWIG_Python_SetConstant(d, "CKM_JUNIPER_COUNTER",SWIG_From_int(static_cast< int >(0x00001063))); SWIG_Python_SetConstant(d, "CKM_JUNIPER_SHUFFLE",SWIG_From_int(static_cast< int >(0x00001064))); SWIG_Python_SetConstant(d, "CKM_JUNIPER_WRAP",SWIG_From_int(static_cast< int >(0x00001065))); SWIG_Python_SetConstant(d, "CKM_FASTHASH",SWIG_From_int(static_cast< int >(0x00001070))); SWIG_Python_SetConstant(d, "CKM_AES_KEY_GEN",SWIG_From_int(static_cast< int >(0x00001080))); SWIG_Python_SetConstant(d, "CKM_AES_ECB",SWIG_From_int(static_cast< int >(0x00001081))); SWIG_Python_SetConstant(d, "CKM_AES_CBC",SWIG_From_int(static_cast< int >(0x00001082))); SWIG_Python_SetConstant(d, "CKM_AES_MAC",SWIG_From_int(static_cast< int >(0x00001083))); SWIG_Python_SetConstant(d, "CKM_AES_MAC_GENERAL",SWIG_From_int(static_cast< int >(0x00001084))); SWIG_Python_SetConstant(d, "CKM_AES_CBC_PAD",SWIG_From_int(static_cast< int >(0x00001085))); SWIG_Python_SetConstant(d, "CKM_BLOWFISH_KEY_GEN",SWIG_From_int(static_cast< int >(0x00001090))); SWIG_Python_SetConstant(d, "CKM_BLOWFISH_CBC",SWIG_From_int(static_cast< int >(0x00001091))); SWIG_Python_SetConstant(d, "CKM_TWOFISH_KEY_GEN",SWIG_From_int(static_cast< int >(0x00001092))); SWIG_Python_SetConstant(d, "CKM_TWOFISH_CBC",SWIG_From_int(static_cast< int >(0x00001093))); SWIG_Python_SetConstant(d, "CKM_DES_ECB_ENCRYPT_DATA",SWIG_From_int(static_cast< int >(0x00001100))); SWIG_Python_SetConstant(d, "CKM_DES_CBC_ENCRYPT_DATA",SWIG_From_int(static_cast< int >(0x00001101))); SWIG_Python_SetConstant(d, "CKM_DES3_ECB_ENCRYPT_DATA",SWIG_From_int(static_cast< int >(0x00001102))); SWIG_Python_SetConstant(d, "CKM_DES3_CBC_ENCRYPT_DATA",SWIG_From_int(static_cast< int >(0x00001103))); SWIG_Python_SetConstant(d, "CKM_AES_ECB_ENCRYPT_DATA",SWIG_From_int(static_cast< int >(0x00001104))); SWIG_Python_SetConstant(d, "CKM_AES_CBC_ENCRYPT_DATA",SWIG_From_int(static_cast< int >(0x00001105))); SWIG_Python_SetConstant(d, "CKM_DSA_PARAMETER_GEN",SWIG_From_int(static_cast< int >(0x00002000))); SWIG_Python_SetConstant(d, "CKM_DH_PKCS_PARAMETER_GEN",SWIG_From_int(static_cast< int >(0x00002001))); SWIG_Python_SetConstant(d, "CKM_X9_42_DH_PARAMETER_GEN",SWIG_From_int(static_cast< int >(0x00002002))); SWIG_Python_SetConstant(d, "CKM_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKF_HW",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKF_ENCRYPT",SWIG_From_int(static_cast< int >(0x00000100))); SWIG_Python_SetConstant(d, "CKF_DECRYPT",SWIG_From_int(static_cast< int >(0x00000200))); SWIG_Python_SetConstant(d, "CKF_DIGEST",SWIG_From_int(static_cast< int >(0x00000400))); SWIG_Python_SetConstant(d, "CKF_SIGN",SWIG_From_int(static_cast< int >(0x00000800))); SWIG_Python_SetConstant(d, "CKF_SIGN_RECOVER",SWIG_From_int(static_cast< int >(0x00001000))); SWIG_Python_SetConstant(d, "CKF_VERIFY",SWIG_From_int(static_cast< int >(0x00002000))); SWIG_Python_SetConstant(d, "CKF_VERIFY_RECOVER",SWIG_From_int(static_cast< int >(0x00004000))); SWIG_Python_SetConstant(d, "CKF_GENERATE",SWIG_From_int(static_cast< int >(0x00008000))); SWIG_Python_SetConstant(d, "CKF_GENERATE_KEY_PAIR",SWIG_From_int(static_cast< int >(0x00010000))); SWIG_Python_SetConstant(d, "CKF_WRAP",SWIG_From_int(static_cast< int >(0x00020000))); SWIG_Python_SetConstant(d, "CKF_UNWRAP",SWIG_From_int(static_cast< int >(0x00040000))); SWIG_Python_SetConstant(d, "CKF_DERIVE",SWIG_From_int(static_cast< int >(0x00080000))); SWIG_Python_SetConstant(d, "CKF_EC_F_P",SWIG_From_int(static_cast< int >(0x00100000))); SWIG_Python_SetConstant(d, "CKF_EC_F_2M",SWIG_From_int(static_cast< int >(0x00200000))); SWIG_Python_SetConstant(d, "CKF_EC_ECPARAMETERS",SWIG_From_int(static_cast< int >(0x00400000))); SWIG_Python_SetConstant(d, "CKF_EC_NAMEDCURVE",SWIG_From_int(static_cast< int >(0x00800000))); SWIG_Python_SetConstant(d, "CKF_EC_UNCOMPRESS",SWIG_From_int(static_cast< int >(0x01000000))); SWIG_Python_SetConstant(d, "CKF_EC_COMPRESS",SWIG_From_int(static_cast< int >(0x02000000))); SWIG_Python_SetConstant(d, "CKF_EXTENSION",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKR_OK",SWIG_From_int(static_cast< int >(0x00000000))); SWIG_Python_SetConstant(d, "CKR_CANCEL",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKR_HOST_MEMORY",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKR_SLOT_ID_INVALID",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKR_GENERAL_ERROR",SWIG_From_int(static_cast< int >(0x00000005))); SWIG_Python_SetConstant(d, "CKR_FUNCTION_FAILED",SWIG_From_int(static_cast< int >(0x00000006))); SWIG_Python_SetConstant(d, "CKR_ARGUMENTS_BAD",SWIG_From_int(static_cast< int >(0x00000007))); SWIG_Python_SetConstant(d, "CKR_NO_EVENT",SWIG_From_int(static_cast< int >(0x00000008))); SWIG_Python_SetConstant(d, "CKR_NEED_TO_CREATE_THREADS",SWIG_From_int(static_cast< int >(0x00000009))); SWIG_Python_SetConstant(d, "CKR_CANT_LOCK",SWIG_From_int(static_cast< int >(0x0000000A))); SWIG_Python_SetConstant(d, "CKR_ATTRIBUTE_READ_ONLY",SWIG_From_int(static_cast< int >(0x00000010))); SWIG_Python_SetConstant(d, "CKR_ATTRIBUTE_SENSITIVE",SWIG_From_int(static_cast< int >(0x00000011))); SWIG_Python_SetConstant(d, "CKR_ATTRIBUTE_TYPE_INVALID",SWIG_From_int(static_cast< int >(0x00000012))); SWIG_Python_SetConstant(d, "CKR_ATTRIBUTE_VALUE_INVALID",SWIG_From_int(static_cast< int >(0x00000013))); SWIG_Python_SetConstant(d, "CKR_DATA_INVALID",SWIG_From_int(static_cast< int >(0x00000020))); SWIG_Python_SetConstant(d, "CKR_DATA_LEN_RANGE",SWIG_From_int(static_cast< int >(0x00000021))); SWIG_Python_SetConstant(d, "CKR_DEVICE_ERROR",SWIG_From_int(static_cast< int >(0x00000030))); SWIG_Python_SetConstant(d, "CKR_DEVICE_MEMORY",SWIG_From_int(static_cast< int >(0x00000031))); SWIG_Python_SetConstant(d, "CKR_DEVICE_REMOVED",SWIG_From_int(static_cast< int >(0x00000032))); SWIG_Python_SetConstant(d, "CKR_ENCRYPTED_DATA_INVALID",SWIG_From_int(static_cast< int >(0x00000040))); SWIG_Python_SetConstant(d, "CKR_ENCRYPTED_DATA_LEN_RANGE",SWIG_From_int(static_cast< int >(0x00000041))); SWIG_Python_SetConstant(d, "CKR_FUNCTION_CANCELED",SWIG_From_int(static_cast< int >(0x00000050))); SWIG_Python_SetConstant(d, "CKR_FUNCTION_NOT_PARALLEL",SWIG_From_int(static_cast< int >(0x00000051))); SWIG_Python_SetConstant(d, "CKR_FUNCTION_NOT_SUPPORTED",SWIG_From_int(static_cast< int >(0x00000054))); SWIG_Python_SetConstant(d, "CKR_KEY_HANDLE_INVALID",SWIG_From_int(static_cast< int >(0x00000060))); SWIG_Python_SetConstant(d, "CKR_KEY_SIZE_RANGE",SWIG_From_int(static_cast< int >(0x00000062))); SWIG_Python_SetConstant(d, "CKR_KEY_TYPE_INCONSISTENT",SWIG_From_int(static_cast< int >(0x00000063))); SWIG_Python_SetConstant(d, "CKR_KEY_NOT_NEEDED",SWIG_From_int(static_cast< int >(0x00000064))); SWIG_Python_SetConstant(d, "CKR_KEY_CHANGED",SWIG_From_int(static_cast< int >(0x00000065))); SWIG_Python_SetConstant(d, "CKR_KEY_NEEDED",SWIG_From_int(static_cast< int >(0x00000066))); SWIG_Python_SetConstant(d, "CKR_KEY_INDIGESTIBLE",SWIG_From_int(static_cast< int >(0x00000067))); SWIG_Python_SetConstant(d, "CKR_KEY_FUNCTION_NOT_PERMITTED",SWIG_From_int(static_cast< int >(0x00000068))); SWIG_Python_SetConstant(d, "CKR_KEY_NOT_WRAPPABLE",SWIG_From_int(static_cast< int >(0x00000069))); SWIG_Python_SetConstant(d, "CKR_KEY_UNEXTRACTABLE",SWIG_From_int(static_cast< int >(0x0000006A))); SWIG_Python_SetConstant(d, "CKR_MECHANISM_INVALID",SWIG_From_int(static_cast< int >(0x00000070))); SWIG_Python_SetConstant(d, "CKR_MECHANISM_PARAM_INVALID",SWIG_From_int(static_cast< int >(0x00000071))); SWIG_Python_SetConstant(d, "CKR_OBJECT_HANDLE_INVALID",SWIG_From_int(static_cast< int >(0x00000082))); SWIG_Python_SetConstant(d, "CKR_OPERATION_ACTIVE",SWIG_From_int(static_cast< int >(0x00000090))); SWIG_Python_SetConstant(d, "CKR_OPERATION_NOT_INITIALIZED",SWIG_From_int(static_cast< int >(0x00000091))); SWIG_Python_SetConstant(d, "CKR_PIN_INCORRECT",SWIG_From_int(static_cast< int >(0x000000A0))); SWIG_Python_SetConstant(d, "CKR_PIN_INVALID",SWIG_From_int(static_cast< int >(0x000000A1))); SWIG_Python_SetConstant(d, "CKR_PIN_LEN_RANGE",SWIG_From_int(static_cast< int >(0x000000A2))); SWIG_Python_SetConstant(d, "CKR_PIN_EXPIRED",SWIG_From_int(static_cast< int >(0x000000A3))); SWIG_Python_SetConstant(d, "CKR_PIN_LOCKED",SWIG_From_int(static_cast< int >(0x000000A4))); SWIG_Python_SetConstant(d, "CKR_SESSION_CLOSED",SWIG_From_int(static_cast< int >(0x000000B0))); SWIG_Python_SetConstant(d, "CKR_SESSION_COUNT",SWIG_From_int(static_cast< int >(0x000000B1))); SWIG_Python_SetConstant(d, "CKR_SESSION_HANDLE_INVALID",SWIG_From_int(static_cast< int >(0x000000B3))); SWIG_Python_SetConstant(d, "CKR_SESSION_PARALLEL_NOT_SUPPORTED",SWIG_From_int(static_cast< int >(0x000000B4))); SWIG_Python_SetConstant(d, "CKR_SESSION_READ_ONLY",SWIG_From_int(static_cast< int >(0x000000B5))); SWIG_Python_SetConstant(d, "CKR_SESSION_EXISTS",SWIG_From_int(static_cast< int >(0x000000B6))); SWIG_Python_SetConstant(d, "CKR_SESSION_READ_ONLY_EXISTS",SWIG_From_int(static_cast< int >(0x000000B7))); SWIG_Python_SetConstant(d, "CKR_SESSION_READ_WRITE_SO_EXISTS",SWIG_From_int(static_cast< int >(0x000000B8))); SWIG_Python_SetConstant(d, "CKR_SIGNATURE_INVALID",SWIG_From_int(static_cast< int >(0x000000C0))); SWIG_Python_SetConstant(d, "CKR_SIGNATURE_LEN_RANGE",SWIG_From_int(static_cast< int >(0x000000C1))); SWIG_Python_SetConstant(d, "CKR_TEMPLATE_INCOMPLETE",SWIG_From_int(static_cast< int >(0x000000D0))); SWIG_Python_SetConstant(d, "CKR_TEMPLATE_INCONSISTENT",SWIG_From_int(static_cast< int >(0x000000D1))); SWIG_Python_SetConstant(d, "CKR_TOKEN_NOT_PRESENT",SWIG_From_int(static_cast< int >(0x000000E0))); SWIG_Python_SetConstant(d, "CKR_TOKEN_NOT_RECOGNIZED",SWIG_From_int(static_cast< int >(0x000000E1))); SWIG_Python_SetConstant(d, "CKR_TOKEN_WRITE_PROTECTED",SWIG_From_int(static_cast< int >(0x000000E2))); SWIG_Python_SetConstant(d, "CKR_UNWRAPPING_KEY_HANDLE_INVALID",SWIG_From_int(static_cast< int >(0x000000F0))); SWIG_Python_SetConstant(d, "CKR_UNWRAPPING_KEY_SIZE_RANGE",SWIG_From_int(static_cast< int >(0x000000F1))); SWIG_Python_SetConstant(d, "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT",SWIG_From_int(static_cast< int >(0x000000F2))); SWIG_Python_SetConstant(d, "CKR_USER_ALREADY_LOGGED_IN",SWIG_From_int(static_cast< int >(0x00000100))); SWIG_Python_SetConstant(d, "CKR_USER_NOT_LOGGED_IN",SWIG_From_int(static_cast< int >(0x00000101))); SWIG_Python_SetConstant(d, "CKR_USER_PIN_NOT_INITIALIZED",SWIG_From_int(static_cast< int >(0x00000102))); SWIG_Python_SetConstant(d, "CKR_USER_TYPE_INVALID",SWIG_From_int(static_cast< int >(0x00000103))); SWIG_Python_SetConstant(d, "CKR_USER_ANOTHER_ALREADY_LOGGED_IN",SWIG_From_int(static_cast< int >(0x00000104))); SWIG_Python_SetConstant(d, "CKR_USER_TOO_MANY_TYPES",SWIG_From_int(static_cast< int >(0x00000105))); SWIG_Python_SetConstant(d, "CKR_WRAPPED_KEY_INVALID",SWIG_From_int(static_cast< int >(0x00000110))); SWIG_Python_SetConstant(d, "CKR_WRAPPED_KEY_LEN_RANGE",SWIG_From_int(static_cast< int >(0x00000112))); SWIG_Python_SetConstant(d, "CKR_WRAPPING_KEY_HANDLE_INVALID",SWIG_From_int(static_cast< int >(0x00000113))); SWIG_Python_SetConstant(d, "CKR_WRAPPING_KEY_SIZE_RANGE",SWIG_From_int(static_cast< int >(0x00000114))); SWIG_Python_SetConstant(d, "CKR_WRAPPING_KEY_TYPE_INCONSISTENT",SWIG_From_int(static_cast< int >(0x00000115))); SWIG_Python_SetConstant(d, "CKR_RANDOM_SEED_NOT_SUPPORTED",SWIG_From_int(static_cast< int >(0x00000120))); SWIG_Python_SetConstant(d, "CKR_RANDOM_NO_RNG",SWIG_From_int(static_cast< int >(0x00000121))); SWIG_Python_SetConstant(d, "CKR_DOMAIN_PARAMS_INVALID",SWIG_From_int(static_cast< int >(0x00000130))); SWIG_Python_SetConstant(d, "CKR_BUFFER_TOO_SMALL",SWIG_From_int(static_cast< int >(0x00000150))); SWIG_Python_SetConstant(d, "CKR_SAVED_STATE_INVALID",SWIG_From_int(static_cast< int >(0x00000160))); SWIG_Python_SetConstant(d, "CKR_INFORMATION_SENSITIVE",SWIG_From_int(static_cast< int >(0x00000170))); SWIG_Python_SetConstant(d, "CKR_STATE_UNSAVEABLE",SWIG_From_int(static_cast< int >(0x00000180))); SWIG_Python_SetConstant(d, "CKR_CRYPTOKI_NOT_INITIALIZED",SWIG_From_int(static_cast< int >(0x00000190))); SWIG_Python_SetConstant(d, "CKR_CRYPTOKI_ALREADY_INITIALIZED",SWIG_From_int(static_cast< int >(0x00000191))); SWIG_Python_SetConstant(d, "CKR_MUTEX_BAD",SWIG_From_int(static_cast< int >(0x000001A0))); SWIG_Python_SetConstant(d, "CKR_MUTEX_NOT_LOCKED",SWIG_From_int(static_cast< int >(0x000001A1))); SWIG_Python_SetConstant(d, "CKR_VENDOR_DEFINED",SWIG_From_int(static_cast< int >(0x80000000))); SWIG_Python_SetConstant(d, "CKF_LIBRARY_CANT_CREATE_OS_THREADS",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKF_OS_LOCKING_OK",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKF_DONT_BLOCK",SWIG_From_int(static_cast< int >(1))); SWIG_Python_SetConstant(d, "CKG_MGF1_SHA1",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKZ_DATA_SPECIFIED",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKD_NULL",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKD_SHA1_KDF",SWIG_From_int(static_cast< int >(0x00000002))); SWIG_Python_SetConstant(d, "CKD_SHA1_KDF_ASN1",SWIG_From_int(static_cast< int >(0x00000003))); SWIG_Python_SetConstant(d, "CKD_SHA1_KDF_CONCATENATE",SWIG_From_int(static_cast< int >(0x00000004))); SWIG_Python_SetConstant(d, "CKP_PKCS5_PBKD2_HMAC_SHA1",SWIG_From_int(static_cast< int >(0x00000001))); SWIG_Python_SetConstant(d, "CKZ_SALT_SPECIFIED",SWIG_From_int(static_cast< int >(0x00000001))); #if PY_VERSION_HEX >= 0x03000000 return m; #else return; #endif } PyKCS11-1.2.4/src/opensc/0000755000175000017500000000000011744467602016440 5ustar rousseaurousseau00000000000000PyKCS11-1.2.4/src/opensc/pkcs11.h0000644000175000017500000012271111101071703017673 0ustar rousseaurousseau00000000000000/* pkcs11.h Copyright 2006, 2007 g10 Code GmbH Copyright 2006 Andreas Jellinghaus This file is free software; as a special exception the author gives unlimited permission to copy and/or distribute it, with or without modifications, as long as this notice is preserved. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY, to the extent permitted by law; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* Please submit changes back to the Scute project at http://www.scute.org/ (or send them to marcus@g10code.com), so that they can be picked up by other projects from there as well. */ /* This file is a modified implementation of the PKCS #11 standard by RSA Security Inc. It is mostly a drop-in replacement, with the following change: This header file does not require any macro definitions by the user (like CK_DEFINE_FUNCTION etc). In fact, it defines those macros for you (if useful, some are missing, let me know if you need more). There is an additional API available that does comply better to the GNU coding standard. It can be switched on by defining CRYPTOKI_GNU before including this header file. For this, the following changes are made to the specification: All structure types are changed to a "struct ck_foo" where CK_FOO is the type name in PKCS #11. All non-structure types are changed to ck_foo_t where CK_FOO is the lowercase version of the type name in PKCS #11. The basic types (CK_ULONG et al.) are removed without substitute. All members of structures are modified in the following way: Type indication prefixes are removed, and underscore characters are inserted before words. Then the result is lowercased. Note that function names are still in the original case, as they need for ABI compatibility. CK_FALSE, CK_TRUE and NULL_PTR are removed without substitute. Use . If CRYPTOKI_COMPAT is defined before including this header file, then none of the API changes above take place, and the API is the one defined by the PKCS #11 standard. */ #ifndef PKCS11_H #define PKCS11_H 1 #if defined(__cplusplus) extern "C" { #endif /* The version of cryptoki we implement. The revision is changed with each modification of this file. If you do not use the "official" version of this file, please consider deleting the revision macro (you may use a macro with a different name to keep track of your versions). */ #define CRYPTOKI_VERSION_MAJOR 2 #define CRYPTOKI_VERSION_MINOR 20 #define CRYPTOKI_VERSION_REVISION 6 /* Compatibility interface is default, unless CRYPTOKI_GNU is given. */ #ifndef CRYPTOKI_GNU #ifndef CRYPTOKI_COMPAT #define CRYPTOKI_COMPAT 1 #endif #endif /* System dependencies. */ #if defined(_WIN32) || defined(CRYPTOKI_FORCE_WIN32) /* There is a matching pop below. */ #pragma pack(push, cryptoki, 1) #ifdef CRYPTOKI_EXPORTS #define CK_SPEC __declspec(dllexport) #else #define CK_SPEC __declspec(dllimport) #endif #else #define CK_SPEC #endif #ifdef CRYPTOKI_COMPAT /* If we are in compatibility mode, switch all exposed names to the PKCS #11 variant. There are corresponding #undefs below. */ #define ck_flags_t CK_FLAGS #define ck_version _CK_VERSION #define ck_info _CK_INFO #define cryptoki_version cryptokiVersion #define manufacturer_id manufacturerID #define library_description libraryDescription #define library_version libraryVersion #define ck_notification_t CK_NOTIFICATION #define ck_slot_id_t CK_SLOT_ID #define ck_slot_info _CK_SLOT_INFO #define slot_description slotDescription #define hardware_version hardwareVersion #define firmware_version firmwareVersion #define ck_token_info _CK_TOKEN_INFO #define serial_number serialNumber #define max_session_count ulMaxSessionCount #define session_count ulSessionCount #define max_rw_session_count ulMaxRwSessionCount #define rw_session_count ulRwSessionCount #define max_pin_len ulMaxPinLen #define min_pin_len ulMinPinLen #define total_public_memory ulTotalPublicMemory #define free_public_memory ulFreePublicMemory #define total_private_memory ulTotalPrivateMemory #define free_private_memory ulFreePrivateMemory #define utc_time utcTime #define ck_session_handle_t CK_SESSION_HANDLE #define ck_user_type_t CK_USER_TYPE #define ck_state_t CK_STATE #define ck_session_info _CK_SESSION_INFO #define slot_id slotID #define device_error ulDeviceError #define ck_object_handle_t CK_OBJECT_HANDLE #define ck_object_class_t CK_OBJECT_CLASS #define ck_hw_feature_type_t CK_HW_FEATURE_TYPE #define ck_key_type_t CK_KEY_TYPE #define ck_certificate_type_t CK_CERTIFICATE_TYPE #define ck_attribute_type_t CK_ATTRIBUTE_TYPE #define ck_attribute _CK_ATTRIBUTE #define value pValue #define value_len ulValueLen #define ck_date _CK_DATE #define ck_mechanism_type_t CK_MECHANISM_TYPE #define ck_mechanism _CK_MECHANISM #define parameter pParameter #define parameter_len ulParameterLen #define ck_mechanism_info _CK_MECHANISM_INFO #define min_key_size ulMinKeySize #define max_key_size ulMaxKeySize #define ck_rv_t CK_RV #define ck_notify_t CK_NOTIFY #define ck_function_list _CK_FUNCTION_LIST #define ck_createmutex_t CK_CREATEMUTEX #define ck_destroymutex_t CK_DESTROYMUTEX #define ck_lockmutex_t CK_LOCKMUTEX #define ck_unlockmutex_t CK_UNLOCKMUTEX #define ck_c_initialize_args _CK_C_INITIALIZE_ARGS #define create_mutex CreateMutex #define destroy_mutex DestroyMutex #define lock_mutex LockMutex #define unlock_mutex UnlockMutex #define reserved pReserved #endif /* CRYPTOKI_COMPAT */ typedef unsigned long ck_flags_t; struct ck_version { unsigned char major; unsigned char minor; }; struct ck_info { struct ck_version cryptoki_version; unsigned char manufacturer_id[32]; ck_flags_t flags; unsigned char library_description[32]; struct ck_version library_version; }; typedef unsigned long ck_notification_t; #define CKN_SURRENDER (0) typedef unsigned long ck_slot_id_t; struct ck_slot_info { unsigned char slot_description[64]; unsigned char manufacturer_id[32]; ck_flags_t flags; struct ck_version hardware_version; struct ck_version firmware_version; }; #define CKF_TOKEN_PRESENT (1 << 0) #define CKF_REMOVABLE_DEVICE (1 << 1) #define CKF_HW_SLOT (1 << 2) #define CKF_ARRAY_ATTRIBUTE (1 << 30) struct ck_token_info { unsigned char label[32]; unsigned char manufacturer_id[32]; unsigned char model[16]; unsigned char serial_number[16]; ck_flags_t flags; unsigned long max_session_count; unsigned long session_count; unsigned long max_rw_session_count; unsigned long rw_session_count; unsigned long max_pin_len; unsigned long min_pin_len; unsigned long total_public_memory; unsigned long free_public_memory; unsigned long total_private_memory; unsigned long free_private_memory; struct ck_version hardware_version; struct ck_version firmware_version; unsigned char utc_time[16]; }; #define CKF_RNG (1 << 0) #define CKF_WRITE_PROTECTED (1 << 1) #define CKF_LOGIN_REQUIRED (1 << 2) #define CKF_USER_PIN_INITIALIZED (1 << 3) #define CKF_RESTORE_KEY_NOT_NEEDED (1 << 5) #define CKF_CLOCK_ON_TOKEN (1 << 6) #define CKF_PROTECTED_AUTHENTICATION_PATH (1 << 8) #define CKF_DUAL_CRYPTO_OPERATIONS (1 << 9) #define CKF_TOKEN_INITIALIZED (1 << 10) #define CKF_SECONDARY_AUTHENTICATION (1 << 11) #define CKF_USER_PIN_COUNT_LOW (1 << 16) #define CKF_USER_PIN_FINAL_TRY (1 << 17) #define CKF_USER_PIN_LOCKED (1 << 18) #define CKF_USER_PIN_TO_BE_CHANGED (1 << 19) #define CKF_SO_PIN_COUNT_LOW (1 << 20) #define CKF_SO_PIN_FINAL_TRY (1 << 21) #define CKF_SO_PIN_LOCKED (1 << 22) #define CKF_SO_PIN_TO_BE_CHANGED (1 << 23) #define CK_UNAVAILABLE_INFORMATION ((unsigned long) -1) #define CK_EFFECTIVELY_INFINITE (0) typedef unsigned long ck_session_handle_t; #define CK_INVALID_HANDLE (0) typedef unsigned long ck_user_type_t; #define CKU_SO (0) #define CKU_USER (1) #define CKU_CONTEXT_SPECIFIC (2) typedef unsigned long ck_state_t; #define CKS_RO_PUBLIC_SESSION (0) #define CKS_RO_USER_FUNCTIONS (1) #define CKS_RW_PUBLIC_SESSION (2) #define CKS_RW_USER_FUNCTIONS (3) #define CKS_RW_SO_FUNCTIONS (4) struct ck_session_info { ck_slot_id_t slot_id; ck_state_t state; ck_flags_t flags; unsigned long device_error; }; #define CKF_RW_SESSION (1 << 1) #define CKF_SERIAL_SESSION (1 << 2) typedef unsigned long ck_object_handle_t; typedef unsigned long ck_object_class_t; #define CKO_DATA (0) #define CKO_CERTIFICATE (1) #define CKO_PUBLIC_KEY (2) #define CKO_PRIVATE_KEY (3) #define CKO_SECRET_KEY (4) #define CKO_HW_FEATURE (5) #define CKO_DOMAIN_PARAMETERS (6) #define CKO_MECHANISM (7) #define CKO_VENDOR_DEFINED ((unsigned long) (1 << 31)) typedef unsigned long ck_hw_feature_type_t; #define CKH_MONOTONIC_COUNTER (1) #define CKH_CLOCK (2) #define CKH_USER_INTERFACE (3) #define CKH_VENDOR_DEFINED ((unsigned long) (1 << 31)) typedef unsigned long ck_key_type_t; #define CKK_RSA (0) #define CKK_DSA (1) #define CKK_DH (2) #define CKK_ECDSA (3) #define CKK_EC (3) #define CKK_X9_42_DH (4) #define CKK_KEA (5) #define CKK_GENERIC_SECRET (0x10) #define CKK_RC2 (0x11) #define CKK_RC4 (0x12) #define CKK_DES (0x13) #define CKK_DES2 (0x14) #define CKK_DES3 (0x15) #define CKK_CAST (0x16) #define CKK_CAST3 (0x17) #define CKK_CAST128 (0x18) #define CKK_RC5 (0x19) #define CKK_IDEA (0x1a) #define CKK_SKIPJACK (0x1b) #define CKK_BATON (0x1c) #define CKK_JUNIPER (0x1d) #define CKK_CDMF (0x1e) #define CKK_AES (0x1f) #define CKK_BLOWFISH (0x20) #define CKK_TWOFISH (0x21) #define CKK_VENDOR_DEFINED ((unsigned long) (1 << 31)) typedef unsigned long ck_certificate_type_t; #define CKC_X_509 (0) #define CKC_X_509_ATTR_CERT (1) #define CKC_WTLS (2) #define CKC_VENDOR_DEFINED ((unsigned long) (1 << 31)) typedef unsigned long ck_attribute_type_t; #define CKA_CLASS (0) #define CKA_TOKEN (1) #define CKA_PRIVATE (2) #define CKA_LABEL (3) #define CKA_APPLICATION (0x10) #define CKA_VALUE (0x11) #define CKA_OBJECT_ID (0x12) #define CKA_CERTIFICATE_TYPE (0x80) #define CKA_ISSUER (0x81) #define CKA_SERIAL_NUMBER (0x82) #define CKA_AC_ISSUER (0x83) #define CKA_OWNER (0x84) #define CKA_ATTR_TYPES (0x85) #define CKA_TRUSTED (0x86) #define CKA_CERTIFICATE_CATEGORY (0x87) #define CKA_JAVA_MIDP_SECURITY_DOMAIN (0x88) #define CKA_URL (0x89) #define CKA_HASH_OF_SUBJECT_PUBLIC_KEY (0x8a) #define CKA_HASH_OF_ISSUER_PUBLIC_KEY (0x8b) #define CKA_CHECK_VALUE (0x90) #define CKA_KEY_TYPE (0x100) #define CKA_SUBJECT (0x101) #define CKA_ID (0x102) #define CKA_SENSITIVE (0x103) #define CKA_ENCRYPT (0x104) #define CKA_DECRYPT (0x105) #define CKA_WRAP (0x106) #define CKA_UNWRAP (0x107) #define CKA_SIGN (0x108) #define CKA_SIGN_RECOVER (0x109) #define CKA_VERIFY (0x10a) #define CKA_VERIFY_RECOVER (0x10b) #define CKA_DERIVE (0x10c) #define CKA_START_DATE (0x110) #define CKA_END_DATE (0x111) #define CKA_MODULUS (0x120) #define CKA_MODULUS_BITS (0x121) #define CKA_PUBLIC_EXPONENT (0x122) #define CKA_PRIVATE_EXPONENT (0x123) #define CKA_PRIME_1 (0x124) #define CKA_PRIME_2 (0x125) #define CKA_EXPONENT_1 (0x126) #define CKA_EXPONENT_2 (0x127) #define CKA_COEFFICIENT (0x128) #define CKA_PRIME (0x130) #define CKA_SUBPRIME (0x131) #define CKA_BASE (0x132) #define CKA_PRIME_BITS (0x133) #define CKA_SUB_PRIME_BITS (0x134) #define CKA_VALUE_BITS (0x160) #define CKA_VALUE_LEN (0x161) #define CKA_EXTRACTABLE (0x162) #define CKA_LOCAL (0x163) #define CKA_NEVER_EXTRACTABLE (0x164) #define CKA_ALWAYS_SENSITIVE (0x165) #define CKA_KEY_GEN_MECHANISM (0x166) #define CKA_MODIFIABLE (0x170) #define CKA_ECDSA_PARAMS (0x180) #define CKA_EC_PARAMS (0x180) #define CKA_EC_POINT (0x181) #define CKA_SECONDARY_AUTH (0x200) #define CKA_AUTH_PIN_FLAGS (0x201) #define CKA_ALWAYS_AUTHENTICATE (0x202) #define CKA_WRAP_WITH_TRUSTED (0x210) #define CKA_HW_FEATURE_TYPE (0x300) #define CKA_RESET_ON_INIT (0x301) #define CKA_HAS_RESET (0x302) #define CKA_PIXEL_X (0x400) #define CKA_PIXEL_Y (0x401) #define CKA_RESOLUTION (0x402) #define CKA_CHAR_ROWS (0x403) #define CKA_CHAR_COLUMNS (0x404) #define CKA_COLOR (0x405) #define CKA_BITS_PER_PIXEL (0x406) #define CKA_CHAR_SETS (0x480) #define CKA_ENCODING_METHODS (0x481) #define CKA_MIME_TYPES (0x482) #define CKA_MECHANISM_TYPE (0x500) #define CKA_REQUIRED_CMS_ATTRIBUTES (0x501) #define CKA_DEFAULT_CMS_ATTRIBUTES (0x502) #define CKA_SUPPORTED_CMS_ATTRIBUTES (0x503) #define CKA_WRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x211) #define CKA_UNWRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x212) #define CKA_ALLOWED_MECHANISMS (CKF_ARRAY_ATTRIBUTE | 0x600) #define CKA_VENDOR_DEFINED ((unsigned long) (1 << 31)) struct ck_attribute { ck_attribute_type_t type; void *value; unsigned long value_len; }; struct ck_date { unsigned char year[4]; unsigned char month[2]; unsigned char day[2]; }; typedef unsigned long ck_mechanism_type_t; #define CKM_RSA_PKCS_KEY_PAIR_GEN (0) #define CKM_RSA_PKCS (1) #define CKM_RSA_9796 (2) #define CKM_RSA_X_509 (3) #define CKM_MD2_RSA_PKCS (4) #define CKM_MD5_RSA_PKCS (5) #define CKM_SHA1_RSA_PKCS (6) #define CKM_RIPEMD128_RSA_PKCS (7) #define CKM_RIPEMD160_RSA_PKCS (8) #define CKM_RSA_PKCS_OAEP (9) #define CKM_RSA_X9_31_KEY_PAIR_GEN (0xa) #define CKM_RSA_X9_31 (0xb) #define CKM_SHA1_RSA_X9_31 (0xc) #define CKM_RSA_PKCS_PSS (0xd) #define CKM_SHA1_RSA_PKCS_PSS (0xe) #define CKM_DSA_KEY_PAIR_GEN (0x10) #define CKM_DSA (0x11) #define CKM_DSA_SHA1 (0x12) #define CKM_DH_PKCS_KEY_PAIR_GEN (0x20) #define CKM_DH_PKCS_DERIVE (0x21) #define CKM_X9_42_DH_KEY_PAIR_GEN (0x30) #define CKM_X9_42_DH_DERIVE (0x31) #define CKM_X9_42_DH_HYBRID_DERIVE (0x32) #define CKM_X9_42_MQV_DERIVE (0x33) #define CKM_SHA256_RSA_PKCS (0x40) #define CKM_SHA384_RSA_PKCS (0x41) #define CKM_SHA512_RSA_PKCS (0x42) #define CKM_SHA256_RSA_PKCS_PSS (0x43) #define CKM_SHA384_RSA_PKCS_PSS (0x44) #define CKM_SHA512_RSA_PKCS_PSS (0x45) #define CKM_RC2_KEY_GEN (0x100) #define CKM_RC2_ECB (0x101) #define CKM_RC2_CBC (0x102) #define CKM_RC2_MAC (0x103) #define CKM_RC2_MAC_GENERAL (0x104) #define CKM_RC2_CBC_PAD (0x105) #define CKM_RC4_KEY_GEN (0x110) #define CKM_RC4 (0x111) #define CKM_DES_KEY_GEN (0x120) #define CKM_DES_ECB (0x121) #define CKM_DES_CBC (0x122) #define CKM_DES_MAC (0x123) #define CKM_DES_MAC_GENERAL (0x124) #define CKM_DES_CBC_PAD (0x125) #define CKM_DES2_KEY_GEN (0x130) #define CKM_DES3_KEY_GEN (0x131) #define CKM_DES3_ECB (0x132) #define CKM_DES3_CBC (0x133) #define CKM_DES3_MAC (0x134) #define CKM_DES3_MAC_GENERAL (0x135) #define CKM_DES3_CBC_PAD (0x136) #define CKM_CDMF_KEY_GEN (0x140) #define CKM_CDMF_ECB (0x141) #define CKM_CDMF_CBC (0x142) #define CKM_CDMF_MAC (0x143) #define CKM_CDMF_MAC_GENERAL (0x144) #define CKM_CDMF_CBC_PAD (0x145) #define CKM_MD2 (0x200) #define CKM_MD2_HMAC (0x201) #define CKM_MD2_HMAC_GENERAL (0x202) #define CKM_MD5 (0x210) #define CKM_MD5_HMAC (0x211) #define CKM_MD5_HMAC_GENERAL (0x212) #define CKM_SHA_1 (0x220) #define CKM_SHA_1_HMAC (0x221) #define CKM_SHA_1_HMAC_GENERAL (0x222) #define CKM_RIPEMD128 (0x230) #define CKM_RIPEMD128_HMAC (0x231) #define CKM_RIPEMD128_HMAC_GENERAL (0x232) #define CKM_RIPEMD160 (0x240) #define CKM_RIPEMD160_HMAC (0x241) #define CKM_RIPEMD160_HMAC_GENERAL (0x242) #define CKM_SHA256 (0x250) #define CKM_SHA256_HMAC (0x251) #define CKM_SHA256_HMAC_GENERAL (0x252) #define CKM_SHA384 (0x260) #define CKM_SHA384_HMAC (0x261) #define CKM_SHA384_HMAC_GENERAL (0x262) #define CKM_SHA512 (0x270) #define CKM_SHA512_HMAC (0x271) #define CKM_SHA512_HMAC_GENERAL (0x272) #define CKM_CAST_KEY_GEN (0x300) #define CKM_CAST_ECB (0x301) #define CKM_CAST_CBC (0x302) #define CKM_CAST_MAC (0x303) #define CKM_CAST_MAC_GENERAL (0x304) #define CKM_CAST_CBC_PAD (0x305) #define CKM_CAST3_KEY_GEN (0x310) #define CKM_CAST3_ECB (0x311) #define CKM_CAST3_CBC (0x312) #define CKM_CAST3_MAC (0x313) #define CKM_CAST3_MAC_GENERAL (0x314) #define CKM_CAST3_CBC_PAD (0x315) #define CKM_CAST5_KEY_GEN (0x320) #define CKM_CAST128_KEY_GEN (0x320) #define CKM_CAST5_ECB (0x321) #define CKM_CAST128_ECB (0x321) #define CKM_CAST5_CBC (0x322) #define CKM_CAST128_CBC (0x322) #define CKM_CAST5_MAC (0x323) #define CKM_CAST128_MAC (0x323) #define CKM_CAST5_MAC_GENERAL (0x324) #define CKM_CAST128_MAC_GENERAL (0x324) #define CKM_CAST5_CBC_PAD (0x325) #define CKM_CAST128_CBC_PAD (0x325) #define CKM_RC5_KEY_GEN (0x330) #define CKM_RC5_ECB (0x331) #define CKM_RC5_CBC (0x332) #define CKM_RC5_MAC (0x333) #define CKM_RC5_MAC_GENERAL (0x334) #define CKM_RC5_CBC_PAD (0x335) #define CKM_IDEA_KEY_GEN (0x340) #define CKM_IDEA_ECB (0x341) #define CKM_IDEA_CBC (0x342) #define CKM_IDEA_MAC (0x343) #define CKM_IDEA_MAC_GENERAL (0x344) #define CKM_IDEA_CBC_PAD (0x345) #define CKM_GENERIC_SECRET_KEY_GEN (0x350) #define CKM_CONCATENATE_BASE_AND_KEY (0x360) #define CKM_CONCATENATE_BASE_AND_DATA (0x362) #define CKM_CONCATENATE_DATA_AND_BASE (0x363) #define CKM_XOR_BASE_AND_DATA (0x364) #define CKM_EXTRACT_KEY_FROM_KEY (0x365) #define CKM_SSL3_PRE_MASTER_KEY_GEN (0x370) #define CKM_SSL3_MASTER_KEY_DERIVE (0x371) #define CKM_SSL3_KEY_AND_MAC_DERIVE (0x372) #define CKM_SSL3_MASTER_KEY_DERIVE_DH (0x373) #define CKM_TLS_PRE_MASTER_KEY_GEN (0x374) #define CKM_TLS_MASTER_KEY_DERIVE (0x375) #define CKM_TLS_KEY_AND_MAC_DERIVE (0x376) #define CKM_TLS_MASTER_KEY_DERIVE_DH (0x377) #define CKM_SSL3_MD5_MAC (0x380) #define CKM_SSL3_SHA1_MAC (0x381) #define CKM_MD5_KEY_DERIVATION (0x390) #define CKM_MD2_KEY_DERIVATION (0x391) #define CKM_SHA1_KEY_DERIVATION (0x392) #define CKM_PBE_MD2_DES_CBC (0x3a0) #define CKM_PBE_MD5_DES_CBC (0x3a1) #define CKM_PBE_MD5_CAST_CBC (0x3a2) #define CKM_PBE_MD5_CAST3_CBC (0x3a3) #define CKM_PBE_MD5_CAST5_CBC (0x3a4) #define CKM_PBE_MD5_CAST128_CBC (0x3a4) #define CKM_PBE_SHA1_CAST5_CBC (0x3a5) #define CKM_PBE_SHA1_CAST128_CBC (0x3a5) #define CKM_PBE_SHA1_RC4_128 (0x3a6) #define CKM_PBE_SHA1_RC4_40 (0x3a7) #define CKM_PBE_SHA1_DES3_EDE_CBC (0x3a8) #define CKM_PBE_SHA1_DES2_EDE_CBC (0x3a9) #define CKM_PBE_SHA1_RC2_128_CBC (0x3aa) #define CKM_PBE_SHA1_RC2_40_CBC (0x3ab) #define CKM_PKCS5_PBKD2 (0x3b0) #define CKM_PBA_SHA1_WITH_SHA1_HMAC (0x3c0) #define CKM_KEY_WRAP_LYNKS (0x400) #define CKM_KEY_WRAP_SET_OAEP (0x401) #define CKM_SKIPJACK_KEY_GEN (0x1000) #define CKM_SKIPJACK_ECB64 (0x1001) #define CKM_SKIPJACK_CBC64 (0x1002) #define CKM_SKIPJACK_OFB64 (0x1003) #define CKM_SKIPJACK_CFB64 (0x1004) #define CKM_SKIPJACK_CFB32 (0x1005) #define CKM_SKIPJACK_CFB16 (0x1006) #define CKM_SKIPJACK_CFB8 (0x1007) #define CKM_SKIPJACK_WRAP (0x1008) #define CKM_SKIPJACK_PRIVATE_WRAP (0x1009) #define CKM_SKIPJACK_RELAYX (0x100a) #define CKM_KEA_KEY_PAIR_GEN (0x1010) #define CKM_KEA_KEY_DERIVE (0x1011) #define CKM_FORTEZZA_TIMESTAMP (0x1020) #define CKM_BATON_KEY_GEN (0x1030) #define CKM_BATON_ECB128 (0x1031) #define CKM_BATON_ECB96 (0x1032) #define CKM_BATON_CBC128 (0x1033) #define CKM_BATON_COUNTER (0x1034) #define CKM_BATON_SHUFFLE (0x1035) #define CKM_BATON_WRAP (0x1036) #define CKM_ECDSA_KEY_PAIR_GEN (0x1040) #define CKM_EC_KEY_PAIR_GEN (0x1040) #define CKM_ECDSA (0x1041) #define CKM_ECDSA_SHA1 (0x1042) #define CKM_ECDH1_DERIVE (0x1050) #define CKM_ECDH1_COFACTOR_DERIVE (0x1051) #define CKM_ECMQV_DERIVE (0x1052) #define CKM_JUNIPER_KEY_GEN (0x1060) #define CKM_JUNIPER_ECB128 (0x1061) #define CKM_JUNIPER_CBC128 (0x1062) #define CKM_JUNIPER_COUNTER (0x1063) #define CKM_JUNIPER_SHUFFLE (0x1064) #define CKM_JUNIPER_WRAP (0x1065) #define CKM_FASTHASH (0x1070) #define CKM_AES_KEY_GEN (0x1080) #define CKM_AES_ECB (0x1081) #define CKM_AES_CBC (0x1082) #define CKM_AES_MAC (0x1083) #define CKM_AES_MAC_GENERAL (0x1084) #define CKM_AES_CBC_PAD (0x1085) #define CKM_DSA_PARAMETER_GEN (0x2000) #define CKM_DH_PKCS_PARAMETER_GEN (0x2001) #define CKM_X9_42_DH_PARAMETER_GEN (0x2002) #define CKM_VENDOR_DEFINED ((unsigned long) (1 << 31)) struct ck_mechanism { ck_mechanism_type_t mechanism; void *parameter; unsigned long parameter_len; }; struct ck_mechanism_info { unsigned long min_key_size; unsigned long max_key_size; ck_flags_t flags; }; #define CKF_HW (1 << 0) #define CKF_ENCRYPT (1 << 8) #define CKF_DECRYPT (1 << 9) #define CKF_DIGEST (1 << 10) #define CKF_SIGN (1 << 11) #define CKF_SIGN_RECOVER (1 << 12) #define CKF_VERIFY (1 << 13) #define CKF_VERIFY_RECOVER (1 << 14) #define CKF_GENERATE (1 << 15) #define CKF_GENERATE_KEY_PAIR (1 << 16) #define CKF_WRAP (1 << 17) #define CKF_UNWRAP (1 << 18) #define CKF_DERIVE (1 << 19) #define CKF_EXTENSION ((unsigned long) (1 << 31)) /* Flags for C_WaitForSlotEvent. */ #define CKF_DONT_BLOCK (1) typedef unsigned long ck_rv_t; typedef ck_rv_t (*ck_notify_t) (ck_session_handle_t session, ck_notification_t event, void *application); /* Forward reference. */ struct ck_function_list; #define _CK_DECLARE_FUNCTION(name, args) \ typedef ck_rv_t (*CK_ ## name) args; \ ck_rv_t CK_SPEC name args _CK_DECLARE_FUNCTION (C_Initialize, (void *init_args)); _CK_DECLARE_FUNCTION (C_Finalize, (void *reserved)); _CK_DECLARE_FUNCTION (C_GetInfo, (struct ck_info *info)); _CK_DECLARE_FUNCTION (C_GetFunctionList, (struct ck_function_list **function_list)); _CK_DECLARE_FUNCTION (C_GetSlotList, (unsigned char token_present, ck_slot_id_t *slot_list, unsigned long *count)); _CK_DECLARE_FUNCTION (C_GetSlotInfo, (ck_slot_id_t slot_id, struct ck_slot_info *info)); _CK_DECLARE_FUNCTION (C_GetTokenInfo, (ck_slot_id_t slot_id, struct ck_token_info *info)); _CK_DECLARE_FUNCTION (C_WaitForSlotEvent, (ck_flags_t flags, ck_slot_id_t *slot, void *reserved)); _CK_DECLARE_FUNCTION (C_GetMechanismList, (ck_slot_id_t slot_id, ck_mechanism_type_t *mechanism_list, unsigned long *count)); _CK_DECLARE_FUNCTION (C_GetMechanismInfo, (ck_slot_id_t slot_id, ck_mechanism_type_t type, struct ck_mechanism_info *info)); _CK_DECLARE_FUNCTION (C_InitToken, (ck_slot_id_t slot_id, unsigned char *pin, unsigned long pin_len, unsigned char *label)); _CK_DECLARE_FUNCTION (C_InitPIN, (ck_session_handle_t session, unsigned char *pin, unsigned long pin_len)); _CK_DECLARE_FUNCTION (C_SetPIN, (ck_session_handle_t session, unsigned char *old_pin, unsigned long old_len, unsigned char *new_pin, unsigned long new_len)); _CK_DECLARE_FUNCTION (C_OpenSession, (ck_slot_id_t slot_id, ck_flags_t flags, void *application, ck_notify_t notify, ck_session_handle_t *session)); _CK_DECLARE_FUNCTION (C_CloseSession, (ck_session_handle_t session)); _CK_DECLARE_FUNCTION (C_CloseAllSessions, (ck_slot_id_t slot_id)); _CK_DECLARE_FUNCTION (C_GetSessionInfo, (ck_session_handle_t session, struct ck_session_info *info)); _CK_DECLARE_FUNCTION (C_GetOperationState, (ck_session_handle_t session, unsigned char *operation_state, unsigned long *operation_state_len)); _CK_DECLARE_FUNCTION (C_SetOperationState, (ck_session_handle_t session, unsigned char *operation_state, unsigned long operation_state_len, ck_object_handle_t encryption_key, ck_object_handle_t authentiation_key)); _CK_DECLARE_FUNCTION (C_Login, (ck_session_handle_t session, ck_user_type_t user_type, unsigned char *pin, unsigned long pin_len)); _CK_DECLARE_FUNCTION (C_Logout, (ck_session_handle_t session)); _CK_DECLARE_FUNCTION (C_CreateObject, (ck_session_handle_t session, struct ck_attribute *templ, unsigned long count, ck_object_handle_t *object)); _CK_DECLARE_FUNCTION (C_CopyObject, (ck_session_handle_t session, ck_object_handle_t object, struct ck_attribute *templ, unsigned long count, ck_object_handle_t *new_object)); _CK_DECLARE_FUNCTION (C_DestroyObject, (ck_session_handle_t session, ck_object_handle_t object)); _CK_DECLARE_FUNCTION (C_GetObjectSize, (ck_session_handle_t session, ck_object_handle_t object, unsigned long *size)); _CK_DECLARE_FUNCTION (C_GetAttributeValue, (ck_session_handle_t session, ck_object_handle_t object, struct ck_attribute *templ, unsigned long count)); _CK_DECLARE_FUNCTION (C_SetAttributeValue, (ck_session_handle_t session, ck_object_handle_t object, struct ck_attribute *templ, unsigned long count)); _CK_DECLARE_FUNCTION (C_FindObjectsInit, (ck_session_handle_t session, struct ck_attribute *templ, unsigned long count)); _CK_DECLARE_FUNCTION (C_FindObjects, (ck_session_handle_t session, ck_object_handle_t *object, unsigned long max_object_count, unsigned long *object_count)); _CK_DECLARE_FUNCTION (C_FindObjectsFinal, (ck_session_handle_t session)); _CK_DECLARE_FUNCTION (C_EncryptInit, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_Encrypt, (ck_session_handle_t session, unsigned char *data, unsigned long data_len, unsigned char *encrypted_data, unsigned long *encrypted_data_len)); _CK_DECLARE_FUNCTION (C_EncryptUpdate, (ck_session_handle_t session, unsigned char *part, unsigned long part_len, unsigned char *encrypted_part, unsigned long *encrypted_part_len)); _CK_DECLARE_FUNCTION (C_EncryptFinal, (ck_session_handle_t session, unsigned char *last_encrypted_part, unsigned long *last_encrypted_part_len)); _CK_DECLARE_FUNCTION (C_DecryptInit, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_Decrypt, (ck_session_handle_t session, unsigned char *encrypted_data, unsigned long encrypted_data_len, unsigned char *data, unsigned long *data_len)); _CK_DECLARE_FUNCTION (C_DecryptUpdate, (ck_session_handle_t session, unsigned char *encrypted_part, unsigned long encrypted_part_len, unsigned char *part, unsigned long *part_len)); _CK_DECLARE_FUNCTION (C_DecryptFinal, (ck_session_handle_t session, unsigned char *last_part, unsigned long *last_part_len)); _CK_DECLARE_FUNCTION (C_DigestInit, (ck_session_handle_t session, struct ck_mechanism *mechanism)); _CK_DECLARE_FUNCTION (C_Digest, (ck_session_handle_t session, unsigned char *data, unsigned long data_len, unsigned char *digest, unsigned long *digest_len)); _CK_DECLARE_FUNCTION (C_DigestUpdate, (ck_session_handle_t session, unsigned char *part, unsigned long part_len)); _CK_DECLARE_FUNCTION (C_DigestKey, (ck_session_handle_t session, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_DigestFinal, (ck_session_handle_t session, unsigned char *digest, unsigned long *digest_len)); _CK_DECLARE_FUNCTION (C_SignInit, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_Sign, (ck_session_handle_t session, unsigned char *data, unsigned long data_len, unsigned char *signature, unsigned long *signature_len)); _CK_DECLARE_FUNCTION (C_SignUpdate, (ck_session_handle_t session, unsigned char *part, unsigned long part_len)); _CK_DECLARE_FUNCTION (C_SignFinal, (ck_session_handle_t session, unsigned char *signature, unsigned long *signature_len)); _CK_DECLARE_FUNCTION (C_SignRecoverInit, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_SignRecover, (ck_session_handle_t session, unsigned char *data, unsigned long data_len, unsigned char *signature, unsigned long *signature_len)); _CK_DECLARE_FUNCTION (C_VerifyInit, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_Verify, (ck_session_handle_t session, unsigned char *data, unsigned long data_len, unsigned char *signature, unsigned long signature_len)); _CK_DECLARE_FUNCTION (C_VerifyUpdate, (ck_session_handle_t session, unsigned char *part, unsigned long part_len)); _CK_DECLARE_FUNCTION (C_VerifyFinal, (ck_session_handle_t session, unsigned char *signature, unsigned long signature_len)); _CK_DECLARE_FUNCTION (C_VerifyRecoverInit, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t key)); _CK_DECLARE_FUNCTION (C_VerifyRecover, (ck_session_handle_t session, unsigned char *signature, unsigned long signature_len, unsigned char *data, unsigned long *data_len)); _CK_DECLARE_FUNCTION (C_DigestEncryptUpdate, (ck_session_handle_t session, unsigned char *part, unsigned long part_len, unsigned char *encrypted_part, unsigned long *encrypted_part_len)); _CK_DECLARE_FUNCTION (C_DecryptDigestUpdate, (ck_session_handle_t session, unsigned char *encrypted_part, unsigned long encrypted_part_len, unsigned char *part, unsigned long *part_len)); _CK_DECLARE_FUNCTION (C_SignEncryptUpdate, (ck_session_handle_t session, unsigned char *part, unsigned long part_len, unsigned char *encrypted_part, unsigned long *encrypted_part_len)); _CK_DECLARE_FUNCTION (C_DecryptVerifyUpdate, (ck_session_handle_t session, unsigned char *encrypted_part, unsigned long encrypted_part_len, unsigned char *part, unsigned long *part_len)); _CK_DECLARE_FUNCTION (C_GenerateKey, (ck_session_handle_t session, struct ck_mechanism *mechanism, struct ck_attribute *templ, unsigned long count, ck_object_handle_t *key)); _CK_DECLARE_FUNCTION (C_GenerateKeyPair, (ck_session_handle_t session, struct ck_mechanism *mechanism, struct ck_attribute *public_key_template, unsigned long public_key_attribute_count, struct ck_attribute *private_key_template, unsigned long private_key_attribute_count, ck_object_handle_t *public_key, ck_object_handle_t *private_key)); _CK_DECLARE_FUNCTION (C_WrapKey, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t wrapping_key, ck_object_handle_t key, unsigned char *wrapped_key, unsigned long *wrapped_key_len)); _CK_DECLARE_FUNCTION (C_UnwrapKey, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t unwrapping_key, unsigned char *wrapped_key, unsigned long wrapped_key_len, struct ck_attribute *templ, unsigned long attribute_count, ck_object_handle_t *key)); _CK_DECLARE_FUNCTION (C_DeriveKey, (ck_session_handle_t session, struct ck_mechanism *mechanism, ck_object_handle_t base_key, struct ck_attribute *templ, unsigned long attribute_count, ck_object_handle_t *key)); _CK_DECLARE_FUNCTION (C_SeedRandom, (ck_session_handle_t session, unsigned char *seed, unsigned long seed_len)); _CK_DECLARE_FUNCTION (C_GenerateRandom, (ck_session_handle_t session, unsigned char *random_data, unsigned long random_len)); _CK_DECLARE_FUNCTION (C_GetFunctionStatus, (ck_session_handle_t session)); _CK_DECLARE_FUNCTION (C_CancelFunction, (ck_session_handle_t session)); struct ck_function_list { struct ck_version version; CK_C_Initialize C_Initialize; CK_C_Finalize C_Finalize; CK_C_GetInfo C_GetInfo; CK_C_GetFunctionList C_GetFunctionList; CK_C_GetSlotList C_GetSlotList; CK_C_GetSlotInfo C_GetSlotInfo; CK_C_GetTokenInfo C_GetTokenInfo; CK_C_GetMechanismList C_GetMechanismList; CK_C_GetMechanismInfo C_GetMechanismInfo; CK_C_InitToken C_InitToken; CK_C_InitPIN C_InitPIN; CK_C_SetPIN C_SetPIN; CK_C_OpenSession C_OpenSession; CK_C_CloseSession C_CloseSession; CK_C_CloseAllSessions C_CloseAllSessions; CK_C_GetSessionInfo C_GetSessionInfo; CK_C_GetOperationState C_GetOperationState; CK_C_SetOperationState C_SetOperationState; CK_C_Login C_Login; CK_C_Logout C_Logout; CK_C_CreateObject C_CreateObject; CK_C_CopyObject C_CopyObject; CK_C_DestroyObject C_DestroyObject; CK_C_GetObjectSize C_GetObjectSize; CK_C_GetAttributeValue C_GetAttributeValue; CK_C_SetAttributeValue C_SetAttributeValue; CK_C_FindObjectsInit C_FindObjectsInit; CK_C_FindObjects C_FindObjects; CK_C_FindObjectsFinal C_FindObjectsFinal; CK_C_EncryptInit C_EncryptInit; CK_C_Encrypt C_Encrypt; CK_C_EncryptUpdate C_EncryptUpdate; CK_C_EncryptFinal C_EncryptFinal; CK_C_DecryptInit C_DecryptInit; CK_C_Decrypt C_Decrypt; CK_C_DecryptUpdate C_DecryptUpdate; CK_C_DecryptFinal C_DecryptFinal; CK_C_DigestInit C_DigestInit; CK_C_Digest C_Digest; CK_C_DigestUpdate C_DigestUpdate; CK_C_DigestKey C_DigestKey; CK_C_DigestFinal C_DigestFinal; CK_C_SignInit C_SignInit; CK_C_Sign C_Sign; CK_C_SignUpdate C_SignUpdate; CK_C_SignFinal C_SignFinal; CK_C_SignRecoverInit C_SignRecoverInit; CK_C_SignRecover C_SignRecover; CK_C_VerifyInit C_VerifyInit; CK_C_Verify C_Verify; CK_C_VerifyUpdate C_VerifyUpdate; CK_C_VerifyFinal C_VerifyFinal; CK_C_VerifyRecoverInit C_VerifyRecoverInit; CK_C_VerifyRecover C_VerifyRecover; CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; CK_C_SignEncryptUpdate C_SignEncryptUpdate; CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; CK_C_GenerateKey C_GenerateKey; CK_C_GenerateKeyPair C_GenerateKeyPair; CK_C_WrapKey C_WrapKey; CK_C_UnwrapKey C_UnwrapKey; CK_C_DeriveKey C_DeriveKey; CK_C_SeedRandom C_SeedRandom; CK_C_GenerateRandom C_GenerateRandom; CK_C_GetFunctionStatus C_GetFunctionStatus; CK_C_CancelFunction C_CancelFunction; CK_C_WaitForSlotEvent C_WaitForSlotEvent; }; typedef ck_rv_t (*ck_createmutex_t) (void **mutex); typedef ck_rv_t (*ck_destroymutex_t) (void *mutex); typedef ck_rv_t (*ck_lockmutex_t) (void *mutex); typedef ck_rv_t (*ck_unlockmutex_t) (void *mutex); struct ck_c_initialize_args { ck_createmutex_t create_mutex; ck_destroymutex_t destroy_mutex; ck_lockmutex_t lock_mutex; ck_unlockmutex_t unlock_mutex; ck_flags_t flags; void *reserved; }; #define CKF_LIBRARY_CANT_CREATE_OS_THREADS (1 << 0) #define CKF_OS_LOCKING_OK (1 << 1) #define CKR_OK (0) #define CKR_CANCEL (1) #define CKR_HOST_MEMORY (2) #define CKR_SLOT_ID_INVALID (3) #define CKR_GENERAL_ERROR (5) #define CKR_FUNCTION_FAILED (6) #define CKR_ARGUMENTS_BAD (7) #define CKR_NO_EVENT (8) #define CKR_NEED_TO_CREATE_THREADS (9) #define CKR_CANT_LOCK (0xa) #define CKR_ATTRIBUTE_READ_ONLY (0x10) #define CKR_ATTRIBUTE_SENSITIVE (0x11) #define CKR_ATTRIBUTE_TYPE_INVALID (0x12) #define CKR_ATTRIBUTE_VALUE_INVALID (0x13) #define CKR_DATA_INVALID (0x20) #define CKR_DATA_LEN_RANGE (0x21) #define CKR_DEVICE_ERROR (0x30) #define CKR_DEVICE_MEMORY (0x31) #define CKR_DEVICE_REMOVED (0x32) #define CKR_ENCRYPTED_DATA_INVALID (0x40) #define CKR_ENCRYPTED_DATA_LEN_RANGE (0x41) #define CKR_FUNCTION_CANCELED (0x50) #define CKR_FUNCTION_NOT_PARALLEL (0x51) #define CKR_FUNCTION_NOT_SUPPORTED (0x54) #define CKR_KEY_HANDLE_INVALID (0x60) #define CKR_KEY_SIZE_RANGE (0x62) #define CKR_KEY_TYPE_INCONSISTENT (0x63) #define CKR_KEY_NOT_NEEDED (0x64) #define CKR_KEY_CHANGED (0x65) #define CKR_KEY_NEEDED (0x66) #define CKR_KEY_INDIGESTIBLE (0x67) #define CKR_KEY_FUNCTION_NOT_PERMITTED (0x68) #define CKR_KEY_NOT_WRAPPABLE (0x69) #define CKR_KEY_UNEXTRACTABLE (0x6a) #define CKR_MECHANISM_INVALID (0x70) #define CKR_MECHANISM_PARAM_INVALID (0x71) #define CKR_OBJECT_HANDLE_INVALID (0x82) #define CKR_OPERATION_ACTIVE (0x90) #define CKR_OPERATION_NOT_INITIALIZED (0x91) #define CKR_PIN_INCORRECT (0xa0) #define CKR_PIN_INVALID (0xa1) #define CKR_PIN_LEN_RANGE (0xa2) #define CKR_PIN_EXPIRED (0xa3) #define CKR_PIN_LOCKED (0xa4) #define CKR_SESSION_CLOSED (0xb0) #define CKR_SESSION_COUNT (0xb1) #define CKR_SESSION_HANDLE_INVALID (0xb3) #define CKR_SESSION_PARALLEL_NOT_SUPPORTED (0xb4) #define CKR_SESSION_READ_ONLY (0xb5) #define CKR_SESSION_EXISTS (0xb6) #define CKR_SESSION_READ_ONLY_EXISTS (0xb7) #define CKR_SESSION_READ_WRITE_SO_EXISTS (0xb8) #define CKR_SIGNATURE_INVALID (0xc0) #define CKR_SIGNATURE_LEN_RANGE (0xc1) #define CKR_TEMPLATE_INCOMPLETE (0xd0) #define CKR_TEMPLATE_INCONSISTENT (0xd1) #define CKR_TOKEN_NOT_PRESENT (0xe0) #define CKR_TOKEN_NOT_RECOGNIZED (0xe1) #define CKR_TOKEN_WRITE_PROTECTED (0xe2) #define CKR_UNWRAPPING_KEY_HANDLE_INVALID (0xf0) #define CKR_UNWRAPPING_KEY_SIZE_RANGE (0xf1) #define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT (0xf2) #define CKR_USER_ALREADY_LOGGED_IN (0x100) #define CKR_USER_NOT_LOGGED_IN (0x101) #define CKR_USER_PIN_NOT_INITIALIZED (0x102) #define CKR_USER_TYPE_INVALID (0x103) #define CKR_USER_ANOTHER_ALREADY_LOGGED_IN (0x104) #define CKR_USER_TOO_MANY_TYPES (0x105) #define CKR_WRAPPED_KEY_INVALID (0x110) #define CKR_WRAPPED_KEY_LEN_RANGE (0x112) #define CKR_WRAPPING_KEY_HANDLE_INVALID (0x113) #define CKR_WRAPPING_KEY_SIZE_RANGE (0x114) #define CKR_WRAPPING_KEY_TYPE_INCONSISTENT (0x115) #define CKR_RANDOM_SEED_NOT_SUPPORTED (0x120) #define CKR_RANDOM_NO_RNG (0x121) #define CKR_DOMAIN_PARAMS_INVALID (0x130) #define CKR_BUFFER_TOO_SMALL (0x150) #define CKR_SAVED_STATE_INVALID (0x160) #define CKR_INFORMATION_SENSITIVE (0x170) #define CKR_STATE_UNSAVEABLE (0x180) #define CKR_CRYPTOKI_NOT_INITIALIZED (0x190) #define CKR_CRYPTOKI_ALREADY_INITIALIZED (0x191) #define CKR_MUTEX_BAD (0x1a0) #define CKR_MUTEX_NOT_LOCKED (0x1a1) #define CKR_FUNCTION_REJECTED (0x200) #define CKR_VENDOR_DEFINED ((unsigned long) (1 << 31)) /* Compatibility layer. */ #ifdef CRYPTOKI_COMPAT #undef CK_DEFINE_FUNCTION #define CK_DEFINE_FUNCTION(retval, name) retval CK_SPEC name /* For NULL. */ #include typedef unsigned char CK_BYTE; typedef unsigned char CK_CHAR; typedef unsigned char CK_UTF8CHAR; typedef unsigned char CK_BBOOL; typedef unsigned long int CK_ULONG; typedef long int CK_LONG; typedef CK_BYTE *CK_BYTE_PTR; typedef CK_CHAR *CK_CHAR_PTR; typedef CK_UTF8CHAR *CK_UTF8CHAR_PTR; typedef CK_ULONG *CK_ULONG_PTR; typedef void *CK_VOID_PTR; typedef void **CK_VOID_PTR_PTR; #define CK_FALSE 0 #define CK_TRUE 1 #ifndef CK_DISABLE_TRUE_FALSE #ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE 1 #endif #endif typedef struct ck_version CK_VERSION; typedef struct ck_version *CK_VERSION_PTR; typedef struct ck_info CK_INFO; typedef struct ck_info *CK_INFO_PTR; typedef ck_slot_id_t *CK_SLOT_ID_PTR; typedef struct ck_slot_info CK_SLOT_INFO; typedef struct ck_slot_info *CK_SLOT_INFO_PTR; typedef struct ck_token_info CK_TOKEN_INFO; typedef struct ck_token_info *CK_TOKEN_INFO_PTR; typedef ck_session_handle_t *CK_SESSION_HANDLE_PTR; typedef struct ck_session_info CK_SESSION_INFO; typedef struct ck_session_info *CK_SESSION_INFO_PTR; typedef ck_object_handle_t *CK_OBJECT_HANDLE_PTR; typedef ck_object_class_t *CK_OBJECT_CLASS_PTR; typedef struct ck_attribute CK_ATTRIBUTE; typedef struct ck_attribute *CK_ATTRIBUTE_PTR; typedef struct ck_date CK_DATE; typedef struct ck_date *CK_DATE_PTR; typedef ck_mechanism_type_t *CK_MECHANISM_TYPE_PTR; typedef struct ck_mechanism CK_MECHANISM; typedef struct ck_mechanism *CK_MECHANISM_PTR; typedef struct ck_mechanism_info CK_MECHANISM_INFO; typedef struct ck_mechanism_info *CK_MECHANISM_INFO_PTR; typedef struct ck_function_list CK_FUNCTION_LIST; typedef struct ck_function_list *CK_FUNCTION_LIST_PTR; typedef struct ck_function_list **CK_FUNCTION_LIST_PTR_PTR; typedef struct ck_c_initialize_args CK_C_INITIALIZE_ARGS; typedef struct ck_c_initialize_args *CK_C_INITIALIZE_ARGS_PTR; #define NULL_PTR NULL /* Delete the helper macros defined at the top of the file. */ #undef ck_flags_t #undef ck_version #undef ck_info #undef cryptoki_version #undef manufacturer_id #undef library_description #undef library_version #undef ck_notification_t #undef ck_slot_id_t #undef ck_slot_info #undef slot_description #undef hardware_version #undef firmware_version #undef ck_token_info #undef serial_number #undef max_session_count #undef session_count #undef max_rw_session_count #undef rw_session_count #undef max_pin_len #undef min_pin_len #undef total_public_memory #undef free_public_memory #undef total_private_memory #undef free_private_memory #undef utc_time #undef ck_session_handle_t #undef ck_user_type_t #undef ck_state_t #undef ck_session_info #undef slot_id #undef device_error #undef ck_object_handle_t #undef ck_object_class_t #undef ck_hw_feature_type_t #undef ck_key_type_t #undef ck_certificate_type_t #undef ck_attribute_type_t #undef ck_attribute #undef value #undef value_len #undef ck_date #undef ck_mechanism_type_t #undef ck_mechanism #undef parameter #undef parameter_len #undef ck_mechanism_info #undef min_key_size #undef max_key_size #undef ck_rv_t #undef ck_notify_t #undef ck_function_list #undef ck_createmutex_t #undef ck_destroymutex_t #undef ck_lockmutex_t #undef ck_unlockmutex_t #undef ck_c_initialize_args #undef create_mutex #undef destroy_mutex #undef lock_mutex #undef unlock_mutex #undef reserved #endif /* CRYPTOKI_COMPAT */ /* System dependencies. */ #if defined(_WIN32) || defined(CRYPTOKI_FORCE_WIN32) #pragma pack(pop, cryptoki) #endif #if defined(__cplusplus) } #endif #endif /* PKCS11_H */ PyKCS11-1.2.4/src/pykcs11string.cpp0000644000175000017500000000261711055022763020373 0ustar rousseaurousseau00000000000000// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #include "stdafx.h" #include "pykcs11string.h" PyKCS11String::PyKCS11String() {} PyKCS11String::PyKCS11String(unsigned char* pBuf, int len) { int i; if (m_str.max_size() < (size_t)len) m_str.reserve(len); for (i=0; i < len; i++) m_str.push_back((char)pBuf[i]); } PyKCS11String::PyKCS11String(const char* str):m_str(str) { } PyKCS11String::PyKCS11String(basic_string str):m_str(str) { } PyKCS11String::PyKCS11String(vector bin_str) { if (m_str.max_size() < bin_str.size()) m_str.reserve(bin_str.size()); size_t iSize = bin_str.size(); size_t i; for (i=0; i < iSize; i++) m_str.push_back(bin_str[i]); } PyKCS11-1.2.4/resource.h0000644000175000017500000000062111055022765016351 0ustar rousseaurousseau00000000000000//{{NO_DEPENDENCIES}} // Microsoft Visual C++ generated include file. // Used by pykcs11.rc // Next default values for new objects // #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 101 #define _APS_NEXT_COMMAND_VALUE 40001 #define _APS_NEXT_CONTROL_VALUE 1001 #define _APS_NEXT_SYMED_VALUE 101 #endif #endif PyKCS11-1.2.4/MANIFEST0000644000175000017500000000125711277563371015521 0ustar rousseaurousseau00000000000000readme.txt pykcs11.rc resource.h setup.py PyKCS11.sln PyKCS11.vcproj Makefile Makefile.win32 COPYING MANIFEST documentation.htm samples/dumpit.py samples/getinfo.py samples/unblock.py samples/LowLevel/dumpit.py samples/LowLevel/InitTokenPin.py samples/LowLevel/test.py samples/LowLevel/test1.py PyKCS11/LowLevel.py PyKCS11/__init__.py src/ck_attribute_smart.cpp src/ck_attribute_smart.h src/dyn_generic.h src/dyn_win32.c src/dyn_unix.c src/pkcs11lib.cpp src/pkcs11lib.h src/pykcs11.cpp src/pykcs11.h src/pykcs11.i src/pykcs11string.cpp src/pykcs11string.h src/stdafx.cpp src/stdafx.h src/utility.cpp src/utility.h src/opensc/pkcs11.h src/win32_pykcs11_wrap.cpp src/unix_pykcs11_wrap.cpp PyKCS11-1.2.4/Makefile.win320000644000175000017500000000077711101072673016761 0ustar rousseaurousseau00000000000000 build: src/win32_pykcs11_wrap.cpp setup.py build install: build setup.py install clean: setup.py clean DEL /F /Q src\win32_pykcs11_wrap.cpp DEL /S /F /Q build DEL /F /Q *.pyc PyKCS11\*.pyc DEL /F /Q PyKCS11\LowLevel.py rebuild: clean build src/win32_pykcs11_wrap.cpp: src/pykcs11.i swig.exe -c++ -Fmicrosoft -o src\win32_pykcs11_wrap.cpp -python src\pykcs11.i move src\LowLevel.py PyKCS11\ src/pykcs11.i: src/opensc/pkcs11.h src/pkcs11lib.h src/pykcs11string.h src/ck_attribute_smart.h PyKCS11-1.2.4/readme.txt0000644000175000017500000000734511744463710016365 0ustar rousseaurousseau00000000000000======================================================================== PyKCS11 - PKCS#11 Wrapper for Python - Project Overview ======================================================================== Authors """"""" - Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) - Copyright (C) 2006-2012 Ludovic Rousseau (ludovic.rousseau@free.fr) Licence """"""" This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Unix Howto """""""""" $ make build $ make install (or make install DESTDIR=/foo/bar) Windows Howto """"""""""""" Please use the VS.NET 2003 project to build the library. Known Bugs """""""""" Current version should be compiled using SWIG 1.3.27. Using 1.3.28+ an error similar to may be generated by the compiler: src\win32_pykcs11_wrap.cpp error C2440: 'static_cast' : cannot convert from 'char *' to 'unsigned char *' The precompiled wrapper included in distribution is being generated using SWIG 1.3.27. If in Windows the linker complains that the Python24_d.lib doesn't exists Please edit the "SWIG-Install-Dir\Lib\python\python.swg" file and replace following line: #include "Python.h" with following code: #ifdef _DEBUG #undef _DEBUG #include "Python.h" #define _DEBUG #else #include "Python.h" #endif This prevents the linker to try to link against the debug version of python lib that doesn't come with the standard distribution. History """"""" 1.2.4 - April 2012, Ludovic Rousseau - improve epydoc documentation - add pinpad support in C_Login() using pin=None - add pinpad support in samples getinfo.py and dumpit.py - add createObject() 1.2.3 - December 2010, Ludovic Rousseau - Add new classes CK_SLOT_INFO, CK_INFO, CK_SESSION_INFO, CK_MECHANISM_INFO and CK_TOKEN_INFO instead of the low level ones to have a __repr__() method. It is now possible to just print an object of these classes and have a human readable version. - Add a new class CK_OBJECT_HANDLE() to replace the low level one and have a __repr__() method for objects returned by findObjects() - Move initToken() from class Session to class PyKCS11Lib and add a slot parameter. - Add generateKeyPair and destoryObject support in high level interface 1.2.2 - June 2010, Ludovic Rousseau Debug low level C_GenerateRandom Add seedRandom() and generateRandom() in the high level API 1.2.1 - November 2008, Ludovic Rousseau Use src/opensc/pkcs11.h instead of src/rsaref/* files since the files from RSA are not free enough (no right to distribute modified versions for example) improve samples/getinfo.py script bug fixes 1.2.0 - August 2008, Ludovic Rousseau add getMechanismList() and getMechanismInfo() add Session().getSessionInfo() bug fixes 1.1.1 - December 2006, Giuseppe Amato (Midori) bug fixes 1.1.0 - August 2006, Ludovic Rousseau Introduce high level API 1.0.2 - July 2006, Ludovic Rousseau port to Unix (tested on GNU/Linux only) explicit call to SWIG to generate the wrapper 1.0.1 - 2004 Giuseppe Amato (Midori) first version Windows only PyKCS11-1.2.4/samples/0000755000175000017500000000000011744467602016026 5ustar rousseaurousseau00000000000000PyKCS11-1.2.4/samples/LowLevel/0000755000175000017500000000000011744467602017557 5ustar rousseaurousseau00000000000000PyKCS11-1.2.4/samples/LowLevel/test.py0000755000175000017500000000761411406076773021123 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import PyKCS11.LowLevel a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = "incryptoki2.dll" session = PyKCS11.LowLevel.CK_SESSION_HANDLE() sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() slotList = PyKCS11.LowLevel.ckintlist() pin = "12345678" print "Load of " + lib + ": " + str(a.Load(lib, 1)) print "C_GetInfo: " + hex(a.C_GetInfo(info)) print "Library manufacturerID: " + info.GetManufacturerID() del info print "C_GetSlotList(NULL): " + hex(a.C_GetSlotList(0, slotList)) print "\tAvailable Slots: " + str(len(slotList)) for x in range(len(slotList)): print "\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slotList[x], slotInfo)) print "\t\tSlot N." + str(x) + ": ID=" + str(slotList[x]) + ", name='" + slotInfo.GetSlotDescription() + "'" print "\tC_OpenSession(): " + hex(a.C_OpenSession(slotList[x], PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session)) print "\t\tSession:" + str(session) print "\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo)) print "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) print "\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[x], tokenInfo)) print "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() print "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() print "\tC_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin)) print "\tC_Logout(): " + hex(a.C_Logout(session)) print "\tC_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_OpenSession(): " + hex(a.C_OpenSession(slotList[0], PyKCS11.LowLevel.CKF_SERIAL_SESSION, session)) print "C_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin)) SearchResult = PyKCS11.ckobjlist(10) SearchTemplate = PyKCS11.ckattrlist(2) SearchTemplate[0].SetNum(PyKCS11.LowLevel.CKA_CLASS, PyKCS11.LowLevel.CKO_CERTIFICATE) SearchTemplate[1].SetBool(PyKCS11.LowLevel.CKA_TOKEN, True) print "C_FindObjectsInit: " + hex(a.C_FindObjectsInit(session, SearchTemplate)) print "C_FindObjects: " + hex(a.C_FindObjects(session, SearchResult)) print "C_FindObjectsFinal: " + hex(a.C_FindObjectsFinal(session)) for x in SearchResult: print "object: " + hex(x.value()) valTemplate = PyKCS11.ckattrlist(2) valTemplate[0].SetType(PyKCS11.LowLevel.CKA_LABEL) #valTemplate[0].Reserve(128) valTemplate[1].SetType(PyKCS11.LowLevel.CKA_CLASS) #valTemplate[1].Reserve(4) print "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) print "CKA_LABEL Len: ", valTemplate[0].GetLen(), " CKA_CLASS Len: ", valTemplate[1].GetLen() print "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) print "\tCKO_CERTIFICATE: " + valTemplate[0].GetString() print "\tCKA_TOKEN: " + str(valTemplate[1].GetNum()) print "C_Logout(): " + hex(a.C_Logout(session)) print "C_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_Finalize(): " + hex(a.C_Finalize()) print a.Unload() PyKCS11-1.2.4/samples/LowLevel/InitTokenPin.py0000755000175000017500000000644111406076773022514 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import PyKCS11.LowLevel a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = "pkcs11_lib.dll" session = PyKCS11.LowLevel.CK_SESSION_HANDLE() sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() slotList = PyKCS11.LowLevel.ckintlist() pin = "123456" puk = "12345678" Label = "PyKCS#11 Initialized Token " print "Load of " + lib + ": " + str(a.Load(lib, 1)) print "C_GetInfo: " + hex(a.C_GetInfo(info)) print "Library manufacturerID: " + info.GetManufacturerID() del info print "C_GetSlotList(NULL): " + hex(a.C_GetSlotList(1, slotList)) print "\tAvailable Slots: " + str(len(slotList)) if len(slotList) != 0: print "\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slotList[0], slotInfo)) print "\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[0], tokenInfo)) print "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() print "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() print "\tC_InitToken(): " + hex(a.C_InitToken(slotList[0], puk, Label)) print "\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[0], tokenInfo)) print "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() print "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() print "\tC_OpenSession(): " + hex(a.C_OpenSession(slotList[0], PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session)) print "\t\tSession:" + str(session) print "\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo)) print "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) print "\tC_Login(SO): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_SO, puk)) print "\tC_InitPIN(): " + hex(a.C_InitPIN(session, pin)) print "\tC_Logout(SO): " + hex(a.C_Logout(session)) print "\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[0], tokenInfo)) print "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() print "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() print "C_Login(USER): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin)) print "C_Logout(USER): " + hex(a.C_Logout(session)) print "C_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_Finalize(): " + hex(a.C_Finalize()) print a.Unload() PyKCS11-1.2.4/samples/LowLevel/test1.py0000755000175000017500000001010011406076773021164 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import PyKCS11.LowLevel a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = "/usr/lib/libopensc.so" session = PyKCS11.LowLevel.CK_SESSION_HANDLE() sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() slotList = PyKCS11.LowLevel.ckintlist() pin = "1234" print "Load of " + lib + ": " + str(a.Load(lib, 1)) print "C_GetInfo: " + hex(a.C_GetInfo(info)) print "Library manufacturerID: " + info.GetManufacturerID() del info print "C_GetSlotList(NULL): " + hex(a.C_GetSlotList(0, slotList)) print "\tAvailable Slots: " + str(len(slotList)) for x in range(len(slotList)): print "\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slotList[x], slotInfo)) print "\t\tSlot N." + str(x) + ": ID=" + str(slotList[x]) + ", name='" + slotInfo.GetSlotDescription() + "'" print "\tC_OpenSession(): " + hex(a.C_OpenSession(slotList[x], PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session)) print "\t\tSession:" + str(session) print "\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo)) print "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) print "\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[x], tokenInfo)) print "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() print "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() print "\tC_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin)) print "\tC_Logout(): " + hex(a.C_Logout(session)) print "\tC_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_OpenSession(): " + hex(a.C_OpenSession(slotList[0], PyKCS11.LowLevel.CKF_RW_SESSION | PyKCS11.LowLevel.CKF_SERIAL_SESSION, session)) print "C_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin)) SearchResult = PyKCS11.LowLevel.ckobjlist(10) SearchTemplate = PyKCS11.LowLevel.ckattrlist(2) SearchTemplate[0].SetNum(PyKCS11.LowLevel.CKA_CLASS, PyKCS11.LowLevel.CKO_CERTIFICATE) SearchTemplate[1].SetBool(PyKCS11.LowLevel.CKA_TOKEN, True) print "C_FindObjectsInit: " + hex(a.C_FindObjectsInit(session, SearchTemplate)) print "C_FindObjects: " + hex(a.C_FindObjects(session, SearchResult)) print "C_FindObjectsFinal: " + hex(a.C_FindObjectsFinal(session)) for x in SearchResult: print "object " + hex(x.value()) valTemplate = PyKCS11.LowLevel.ckattrlist(1) valTemplate[0].SetType(PyKCS11.LowLevel.CKA_ISSUER) #valTemplate[0].Reserve(128) print "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) print "CKA_ISSUER Len: ", valTemplate[0].GetLen() print "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) binval = list(valTemplate[0].GetBin()) print "binval=", binval binval[0] = 0 valTemplate[0].SetBin(PyKCS11.LowLevel.CKA_ISSUER, binval) binval = valTemplate[0].GetBin() # list(valTemplate[0].GetBin()) print "binval[0]=", binval[0] binval[0] = 0 print "C_SetAttributeValue(): " + hex(a.C_SetAttributeValue(session, x, valTemplate)) print "C_Logout(): " + hex(a.C_Logout(session)) print "C_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_Finalize(): " + hex(a.C_Finalize()) print a.Unload() PyKCS11-1.2.4/samples/LowLevel/dumpit.py0000755000175000017500000001317011406076773021440 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # Copyright (C) 2006 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA from PyKCS11.LowLevel import * a = CPKCS11Lib() info = CK_INFO() slotInfo = CK_SLOT_INFO() lib = "incryptoki2.dll" session = CK_SESSION_HANDLE() sessionInfo = CK_SESSION_INFO() tokenInfo = CK_TOKEN_INFO() slotList = ckintlist() pin = "12345678" print "Load of " + lib + ": " + str(a.Load(lib, 1)) print "C_GetInfo: " + hex(a.C_GetInfo(info)) print "Library manufacturerID: " + info.GetManufacturerID() del info print "C_GetSlotList(NULL): " + hex(a.C_GetSlotList(0, slotList)) print "\tAvailable Slots: " + str(len(slotList)) for x in range(len(slotList)): print "\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slotList[x], slotInfo)) print "\t\tSlot N." + str(x) + ": ID=" + str(slotList[x]) + ", name='" + slotInfo.GetSlotDescription() + "'" print "\tC_OpenSession(): " + hex(a.C_OpenSession(slotList[x], CKF_SERIAL_SESSION | CKF_RW_SESSION, session)) print "\t\tSession:" + str(session) print "\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo)) print "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) print "\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[x], tokenInfo)) print "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() print "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() print "\tC_Login(): " + hex(a.C_Login(session, CKU_USER, pin)) print "\tC_Logout(): " + hex(a.C_Logout(session)) print "\tC_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_OpenSession(): " + hex(a.C_OpenSession(slotList[0], CKF_SERIAL_SESSION, session)) print "C_Login(): " + hex(a.C_Login(session, CKU_USER, pin)) SearchResult = ckobjlist(10) SearchTemplate = ckattrlist(0) #SearchTemplate[0].SetNum(CKA_CLASS, CKO_CERTIFICATE) #SearchTemplate[1].SetBool(CKA_TOKEN, True) print "C_FindObjectsInit: " + hex(a.C_FindObjectsInit(session, SearchTemplate)) print "C_FindObjects: " + hex(a.C_FindObjects(session, SearchResult)) print "C_FindObjectsFinal: " + hex(a.C_FindObjectsFinal(session)) attributes = [ ["CKA_CLASS", CKA_CLASS], ["CKA_TOKEN", CKA_TOKEN], ["CKA_PRIVATE", CKA_PRIVATE], ["CKA_LABEL", CKA_LABEL], ["CKA_APPLICATION", CKA_APPLICATION], ["CKA_VALUE", CKA_VALUE], ["CKA_CERTIFICATE_TYPE", CKA_CERTIFICATE_TYPE], ["CKA_ISSUER", CKA_ISSUER], ["CKA_SERIAL_NUMBER", CKA_SERIAL_NUMBER], ["CKA_KEY_TYPE", CKA_KEY_TYPE], ["CKA_SUBJECT", CKA_SUBJECT], ["CKA_ID", CKA_ID], ["CKA_SENSITIVE", CKA_SENSITIVE], ["CKA_ENCRYPT", CKA_ENCRYPT], ["CKA_DECRYPT", CKA_DECRYPT], ["CKA_WRAP", CKA_WRAP], ["CKA_UNWRAP", CKA_UNWRAP], ["CKA_SIGN", CKA_SIGN], ["CKA_SIGN_RECOVER", CKA_SIGN_RECOVER], ["CKA_VERIFY", CKA_VERIFY], ["CKA_VERIFY_RECOVER", CKA_VERIFY_RECOVER], ["CKA_DERIVE", CKA_DERIVE], ["CKA_START_DATE", CKA_START_DATE], ["CKA_END_DATE", CKA_END_DATE], ["CKA_MODULUS", CKA_MODULUS], ["CKA_MODULUS_BITS", CKA_MODULUS_BITS], ["CKA_PUBLIC_EXPONENT", CKA_PUBLIC_EXPONENT], ["CKA_PRIVATE_EXPONENT", CKA_PRIVATE_EXPONENT], ["CKA_PRIME_1", CKA_PRIME_1], ["CKA_PRIME_2", CKA_PRIME_2], ["CKA_EXPONENT_1", CKA_EXPONENT_1], ["CKA_EXPONENT_2", CKA_EXPONENT_2], ["CKA_COEFFICIENT", CKA_COEFFICIENT], ["CKA_PRIME", CKA_PRIME], ["CKA_SUBPRIME", CKA_SUBPRIME], ["CKA_BASE", CKA_BASE], ["CKA_VALUE_BITS", CKA_VALUE_BITS], ["CKA_VALUE_LEN", CKA_VALUE_LEN], ["CKA_EXTRACTABLE", CKA_EXTRACTABLE], ["CKA_LOCAL", CKA_LOCAL], ["CKA_NEVER_EXTRACTABLE", CKA_NEVER_EXTRACTABLE], ["CKA_ALWAYS_SENSITIVE", CKA_ALWAYS_SENSITIVE], ["CKA_MODIFIABLE", CKA_MODIFIABLE], ["CKA_ECDSA_PARAMS", CKA_ECDSA_PARAMS], ["CKA_EC_POINT", CKA_EC_POINT], ] for x in SearchResult: print "object: " + hex(x.value()) valTemplate = ckattrlist(1) for attr in attributes: valTemplate[0].Reset() valTemplate[0].SetType(attr[1]) # first call to get the attribute size and reserve the memory a.C_GetAttributeValue(session, x, valTemplate) # second call to get the attribute value rv = a.C_GetAttributeValue(session, x, valTemplate) if (rv == CKR_OK): print "\t" + attr[0] + ": ", if (valTemplate[0].IsNum()): print valTemplate[0].GetNum() if (valTemplate[0].IsBool()): print valTemplate[0].GetBool() if (valTemplate[0].IsString()): print valTemplate[0].GetString() if (valTemplate[0].IsBin()): print "(" + str(valTemplate[0].GetLen()) + " bytes)", print map(hex, valTemplate[0].GetBin()) print "C_Logout(): " + hex(a.C_Logout(session)) print "C_CloseSession(): " + hex(a.C_CloseSession(session)) print "C_Finalize(): " + hex(a.C_Finalize()) print a.Unload() PyKCS11-1.2.4/samples/dumpit.py0000755000175000017500000002303111702037451017671 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2006-2008 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import PyKCS11 import getopt import sys import platform # from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/142812 # Title: Hex dumper # Submitter: Sebastien Keim (other recipes) # Last Updated: 2002/08/05 # Version no: 1.0 def hexx(intval): x = hex(intval)[2:] if (x[-1:].upper() == 'L'): x = x[:-1] if len(x) % 2 != 0: return "0%s" % x return x def dump(src, length=8): FILTER = ''.join([(len(repr(chr(x))) == 3) and chr(x) or '.' for x in range(256)]) N = 0 result = '' while src: s, src = src[:length], src[length:] hexa = ' '.join(["%02X" % ord(x) for x in s]) s = s.translate(FILTER) result += "%04X %-*s %s\n" % (N, length * 3, hexa, s) N += length return result def usage(): print "Usage:", sys.argv[0], print "[-p pin][--pin=pin] (use --pin=NULL for pinpad)", print "[-c lib][--lib=lib]", print "[-S][--sign]", print "[-d][--decrypt]", print "[-h][--help]", try: opts, args = getopt.getopt(sys.argv[1:], "p:c:Sd:h", ["pin=", "lib=", "sign", "decrypt", "help"]) except getopt.GetoptError: # print help information and exit: usage() sys.exit(2) pin_available = False decrypt = sign = False lib = None for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() elif o in ("-p", "--pin"): pin = a if pin == "NULL": pin = None pin_available = True elif o in ("-c", "--lib"): lib = a print "using PKCS11 lib:", lib elif o in ("-S", "--sign"): sign = True elif o in ("-d", "--decrypt"): decrypt = True red = blue = magenta = normal = "" if sys.stdout.isatty() and platform.system().lower() != 'windows': red = "\x1b[01;31m" blue = "\x1b[34m" magenta = "\x1b[35m" normal = "\x1b[0m" format_long = magenta + " %s:" + blue + " %s (%s)" + normal format_binary = magenta + " %s:" + blue + " %d bytes" + normal format_normal = magenta + " %s:" + blue + " %s" + normal pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load(lib) info = pkcs11.getInfo() print "Library manufacturerID: " + info.manufacturerID slots = pkcs11.getSlotList() print "Available Slots:", len(slots) for s in slots: try: i = pkcs11.getSlotInfo(s) print "Slot no:", s print format_normal % ("slotDescription", i.slotDescription.strip()) print format_normal % ("manufacturerID", i.manufacturerID.strip()) t = pkcs11.getTokenInfo(s) print "TokenInfo" print format_normal % ("label", t.label.strip()) print format_normal % ("manufacturerID", t.manufacturerID.strip()) print format_normal % ("model", t.model.strip()) session = pkcs11.openSession(s) print "Opened session 0x%08X" % session.session.value() if pin_available: try: session.login(pin=pin) except: print "login failed, exception:", str(sys.exc_info()[1]) objects = session.findObjects() print print "Found %d objects: %s" % (len(objects), [x.value() for x in objects]) all_attributes = PyKCS11.CKA.keys() # remove the CKR_ATTRIBUTE_SENSITIVE attributes since we can't get # their values and will get an exception instead all_attributes.remove(PyKCS11.CKA_PRIVATE_EXPONENT) all_attributes.remove(PyKCS11.CKA_PRIME_1) all_attributes.remove(PyKCS11.CKA_PRIME_2) all_attributes.remove(PyKCS11.CKA_EXPONENT_1) all_attributes.remove(PyKCS11.CKA_EXPONENT_2) all_attributes.remove(PyKCS11.CKA_COEFFICIENT) # only use the integer values and not the strings like 'CKM_RSA_PKCS' all_attributes = [e for e in all_attributes if isinstance(e, int)] for o in objects: print print (red + "==================== Object: %d ====================" + normal) % o.value() attributes = session.getAttributeValue(o, all_attributes) attrDict = dict(zip(all_attributes, attributes)) if attrDict[PyKCS11.CKA_CLASS] == PyKCS11.CKO_PRIVATE_KEY \ and attrDict[PyKCS11.CKA_KEY_TYPE] == PyKCS11.CKK_RSA: m = attrDict[PyKCS11.CKA_MODULUS] e = attrDict[PyKCS11.CKA_PUBLIC_EXPONENT] if m and e: mx = eval('0x%s' % ''.join(chr(c) for c in m).encode('hex')) ex = eval('0x%s' % ''.join(chr(c) for c in e).encode('hex')) if sign: try: toSign = "12345678901234567890" # 20 bytes, SHA1 digest print "* Signing with object 0x%08X following data: %s" % (o.value(), toSign) signature = session.sign(o, toSign) s = ''.join(chr(c) for c in signature).encode('hex') sx = eval('0x%s' % s) print "Signature:" print dump(''.join(map(chr, signature)), 16) if m and e: print "Verifying using following public key:" print "Modulus:" print dump(''.join(map(chr, m)), 16) print "Exponent:" print dump(''.join(map(chr, e)), 16) decrypted = pow(sx, ex, mx) # RSA print "Decrypted:" d = hexx(decrypted).decode('hex') print dump(d, 16) if toSign == d[-20:]: print "*** signature VERIFIED!\n" else: print "*** signature NOT VERIFIED; decrypted value:" print hex(decrypted), "\n" else: print "Unable to verify signature: MODULUS/PUBLIC_EXP not found" except: print "Sign failed, exception:", str(sys.exc_info()[1]) if decrypt: if m and e: try: toEncrypt = "12345678901234567890" # note: PKCS1 BT2 padding should be random data, # but this is just a test and we use 0xFF... padded = "\x00\x02%s\x00%s" % ("\xFF" * (128 - (len(toEncrypt)) - 3), toEncrypt) print "* Decrypting with 0x%08X following data: %s" % (o.value(), toEncrypt) print "padded:\n", dump(padded, 16) encrypted = pow(eval('0x%sL' % padded.encode('hex')), ex, mx) # RSA encrypted1 = hexx(encrypted).decode('hex') print "encrypted:\n", dump(encrypted1, 16) decrypted = session.decrypt(o, encrypted1) decrypted1 = ''.join(chr(i) for i in decrypted) print "decrypted:\n", dump(decrypted1, 16) if decrypted1 == toEncrypt: print "decryption SUCCESSFULL!\n" else: print "decryption FAILED!\n" except: print "Decrypt failed, exception:", str(sys.exc_info()[1]) else: print "ERROR: Private key don't have MODULUS/PUBLIC_EXP" print "Dumping attributes:" for q, a in zip(all_attributes, attributes): if a == None: # undefined (CKR_ATTRIBUTE_TYPE_INVALID) attribute continue if q == PyKCS11.CKA_CLASS: print format_long % (PyKCS11.CKA[q], PyKCS11.CKO[a], a) elif q == PyKCS11.CKA_CERTIFICATE_TYPE: print format_long % (PyKCS11.CKA[q], PyKCS11.CKC[a], a) elif q == PyKCS11.CKA_KEY_TYPE: print format_long % (PyKCS11.CKA[q], PyKCS11.CKK[a], a) elif session.isBin(q): print format_binary % (PyKCS11.CKA[q], len(a)) if a: print dump(''.join(map(chr, a)), 16), elif q == PyKCS11.CKA_SERIAL_NUMBER: print format_binary % (PyKCS11.CKA[q], len(a)) if a: print dump(a, 16), else: print format_normal % (PyKCS11.CKA[q], a) print if pin_available: try: session.logout() except: print "logout failed, exception:", str(sys.exc_info()[1]) session.closeSession() except PyKCS11.PyKCS11Error, e: print "Error:", e PyKCS11-1.2.4/samples/getinfo.py0000755000175000017500000001056111702037451020026 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2006-2010 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import PyKCS11 import platform import sys class getInfo(object): red = blue = magenta = normal = "" def colorize(self, text, arg): print self.magenta + text + self.blue, arg, self.normal def display(self, obj, indent=""): dico = obj.to_dict() for key in sorted(dico.keys()): type = obj.fields[key] left = indent + key + ":" if type == "flags": self.colorize(left, ", ".join(dico[key])) elif type == "pair": self.colorize(left, "%d.%d" % dico[key]) else: self.colorize(left, dico[key]) def __init__(self, lib=None): if sys.stdout.isatty() and platform.system().lower() != 'windows': self.red = "\x1b[01;31m" self.blue = "\x1b[34m" self.magenta = "\x1b[35m" self.normal = "\x1b[0m" self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load(lib) def getSlotInfo(self, slot): print "Slot n.:", slot self.display(self.pkcs11.getSlotInfo(slot), " ") def getTokenInfo(self, slot): print " TokenInfo" self.display(self.pkcs11.getTokenInfo(slot), " ") def getMechanismInfo(self, slot): print " Mechanism list: " m = self.pkcs11.getMechanismList(slot) for x in m: self.colorize(" ", x) i = self.pkcs11.getMechanismInfo(slot, x) if not i.flags & PyKCS11.CKF_DIGEST: if i.ulMinKeySize != PyKCS11.CK_UNAVAILABLE_INFORMATION: self.colorize(" ulMinKeySize:", i.ulMinKeySize) if i.ulMaxKeySize != PyKCS11.CK_UNAVAILABLE_INFORMATION: self.colorize(" ulMaxKeySize:", i.ulMaxKeySize) self.colorize(" flags:", ", ".join(i.flags2text())) def getInfo(self): self.display(self.pkcs11.getInfo()) def getSessionInfo(self, slot, pin=""): print " SessionInfo", session = self.pkcs11.openSession(slot) if pin != "": if pin == None: print "(using pinpad)" else: print "(using pin: %s)" % pin session.login(pin) else: print self.display(session.getSessionInfo(), " ") if pin: session.logout() def usage(): print "Usage:", sys.argv[0], print "[-p pin][--pin=pin] (use 'NULL' for pinpad)", print "[-s slot][--slot=slot]", print "[-c lib][--lib=lib]", print "[-h][--help]" if __name__ == '__main__': import getopt try: opts, args = getopt.getopt(sys.argv[1:], "p:s:c:ho", ["pin=", "slot=", "lib=", "help", "opensession"]) except getopt.GetoptError: # print help information and exit: usage() sys.exit(2) slot = None lib = None pin = "" for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() if o in ("-p", "--pin"): pin = a if pin == "NULL": pin = None if o in ("-s", "--slot"): slot = int(a) if o in ("-c", "--lib"): lib = a gi = getInfo(lib) gi.getInfo() slots = gi.pkcs11.getSlotList() print "Available Slots:", len(slots), slots if len(slots) == 0: sys.exit(2) if slot: slots = [slots[slot]] for slot in slots: try: gi.getSlotInfo(slot) gi.getSessionInfo(slot, pin) gi.getTokenInfo(slot) gi.getMechanismInfo(slot) except PyKCS11.PyKCS11Error, e: print "Error:", e PyKCS11-1.2.4/samples/unblock.py0000755000175000017500000000204711406076773020043 0ustar rousseaurousseau00000000000000#!/usr/bin/env python # Copyright (C) 2006 Ludovic Rousseau # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import PyKCS11 pin = "1234" puk = "1234" pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() slot = pkcs11.getSlotList()[0] session = pkcs11.openSession(slot, PyKCS11.CKF_RW_SESSION) session.login(puk, PyKCS11.CKU_SO) session.initPin(pin) session.logout() session.closeSession() PyKCS11-1.2.4/COPYING0000644000175000017500000004310311055022765015406 0ustar rousseaurousseau00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. PyKCS11-1.2.4/setup.py0000755000175000017500000000567411744463710016107 0ustar rousseaurousseau00000000000000#! /usr/bin/env python # python setup.py install --root=/tmp/p # PYTHONPATH=/tmp/p/usr/lib/python2.4/site-packages python test.py from distutils.core import setup, Extension from sys import version_info as pyver from os import path import platform description = '''A complete PKCS#11 wrapper for Python. You can use any PKCS#11 (aka CryptoKi) module such as the PSM which comes as part of mozilla or the various modules supplied by vendors of hardware crypto tokens, and almost all PKCS#11 functions and data types. The wrapper has been generated with the help of the SWIG compiler.''' classifiers = ["Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: GNU General Public License (GPL)", "Natural Language :: English", "Operating System :: Microsoft :: Windows", "Operating System :: OS Independent", "Operating System :: Unix", "Programming Language :: C", "Programming Language :: C++", "Programming Language :: Python", "Topic :: Security :: Cryptography", "Topic :: Software Development :: Libraries :: Python Modules"] lib_dirs = [] inc_dirs = ["src"] # some OS, such as FreeBSD, uses /usr/local folders if path.exists("/usr/local"): lib_dirs.append("/usr/local/lib") inc_dirs.append("/usr/local/include") source_files = ["src/ck_attribute_smart.cpp", "src/pkcs11lib.cpp", "src/pykcs11string.cpp", "src/utility.cpp", "src/pykcs11.cpp"] define_macros = [] extra_compile_args = [] extra_link_args = [] if (platform.system().lower() == 'windows'): source_files.append("src/dyn_win32.c") source_files.append("pykcs11.rc") source_files.append("src/win32_pykcs11_wrap.cpp") libraries_val = ["python%d%d" % pyver[:2]] extra_compile_args = ["/Fdvc70.pdb", "/Zi", "/GR"] extra_link_args = ["/DEBUG", "/PDB:_LowLevel.pdb", "/SUBSYSTEM:WINDOWS", "/OPT:REF", "/OPT:ICF"] else: source_files.append("src/dyn_unix.c") source_files.append("src/unix_pykcs11_wrap.cpp") libraries_val = ["python%d.%d" % pyver[:2]] setup(name="PyKCS11", version="1.2.4", description="A Full PKCS#11 wrapper for Python", keywords="crypto,pki,pkcs11,c++", classifiers=classifiers, platforms="Win32 Unix", long_description=description, author="Giuseppe Amato (Midori)", author_email="paipai at tiscali.it", maintainer="Ludovic Rousseau", maintainer_email="ludovic.rousseau@free.fr", url="http://www.bit4id.org/trac/pykcs11", download_url="http://www.bit4id.org/trac/pykcs11/wiki/Download", license="GPL", ext_modules=[ Extension( "PyKCS11._LowLevel", sources=source_files, include_dirs=inc_dirs, library_dirs=lib_dirs, libraries=libraries_val, define_macros=define_macros, extra_compile_args=extra_compile_args, extra_link_args=extra_link_args)], py_modules=["PyKCS11.__init__", "PyKCS11.LowLevel"], ) PyKCS11-1.2.4/pykcs11.rc0000644000175000017500000000535711101071217016171 0ustar rousseaurousseau00000000000000// Microsoft Visual C++ generated resource script. // #include "resource.h" #define APSTUDIO_READONLY_SYMBOLS ///////////////////////////////////////////////////////////////////////////// // // Generated from the TEXTINCLUDE 2 resource. // #include "afxres.h" ///////////////////////////////////////////////////////////////////////////// #undef APSTUDIO_READONLY_SYMBOLS ///////////////////////////////////////////////////////////////////////////// // English (U.S.) resources #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) #ifdef _WIN32 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US #pragma code_page(1252) #endif //_WIN32 #ifdef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // TEXTINCLUDE // 1 TEXTINCLUDE BEGIN "resource.h\0" END 2 TEXTINCLUDE BEGIN "#include ""afxres.h""\r\n" "\0" END 3 TEXTINCLUDE BEGIN "\r\n" "\0" END #endif // APSTUDIO_INVOKED #endif // English (U.S.) resources ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// // Italian (Italy) resources #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ITA) #ifdef _WIN32 LANGUAGE LANG_ITALIAN, SUBLANG_ITALIAN #pragma code_page(1252) #endif //_WIN32 ///////////////////////////////////////////////////////////////////////////// // // Version // VS_VERSION_INFO VERSIONINFO FILEVERSION 1,2,0,0 PRODUCTVERSION 1,2,0,0 FILEFLAGSMASK 0x17L #ifdef _DEBUG FILEFLAGS 0x1L #else FILEFLAGS 0x0L #endif FILEOS 0x4L FILETYPE 0x2L FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "000004b0" BEGIN VALUE "Comments", "_LowLevel module" VALUE "FileDescription", "PKCS#11 wrapper for Python (_LowLevel)" VALUE "FileVersion", "1, 1, 1, 0" VALUE "InternalName", "pykcs11" VALUE "LegalCopyright", "Copyright (C) 2004-2006 Giuseppe Amato (paipai -at- tiscali dot it)" VALUE "OriginalFilename", "pykcs11.dll" VALUE "ProductName", " pykcs11 Dynamic Link Library" VALUE "ProductVersion", "1, 1, 1, 0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x0, 1200 END END #endif // Italian (Italy) resources ///////////////////////////////////////////////////////////////////////////// #ifndef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // // Generated from the TEXTINCLUDE 3 resource. // ///////////////////////////////////////////////////////////////////////////// #endif // not APSTUDIO_INVOKED PyKCS11-1.2.4/PKG-INFO0000644000175000017500000000240511744467602015460 0ustar rousseaurousseau00000000000000Metadata-Version: 1.1 Name: PyKCS11 Version: 1.2.4 Summary: A Full PKCS#11 wrapper for Python Home-page: http://www.bit4id.org/trac/pykcs11 Author: Ludovic Rousseau Author-email: ludovic.rousseau@free.fr License: GPL Download-URL: http://www.bit4id.org/trac/pykcs11/wiki/Download Description: A complete PKCS#11 wrapper for Python. You can use any PKCS#11 (aka CryptoKi) module such as the PSM which comes as part of mozilla or the various modules supplied by vendors of hardware crypto tokens, and almost all PKCS#11 functions and data types. The wrapper has been generated with the help of the SWIG compiler. Keywords: crypto,pki,pkcs11,c++ Platform: Win32 Unix Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: GNU General Public License (GPL) Classifier: Natural Language :: English Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: OS Independent Classifier: Operating System :: Unix Classifier: Programming Language :: C Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Topic :: Security :: Cryptography Classifier: Topic :: Software Development :: Libraries :: Python Modules PyKCS11-1.2.4/PyKCS11/0000755000175000017500000000000011744467602015455 5ustar rousseaurousseau00000000000000PyKCS11-1.2.4/PyKCS11/__init__.py0000644000175000017500000011330011744463710017560 0ustar rousseaurousseau00000000000000# Copyright (C) 2006-2012 Ludovic Rousseau (ludovic.rousseau@free.fr) # Copyright (C) 2010 Giuseppe Amato (additions to original interface) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # $Id: __init__.py 242 2012-04-21 06:49:12Z lrousseau $ import PyKCS11.LowLevel import os # redefine PKCS#11 constants CK_TRUE = PyKCS11.LowLevel.CK_TRUE CK_FALSE = PyKCS11.LowLevel.CK_FALSE CK_UNAVAILABLE_INFORMATION = PyKCS11.LowLevel.CK_UNAVAILABLE_INFORMATION CK_EFFECTIVELY_INFINITE = PyKCS11.LowLevel.CK_EFFECTIVELY_INFINITE CK_INVALID_HANDLE = PyKCS11.LowLevel.CK_INVALID_HANDLE CKM = {} CKR = {} CKA = {} CKO = {} CKU = {} CKK = {} CKC = {} CKF = {} CKS = {} # redefine PKCS#11 constants using well known prefixes for x in PyKCS11.LowLevel.__dict__.keys(): if x[:4] == 'CKM_' \ or x[:4] == 'CKR_' \ or x[:4] == 'CKA_' \ or x[:4] == 'CKO_' \ or x[:4] == 'CKU_' \ or x[:4] == 'CKK_' \ or x[:4] == 'CKC_' \ or x[:4] == 'CKF_' \ or x[:4] == 'CKS_': a = "%s=PyKCS11.LowLevel.%s" % (x, x) exec(a) if x[3:] != "_VENDOR_DEFINED": eval(x[:3])[eval(x)] = x # => CKM[CKM_RSA_PKCS] = 'CKM_RSA_PKCS' eval(x[:3])[x] = eval(x) # => CKM['CKM_RSA_PKCS'] = CKM_RSA_PKCS # special CKR[] values CKR[-2] = "Unkown PKCS#11 type" CKR[-1] = "Load" class ckbytelist(PyKCS11.LowLevel.ckbytelist): """ add a __repr__() method to the LowLevel equivalent """ def __repr__(self): """ return the representation of a tuple the __str__ method will use it also """ rep = [elt for elt in self] return repr(rep) class byteArray(PyKCS11.LowLevel.byteArray): """ add a __repr__() method to the LowLevel equivalent """ def __repr__(self): """ return the representation of a tuple the __str__ method will use it also """ rep = [elt for elt in self] return repr(rep) class CK_OBJECT_HANDLE(PyKCS11.LowLevel.CK_OBJECT_HANDLE): """ add a __repr__() method to the LowLevel equivalent """ def __init__(self, session): PyKCS11.LowLevel.CK_OBJECT_HANDLE.__init__(self) self.session = session pass def to_dict(self): """ convert the fields of the object into a dictionnary """ # all the attibutes defined by PKCS#11 all_attributes = PyKCS11.CKA.keys() # only use the integer values and not the strings like 'CKM_RSA_PKCS' all_attributes = [attr for attr in all_attributes if isinstance(attr, int)] # all the attributes of the object attributes = self.session.getAttributeValue(self, all_attributes) dico = dict() for key, attr in zip(all_attributes, attributes): if attr == None: continue if key == CKA_CLASS: dico[PyKCS11.CKA[key]] = PyKCS11.CKO[attr] elif key == CKA_CERTIFICATE_TYPE: dico[PyKCS11.CKA[key]] = PyKCS11.CKC[attr] elif key == CKA_KEY_TYPE: dico[PyKCS11.CKA[key]] = PyKCS11.CKK[attr] else: dico[PyKCS11.CKA[key]] = attr return dico def __repr__(self): """ text representation of the object """ dico = self.to_dict() lines = list() for key in sorted(dico.keys()): lines.append("%s: %s" % (key, dico[key])) return "\n".join(lines) class CkClass(object): """ Base class for CK_* classes """ # dictionnary of integer_value: text_value for the flags bits flags_dict = dict() # dictionnary of fields names and types # type can be "pair", "flags" or "text" fields = dict() flags = 0 def flags2text(self): """ parse the L{self.flags} field and create a list of "CKF_*" strings corresponding to bits set in flags @return: a list of strings @rtype: list """ r = [] for v in self.flags_dict.keys(): if self.flags & v: r.append(self.flags_dict[v]) return r def to_dict(self): """ convert the fields of the object into a dictionnary """ dico = dict() for field in self.fields.keys(): if field == "flags": dico[field] = self.flags2text() else: dico[field] = eval("self." + field) return dico def __str__(self): """ text representation of the object """ dico = self.to_dict() lines = list() for key in sorted(dico.keys()): type = self.fields[key] if type == "flags": lines.append("%s: %s" % (key, ", ".join(dico[key]))) elif type == "pair": lines.append("%s: " % key + "%d.%d" % dico[key]) else: lines.append("%s: %s" % (key, dico[key])) return "\n".join(lines) class CK_SLOT_INFO(CkClass): """ matches the PKCS#11 CK_SLOT_INFO structure @ivar slotDescription: blank padded @type slotDescription: string @ivar manufacturerID: blank padded @type manufacturerID: string @ivar flags: See L{flags2text} @type flags: integer @ivar hardwareVersion: 2 elements list @type hardwareVersion: list @ivar firmwareVersion: 2 elements list @type firmwareVersion: list """ flags_dict = { CKF_TOKEN_PRESENT: "CKF_TOKEN_PRESENT", CKF_REMOVABLE_DEVICE: "CKF_REMOVABLE_DEVICE", CKF_HW_SLOT: "CKF_HW_SLOT"} fields = {"slotDescription": "text", "manufacturerID": "text", "flags": "flags", "hardwareVersion": "text", "firmwareVersion": "text"} class CK_INFO(CkClass): """ matches the PKCS#11 CK_INFO structure @ivar cryptokiVersion: Cryptoki interface version @type cryptokiVersion: integer @ivar manufacturerID: blank padded @type manufacturerID: string @ivar flags: must be zero @type flags: integer @ivar libraryDescription: blank padded @type libraryDescription: string @ivar libraryVersion: 2 elements list @type libraryVersion: list """ fields = {"cryptokiVersion": "pair", "manufacturerID": "text", "flags": "flags", "libraryDescription": "text", "libraryVersion": "pair"} class CK_SESSION_INFO(CkClass): """ matches the PKCS#11 CK_SESSION_INFO structure @ivar slotID: ID of the slot that interfaces with the token @type slotID: integer @ivar state: state of the session @type state: integer @ivar flags: bit flags that define the type of session @type flags: integer @ivar ulDeviceError: an error code defined by the cryptographic token @type ulDeviceError: integer """ flags_dict = { CKF_RW_SESSION: "CKF_RW_SESSION", CKF_SERIAL_SESSION: "CKF_SERIAL_SESSION", } def state2text(self): """ parse the L{self.state} field and return a "CKS_*" string corresponding to the state @return: a string @rtype: string """ return CKS[self.state] fields = {"slotID": "text", "state": "text", "flags": "flags", "ulDeviceError": "text"} class CK_TOKEN_INFO(CkClass): """ matches the PKCS#11 CK_TOKEN_INFO structure @ivar label: blank padded @type label: string @ivar manufacturerID: blank padded @type manufacturerID: string @ivar model: string blank padded @type model: string @ivar serialNumber: string blank padded @type serialNumber: string @ivar flags: @type flags: integer @ivar ulMaxSessionCount: @type ulMaxSessionCount: integer @ivar ulSessionCount: @type ulSessionCount: integer @ivar ulMaxRwSessionCount: @type ulMaxRwSessionCount: integer @ivar ulRwSessionCount: @type ulRwSessionCount: integer @ivar ulMaxPinLen: @type ulMaxPinLen: integer @ivar ulMinPinLen: @type ulMinPinLen: integer @ivar ulTotalPublicMemory: @type ulTotalPublicMemory: integer @ivar ulFreePublicMemory: @type ulFreePublicMemory: integer @ivar ulTotalPrivateMemory: @type ulTotalPrivateMemory: integer @ivar ulFreePrivateMemory: @type ulFreePrivateMemory: integer @ivar hardwareVersion: 2 elements list @type hardwareVersion: list @ivar firmwareVersion: 2 elements list @type firmwareVersion: list @ivar utcTime: string @type utcTime: string """ flags_dict = { CKF_RNG: "CKF_RNG", CKF_WRITE_PROTECTED: "CKF_WRITE_PROTECTED", CKF_LOGIN_REQUIRED: "CKF_LOGIN_REQUIRED", CKF_USER_PIN_INITIALIZED: "CKF_USER_PIN_INITIALIZED", CKF_RESTORE_KEY_NOT_NEEDED: "CKF_RESTORE_KEY_NOT_NEEDED", CKF_CLOCK_ON_TOKEN: "CKF_CLOCK_ON_TOKEN", CKF_PROTECTED_AUTHENTICATION_PATH: "CKF_PROTECTED_AUTHENTICATION_PATH", CKF_DUAL_CRYPTO_OPERATIONS: "CKF_DUAL_CRYPTO_OPERATIONS", CKF_TOKEN_INITIALIZED: "CKF_TOKEN_INITIALIZED", CKF_SECONDARY_AUTHENTICATION: "CKF_SECONDARY_AUTHENTICATION", CKF_USER_PIN_COUNT_LOW: "CKF_USER_PIN_COUNT_LOW", CKF_USER_PIN_FINAL_TRY: "CKF_USER_PIN_FINAL_TRY", CKF_USER_PIN_LOCKED: "CKF_USER_PIN_LOCKED", CKF_USER_PIN_TO_BE_CHANGED: "CKF_USER_PIN_TO_BE_CHANGED", CKF_SO_PIN_COUNT_LOW: "CKF_SO_PIN_COUNT_LOW", CKF_SO_PIN_FINAL_TRY: "CKF_SO_PIN_FINAL_TRY", CKF_SO_PIN_LOCKED: "CKF_SO_PIN_LOCKED", CKF_SO_PIN_TO_BE_CHANGED: "CKF_SO_PIN_TO_BE_CHANGED", } fields = {"label": "text", "manufacturerID": "text", "model": "text", "serialNumber": "text", "flags": "flags", "ulMaxSessionCount": "text", "ulSessionCount": "text", "ulMaxRwSessionCount": "text", "ulRwSessionCount": "text", "ulMaxPinLen": "text", "ulMinPinLen": "text", "ulTotalPublicMemory": "text", "ulFreePublicMemory": "text", "ulTotalPrivateMemory": "text", "ulFreePrivateMemory": "text", "hardwareVersion": "pair", "firmwareVersion": "pair", "utcTime": "text"} class CK_MECHANISM_INFO(CkClass): """ matches the PKCS#11 CK_MECHANISM_INFO structure @ivar ulMinKeySize: minimum size of the key @type ulMinKeySize: integer @ivar ulMaxKeySize: maximum size of the key @type ulMaxKeySize: integer @ivar flags: bit flags specifying mechanism capabilities @type flags: integer """ flags_dict = { CKF_HW: "CKF_HW", CKF_ENCRYPT: "CKF_ENCRYPT", CKF_DECRYPT: "CKF_DECRYPT", CKF_DIGEST: "CKF_DIGEST", CKF_SIGN: "CKF_SIGN", CKF_SIGN_RECOVER: "CKF_SIGN_RECOVER", CKF_VERIFY: "CKF_VERIFY", CKF_VERIFY_RECOVER: "CKF_VERIFY_RECOVER", CKF_GENERATE: "CKF_GENERATE", CKF_GENERATE_KEY_PAIR: "CKF_GENERATE_KEY_PAIR", CKF_WRAP: "CKF_WRAP", CKF_UNWRAP: "CKF_UNWRAP", CKF_DERIVE: "CKF_DERIVE", CKF_EXTENSION: "CKF_EXTENSION", } fields = {"ulMinKeySize": "text", "ulMaxKeySize": "text", "flags": "flags"} class PyKCS11Error(Exception): """ define the possible PKCS#11 error codes """ def __init__(self, value, text=""): self.value = value self.text = text def __str__(self): """ The text representation of a PKCS#11 error is something like: "CKR_DEVICE_ERROR (0x00000030)" """ if (self.value < 0): return CKR[self.value] + " (%s)" % self.text else: return CKR[self.value] + " (0x%08X)" % self.value class PyKCS11Lib(object): """ high level PKCS#11 binding """ def __init__(self): self.lib = PyKCS11.LowLevel.CPKCS11Lib() def __del__(self): self.lib.Unload() def load(self, pkcs11dll_filename=None, *init_string): """ load a PKCS#11 library @type pkcs11dll_filename: string @param pkcs11dll_filename: the library name. If this parameter is not set the environment variable PYKCS11LIB is used instead @return: a L{PyKCS11Lib} object @raise PyKCS11Error(-1): when the load fails """ if pkcs11dll_filename == None: pkcs11dll_filename = os.getenv("PYKCS11LIB") if pkcs11dll_filename == None: raise PyKCS11Error(-1, "No PKCS11 library specified (set PYKCS11LIB env variable)") rv = self.lib.Load(pkcs11dll_filename, 1) if rv == 0: raise PyKCS11Error(-1, pkcs11dll_filename) def initToken(self, slot, pin, label): """ C_InitToken """ rv = self.lib.C_InitToken(slot, pin, label) if rv != CKR_OK: raise PyKCS11Error(rv) def getInfo(self): """ C_GetInfo @return: a L{CK_INFO} object """ info = PyKCS11.LowLevel.CK_INFO() rv = self.lib.C_GetInfo(info) if rv != CKR_OK: raise PyKCS11Error(rv) i = CK_INFO() i.cryptokiVersion = (info.cryptokiVersion.major, info.cryptokiVersion.minor) i.manufacturerID = info.GetManufacturerID() i.flags = info.flags i.libraryDescription = info.GetLibraryDescription() i.libraryVersion = (info.libraryVersion.major, info.libraryVersion.minor) return i def getSlotList(self): """ C_GetSlotList @return: a list of available slots @rtype: list """ slotList = PyKCS11.LowLevel.ckintlist() rv = self.lib.C_GetSlotList(0, slotList) if rv != CKR_OK: raise PyKCS11Error(rv) s = [] for x in xrange(len(slotList)): s.append(slotList[x]) return s def getSlotInfo(self, slot): """ C_GetSlotInfo @param slot: slot number returned by L{getSlotList} @type slot: integer @return: a L{CK_SLOT_INFO} object """ slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() rv = self.lib.C_GetSlotInfo(slot, slotInfo) if rv != CKR_OK: raise PyKCS11Error(rv) s = CK_SLOT_INFO() s.slotDescription = slotInfo.GetSlotDescription() s.manufacturerID = slotInfo.GetManufacturerID() s.flags = slotInfo.flags s.hardwareVersion = slotInfo.GetHardwareVersion() s.firmwareVersion = slotInfo.GetFirmwareVersion() return s def getTokenInfo(self, slot): """ C_GetTokenInfo @param slot: slot number returned by L{getSlotList} @type slot: integer @return: a L{CK_TOKEN_INFO} object """ tokeninfo = PyKCS11.LowLevel.CK_TOKEN_INFO() rv = self.lib.C_GetTokenInfo(slot, tokeninfo) if rv != CKR_OK: raise PyKCS11Error(rv) t = CK_TOKEN_INFO() t.label = tokeninfo.GetLabel() t.manufacturerID = tokeninfo.GetManufacturerID() t.model = tokeninfo.GetModel() t.serialNumber = tokeninfo.GetSerialNumber() t.flags = tokeninfo.flags t.ulMaxSessionCount = tokeninfo.ulMaxSessionCount if t.ulMaxSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulMaxSessionCount = -1 t.ulSessionCount = tokeninfo.ulSessionCount if t.ulSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulSessionCount = -1 t.ulMaxRwSessionCount = tokeninfo.ulMaxRwSessionCount if t.ulMaxRwSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulMaxRwSessionCount = -1 t.ulRwSessionCount = tokeninfo.ulRwSessionCount if t.ulRwSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulRwSessionCount = -1 t.ulMaxPinLen = tokeninfo.ulMaxPinLen t.ulMinPinLen = tokeninfo.ulMinPinLen t.ulTotalPublicMemory = tokeninfo.ulTotalPublicMemory if t.ulTotalPublicMemory == CK_UNAVAILABLE_INFORMATION: t.ulTotalPublicMemory = -1 t.ulFreePublicMemory = tokeninfo.ulFreePublicMemory if t.ulFreePublicMemory == CK_UNAVAILABLE_INFORMATION: t.ulFreePublicMemory = -1 t.ulTotalPrivateMemory = tokeninfo.ulTotalPrivateMemory if t.ulTotalPrivateMemory == CK_UNAVAILABLE_INFORMATION: t.ulTotalPrivateMemory = -1 t.ulFreePrivateMemory = tokeninfo.ulFreePrivateMemory if t.ulFreePrivateMemory == CK_UNAVAILABLE_INFORMATION: t.ulFreePrivateMemory = -1 t.hardwareVersion = (tokeninfo.hardwareVersion.major, tokeninfo.hardwareVersion.minor) t.firmwareVersion = (tokeninfo.firmwareVersion.major, tokeninfo.firmwareVersion.minor) t.utcTime = tokeninfo.GetUtcTime() return t def openSession(self, slot, flags=0): """ C_OpenSession @param slot: slot number returned by L{getSlotList} @type slot: integer @param flags: 0 (default), CKF_RW_SESSION for RW session @type flags: integer @return: a L{Session} object """ se = PyKCS11.LowLevel.CK_SESSION_HANDLE() flags |= CKF_SERIAL_SESSION rv = self.lib.C_OpenSession(slot, flags, se) if rv != CKR_OK: raise PyKCS11Error(rv) s = Session() s.lib = self.lib s.slot = slot s.session = se return s def getMechanismList(self, slot): """ C_GetMechanismList @return: the list of available mechanisms for a slot @rtype: list """ mechanismList = PyKCS11.LowLevel.ckintlist() rv = self.lib.C_GetMechanismList(slot, mechanismList) if rv != CKR_OK: raise PyKCS11Error(rv) m = [] for x in xrange(len(mechanismList)): m.append(CKM[mechanismList[x]]) return m def getMechanismInfo(self, slot, type): """ C_GetMechanismInfo @return: information about a mechanism @rtype: a L{CK_MECHANISM_INFO} object """ info = PyKCS11.LowLevel.CK_MECHANISM_INFO() rv = self.lib.C_GetMechanismInfo(slot, CKM[type], info) if rv != CKR_OK: raise PyKCS11Error(rv) i = CK_MECHANISM_INFO() i.ulMinKeySize = info.ulMinKeySize i.ulMaxKeySize = info.ulMaxKeySize i.flags = info.flags return i def waitForSlotEvent(self, flags=0): """ C_WaitForSlotEvent @param flags: 0 (default) or CKF_DONT_BLOCK @type flags: integer @return: slot @rtype: integer """ tmp = 0 (rv, slot) = self.lib.C_WaitForSlotEvent(flags, tmp) if rv != CKR_OK: raise PyKCS11Error(rv) return slot class Mechanism(object): """Wraps CK_MECHANISM""" def __init__(self, mechanism, param): """ @param mechanism: the mechanism to be used @type mechanism: integer, any CKM_* value @param param: data to be used as crypto operation parameter (i.e. the IV for some agorithms) @type param: string or list/tuple of bytes @see: L{Session.decrypt}, L{Session.sign} """ self.mechanism = mechanism self.param = param MechanismRSAPKCS1 = Mechanism(CKM_RSA_PKCS, None) MechanismRSAGENERATEKEYPAIR = Mechanism(CKM_RSA_PKCS_KEY_PAIR_GEN, None) class Session(object): """ Manage L{PyKCS11Lib.openSession} objects """ def closeSession(self): """ C_CloseSession """ rv = self.lib.C_CloseSession(self.session) if rv != CKR_OK: raise PyKCS11Error(rv) def closeAllSession(self): """ C_CloseAllSession """ rv = self.lib.C_CloseAllSession(self.slot) if rv != CKR_OK: raise PyKCS11Error(rv) def getSessionInfo(self): """ C_GetSessionInfo @return: a L{CK_SESSION_INFO} object """ sessioninfo = PyKCS11.LowLevel.CK_SESSION_INFO() rv = self.lib.C_GetSessionInfo(self.session, sessioninfo) if rv != CKR_OK: raise PyKCS11Error(rv) s = CK_SESSION_INFO() s.slotID = sessioninfo.slotID s.state = sessioninfo.state s.flags = sessioninfo.flags s.ulDeviceError = sessioninfo.ulDeviceError return s def login(self, pin, user_type=CKU_USER): """ C_Login @param pin: the user's PIN or None for CKF_PROTECTED_AUTHENTICATION_PATH @type pin: string @param user_type: the user type. The default value is CKU_USER. You may also use CKU_SO @type user_type: integer """ rv = self.lib.C_Login(self.session, user_type, pin) if rv != CKR_OK: raise PyKCS11Error(rv) def logout(self): """ C_Logout """ rv = self.lib.C_Logout(self.session) if rv != CKR_OK: raise PyKCS11Error(rv) del self def initPin(self, new_pin): """ C_InitPIN """ rv = self.lib.C_InitPIN(self.session, new_pin) if rv != CKR_OK: raise PyKCS11Error(rv) def setPin(self, old_pin, new_pin): """ C_SetPIN """ rv = self.lib.C_SetPIN(self.session, old_pin, new_pin) if rv != CKR_OK: raise PyKCS11Error(rv) def createObject(self, template): """ C_CreateObject """ attrs = self._template2ckattrlist(template) handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() rv = self.lib.C_CreateObject(self.session, attrs, handle) if rv != PyKCS11.CKR_OK: raise PyKCS11.PyKCS11Error(rv) return handle def destroyObject(self, obj): """ C_DestroyObject """ rv = self.lib.C_DestroyObject(self.session, obj) if rv != CKR_OK: raise PyKCS11Error(rv) def sign(self, key, data, mecha=MechanismRSAPKCS1): """ C_SignInit/C_Sign @param key: a key handle, obtained calling L{findObjects}. @type key: integer @param data: the data to be signed @type data: (binary) sring or list/tuple of bytes @param mecha: the signing mechanism to be used @type mecha: L{Mechanism} instance or L{MechanismRSAPKCS1} for CKM_RSA_PKCS @return: the computed signature @rtype: list of bytes @note: the returned value is an istance of L{ckbytelist}. You can easly convert it to a binary string with:: ''.join(chr(i) for i in ckbytelistSignature) """ m = PyKCS11.LowLevel.CK_MECHANISM() signature = ckbytelist() ba = None # must be declared here or may be deallocated too early m.mechanism = mecha.mechanism if (mecha.param): ba = PyKCS11.LowLevel.byteArray(len(mecha.param)) if type(mecha.param) is type(''): for c in xrange(len(mecha.param)): ba[c] = ord(mecha.param[c]) else: for c in xrange(len(mecha.param)): ba[c] = mecha.param[c] # with cast() the ba object continue to own internal pointer # (avoids a leak). # pParameter is an opaque pointer, never garbage collected. m.pParameter = ba.cast() m.ulParameterLen = len(mecha.param) data1 = ckbytelist() data1.reserve(len(data)) if type(data) is type(''): for x in data: data1.append(ord(x)) else: for c in xrange(len(data)): data1.append(data[c]) rv = self.lib.C_SignInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) #first call get signature size rv = self.lib.C_Sign(self.session, data1, signature) if rv != CKR_OK: raise PyKCS11Error(rv) #second call get actual signature data rv = self.lib.C_Sign(self.session, data1, signature) if rv != CKR_OK: raise PyKCS11Error(rv) return signature def decrypt(self, key, data, mecha=MechanismRSAPKCS1): """ C_DecryptInit/C_Decrypt @param key: a key handle, obtained calling L{findObjects}. @type key: integer @param data: the data to be decrypted @type data: (binary) sring or list/tuple of bytes @param mecha: the decrypt mechanism to be used @type mecha: L{Mechanism} instance or L{MechanismRSAPKCS1} for CKM_RSA_PKCS @return: the decrypted data @rtype: list of bytes @note: the returned value is an istance of L{ckbytelist}. You can easly convert it to a binary string with:: ''.join(chr(i) for i in ckbytelistData) """ m = PyKCS11.LowLevel.CK_MECHANISM() decrypted = ckbytelist() ba = None # must be declared here or may be deallocated too early m.mechanism = mecha.mechanism if (mecha.param): ba = PyKCS11.LowLevel.byteArray(len(mecha.param)) if type(mecha.param) is type(''): for c in xrange(len(mecha.param)): ba[c] = ord(mecha.param[c]) else: for c in xrange(len(mecha.param)): ba[c] = mecha.param[c] # with cast() the ba object continue to own internal pointer # (avoids a leak). # pParameter is an opaque pointer, never garbage collected. m.pParameter = ba.cast() m.ulParameterLen = len(mecha.param) data1 = ckbytelist() data1.reserve(len(data)) if type(data) is type(''): for x in data: data1.append(ord(x)) else: for c in xrange(len(data)): data1.append(data[c]) rv = self.lib.C_DecryptInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) #first call get decrypted size rv = self.lib.C_Decrypt(self.session, data1, decrypted) if rv != CKR_OK: raise PyKCS11Error(rv) #second call get actual decrypted data rv = self.lib.C_Decrypt(self.session, data1, decrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return decrypted def isNum(self, type): """ is the type a numerical value? @param type: PKCS#11 type like CKA_CERTIFICATE_TYPE @rtype: bool """ if type in (CKA_CERTIFICATE_TYPE, CKA_CLASS, CKA_KEY_GEN_MECHANISM, CKA_KEY_TYPE, CKA_MODULUS_BITS, CKA_VALUE_BITS, CKA_VALUE_LEN): return True return False def isString(self, type): """ is the type a string value? @param type: PKCS#11 type like CKA_LABEL @rtype: bool """ if type in (CKA_LABEL, CKA_APPLICATION): return True return False def isBool(self, type): """ is the type a boolean value? @param type: PKCS#11 type like CKA_ALWAYS_SENSITIVE @rtype: bool """ if type in (CKA_ALWAYS_SENSITIVE, CKA_DECRYPT, CKA_ENCRYPT, CKA_EXTRACTABLE, CKA_HAS_RESET, CKA_LOCAL, CKA_MODIFIABLE, CKA_NEVER_EXTRACTABLE, CKA_PRIVATE, CKA_RESET_ON_INIT, CKA_SECONDARY_AUTH, CKA_SENSITIVE, CKA_SIGN, CKA_SIGN_RECOVER, CKA_TOKEN, CKA_TRUSTED, CKA_UNWRAP, CKA_VERIFY, CKA_VERIFY_RECOVER, CKA_WRAP): return True return False def isBin(self, type): """ is the type a byte array value? @param type: PKCS#11 type like CKA_MODULUS @rtype: bool """ return (not self.isBool(type)) and (not self.isString(type)) and (not self.isNum(type)) def _template2ckattrlist(self, template): t = PyKCS11.LowLevel.ckattrlist(len(template)) for x in xrange(len(template)): attr = template[x] if self.isNum(attr[0]): t[x].SetNum(attr[0], int(attr[1])) elif self.isString(attr[0]): t[x].SetString(attr[0], str(attr[1])) elif self.isBool(attr[0]): t[x].SetBool(attr[0], attr[1]) elif self.isBin(attr[0]): attrBin = attr[1] attrStr = attr[1] if isinstance(attr[1], int): attrStr = str(attr[1]) if isinstance(attr[1], str): attrBin = ckbytelist() attrBin.reserve(len(attrStr)) for c in xrange(len(attrStr)): attrBin.append(ord(attrStr[c])) t[x].SetBin(attr[0], attrBin) else: raise PyKCS11Error(-2) return t def generateKeyPair(self, templatePub, templatePriv, mecha=MechanismRSAGENERATEKEYPAIR): """ generate a key pair @param templatePub: template for the public key @param templatePriv: template for the private key @param mecha: mechanism to use @return: a tuple of handles (pub, priv) @rtype: tuple """ tPub = self._template2ckattrlist(templatePub) tPriv = self._template2ckattrlist(templatePriv) ck_pub_handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() ck_prv_handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() m = PyKCS11.LowLevel.CK_MECHANISM() ba = None # must be declared here or may be deallocated too early m.mechanism = mecha.mechanism if (mecha.param): ba = PyKCS11.LowLevel.byteArray(len(mecha.param)) if type(mecha.param) is type(''): for c in xrange(len(mecha.param)): ba[c] = ord(mecha.param[c]) else: for c in xrange(len(mecha.param)): ba[c] = mecha.param[c] # with cast() the ba object continue to own internal pointer # (avoids a leak). # pParameter is an opaque pointer, never garbage collected. m.pParameter = ba.cast() m.ulParameterLen = len(mecha.param) rv = self.lib.C_GenerateKeyPair(self.session, m, tPub, tPriv, ck_pub_handle, ck_prv_handle) if rv != CKR_OK: raise PyKCS11Error(rv) return ck_pub_handle, ck_prv_handle def findObjects(self, template=()): """ find the objects matching the template pattern @param template: list of attributes tuples (attribute,value). The default value is () and all the objects are returned @type template: list @return: a list of object ids @rtype: list """ t = self._template2ckattrlist(template) # we search for 10 objects by default. speed/memory tradeoff result = PyKCS11.LowLevel.ckobjlist(10) self.lib.C_FindObjectsInit(self.session, t) res = [] while True: self.lib.C_FindObjects(self.session, result) for x in result: # make a copy of the handle: the original value get # corrupted (!!) a = CK_OBJECT_HANDLE(self) a.assign(x.value()) res.append(a) if len(result) == 0: break self.lib.C_FindObjectsFinal(self.session) return res def getAttributeValue(self, obj_id, attr, allAsBinary=False): """ C_GetAttributeValue @param obj_id: object ID returned by L{findObjects} @type obj_id: integer @param attr: list of attributes @type attr: list @param allAsBinary: return all values as binary data; default is False. @type allAsBinary: Boolean @return: a list of values corresponding to the list of attributes @rtype: list @see: L{getAttributeValue_fragmented} @note: if allAsBinary is True the function do not convert results to Python types (i.e.: CKA_TOKEN to Bool, CKA_CLASS to int, ...). Binary data is returned as L{ckbytelist} type, usable as a list containing only bytes. You can easly convert it to a binary string with:: ''.join(chr(i) for i in ckbytelistVariable) """ valTemplate = PyKCS11.LowLevel.ckattrlist(len(attr)) for x in xrange(len(attr)): valTemplate[x].SetType(attr[x]) # first call to get the attribute size and reserve the memory rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv == CKR_ATTRIBUTE_TYPE_INVALID \ or rv == CKR_ATTRIBUTE_SENSITIVE: return self.getAttributeValue_fragmented(obj_id, attr, allAsBinary) if rv != CKR_OK: raise PyKCS11Error(rv) # second call to get the attribute value rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv != CKR_OK: raise PyKCS11Error(rv) res = [] for x in xrange(len(attr)): if (allAsBinary): res.append(valTemplate[x].GetBin()) elif valTemplate[x].IsNum(): res.append(valTemplate[x].GetNum()) elif valTemplate[x].IsBool(): res.append(valTemplate[x].GetBool()) elif valTemplate[x].IsString(): res.append(valTemplate[x].GetString()) elif valTemplate[x].IsBin(): res.append(valTemplate[x].GetBin()) else: raise PyKCS11Error(-2) return res def getAttributeValue_fragmented(self, obj_id, attr, allAsBinary=False): """ Same as L{getAttributeValue} except that when some attribute is sensitive or unknown an empty value (None) is returned. Note: this is achived by getting attributes one by one. @see: L{getAttributeValue} """ # some attributes does not exists or is sensitive # but we don't know which ones. So try one by one valTemplate = PyKCS11.LowLevel.ckattrlist(1) res = [] for x in xrange(len(attr)): valTemplate[0].Reset() valTemplate[0].SetType(attr[x]) # first call to get the attribute size and reserve the memory rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv == CKR_ATTRIBUTE_TYPE_INVALID \ or rv == CKR_ATTRIBUTE_SENSITIVE: # append an empty value res.append(None) continue if rv != CKR_OK: raise PyKCS11Error(rv) # second call to get the attribute value rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv != CKR_OK: raise PyKCS11Error(rv) if (allAsBinary): res.append(valTemplate[0].GetBin()) elif valTemplate[0].IsNum(): res.append(valTemplate[0].GetNum()) elif valTemplate[0].IsBool(): res.append(valTemplate[0].GetBool()) elif valTemplate[0].IsString(): res.append(valTemplate[0].GetString()) elif valTemplate[0].IsBin(): res.append(valTemplate[0].GetBin()) else: raise PyKCS11Error(-2) return res def seedRandom(self, seed): """ C_SeedRandom @param seed: seed material @type seed: iterable """ low_seed = ckbytelist(len(seed)) for c in xrange(len(seed)): low_seed.append(seed[c]) rv = self.lib.C_SeedRandom(self.session, low_seed) if rv != CKR_OK: raise PyKCS11Error(rv) def generateRandom(self, size=16): """ C_GenerateRandom @param size: number of random bytes to get @type size: integer @note: the returned value is an istance of L{ckbytelist}. You can easly convert it to a binary string with:: ''.join(chr(i) for i in random) """ low_rand = ckbytelist(size) rv = self.lib.C_GenerateRandom(self.session, low_rand) if rv != CKR_OK: raise PyKCS11Error(rv) return low_rand if __name__ == "__main__": # sample test/debug code p = PyKCS11Lib() p.load() print "getInfo" print p.getInfo() print print "getSlotList" s = p.getSlotList() print "slots:", s slot = s[0] print "using slot:", slot print print "getSlotInfo" print p.getSlotInfo(slot) print print "getTokenInfo" print p.getTokenInfo(slot) print print "openSession" se = p.openSession(slot) print print "sessionInfo" print se.getSessionInfo() print print "seedRandom" try: se.seedRandom([1, 2, 3, 4]) except PyKCS11Error, e: print e print "generateRandom" print se.generateRandom() print print "login" se.login(pin="0000") print print "sessionInfo" print se.getSessionInfo() print print "findObjects" objs = se.findObjects([(CKA_CLASS, CKO_CERTIFICATE)]) print "Nb objetcs:", len(objs) print objs print print "getAttributeValue" for o in objs: attr = se.getAttributeValue(o, [CKA_LABEL, CKA_CLASS]) print attr print print "logout" se.logout() print print "closeSession" se.closeSession() PyKCS11-1.2.4/PyKCS11/LowLevel.py0000644000175000017500000017166211744467536017603 0ustar rousseaurousseau00000000000000# This file was automatically generated by SWIG (http://www.swig.org). # Version 2.0.4 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. from sys import version_info if version_info >= (2,6,0): def swig_import_helper(): from os.path import dirname import imp fp = None try: fp, pathname, description = imp.find_module('_LowLevel', [dirname(__file__)]) except ImportError: import _LowLevel return _LowLevel if fp is not None: try: _mod = imp.load_module('_LowLevel', fp, pathname, description) finally: fp.close() return _mod _LowLevel = swig_import_helper() del swig_import_helper else: import _LowLevel del version_info try: _swig_property = property except NameError: pass # Python < 2.2 doesn't have 'property'. def _swig_setattr_nondynamic(self,class_type,name,value,static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'SwigPyObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name,None) if method: return method(self,value) if (not static): self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self,class_type,name,value): return _swig_setattr_nondynamic(self,class_type,name,value,0) def _swig_getattr(self,class_type,name): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name,None) if method: return method(self) raise AttributeError(name) def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) try: _object = object _newclass = 1 except AttributeError: class _object : pass _newclass = 0 def cdata(*args): return _LowLevel.cdata(*args) cdata = _LowLevel.cdata def memmove(*args): return _LowLevel.memmove(*args) memmove = _LowLevel.memmove class SwigPyIterator(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _LowLevel.delete_SwigPyIterator __del__ = lambda self : None; def value(self): return _LowLevel.SwigPyIterator_value(self) def incr(self, n = 1): return _LowLevel.SwigPyIterator_incr(self, n) def decr(self, n = 1): return _LowLevel.SwigPyIterator_decr(self, n) def distance(self, *args): return _LowLevel.SwigPyIterator_distance(self, *args) def equal(self, *args): return _LowLevel.SwigPyIterator_equal(self, *args) def copy(self): return _LowLevel.SwigPyIterator_copy(self) def next(self): return _LowLevel.SwigPyIterator_next(self) def __next__(self): return _LowLevel.SwigPyIterator___next__(self) def previous(self): return _LowLevel.SwigPyIterator_previous(self) def advance(self, *args): return _LowLevel.SwigPyIterator_advance(self, *args) def __eq__(self, *args): return _LowLevel.SwigPyIterator___eq__(self, *args) def __ne__(self, *args): return _LowLevel.SwigPyIterator___ne__(self, *args) def __iadd__(self, *args): return _LowLevel.SwigPyIterator___iadd__(self, *args) def __isub__(self, *args): return _LowLevel.SwigPyIterator___isub__(self, *args) def __add__(self, *args): return _LowLevel.SwigPyIterator___add__(self, *args) def __sub__(self, *args): return _LowLevel.SwigPyIterator___sub__(self, *args) def __iter__(self): return self SwigPyIterator_swigregister = _LowLevel.SwigPyIterator_swigregister SwigPyIterator_swigregister(SwigPyIterator) class ckintlist(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ckintlist, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ckintlist, name) __repr__ = _swig_repr def iterator(self): return _LowLevel.ckintlist_iterator(self) def __iter__(self): return self.iterator() def __nonzero__(self): return _LowLevel.ckintlist___nonzero__(self) def __bool__(self): return _LowLevel.ckintlist___bool__(self) def __len__(self): return _LowLevel.ckintlist___len__(self) def pop(self): return _LowLevel.ckintlist_pop(self) def __getslice__(self, *args): return _LowLevel.ckintlist___getslice__(self, *args) def __setslice__(self, *args): return _LowLevel.ckintlist___setslice__(self, *args) def __delslice__(self, *args): return _LowLevel.ckintlist___delslice__(self, *args) def __delitem__(self, *args): return _LowLevel.ckintlist___delitem__(self, *args) def __getitem__(self, *args): return _LowLevel.ckintlist___getitem__(self, *args) def __setitem__(self, *args): return _LowLevel.ckintlist___setitem__(self, *args) def append(self, *args): return _LowLevel.ckintlist_append(self, *args) def empty(self): return _LowLevel.ckintlist_empty(self) def size(self): return _LowLevel.ckintlist_size(self) def clear(self): return _LowLevel.ckintlist_clear(self) def swap(self, *args): return _LowLevel.ckintlist_swap(self, *args) def get_allocator(self): return _LowLevel.ckintlist_get_allocator(self) def begin(self): return _LowLevel.ckintlist_begin(self) def end(self): return _LowLevel.ckintlist_end(self) def rbegin(self): return _LowLevel.ckintlist_rbegin(self) def rend(self): return _LowLevel.ckintlist_rend(self) def pop_back(self): return _LowLevel.ckintlist_pop_back(self) def erase(self, *args): return _LowLevel.ckintlist_erase(self, *args) def __init__(self, *args): this = _LowLevel.new_ckintlist(*args) try: self.this.append(this) except: self.this = this def push_back(self, *args): return _LowLevel.ckintlist_push_back(self, *args) def front(self): return _LowLevel.ckintlist_front(self) def back(self): return _LowLevel.ckintlist_back(self) def assign(self, *args): return _LowLevel.ckintlist_assign(self, *args) def resize(self, *args): return _LowLevel.ckintlist_resize(self, *args) def insert(self, *args): return _LowLevel.ckintlist_insert(self, *args) def reserve(self, *args): return _LowLevel.ckintlist_reserve(self, *args) def capacity(self): return _LowLevel.ckintlist_capacity(self) __swig_destroy__ = _LowLevel.delete_ckintlist __del__ = lambda self : None; ckintlist_swigregister = _LowLevel.ckintlist_swigregister ckintlist_swigregister(ckintlist) class ckbytelist(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ckbytelist, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ckbytelist, name) __repr__ = _swig_repr def iterator(self): return _LowLevel.ckbytelist_iterator(self) def __iter__(self): return self.iterator() def __nonzero__(self): return _LowLevel.ckbytelist___nonzero__(self) def __bool__(self): return _LowLevel.ckbytelist___bool__(self) def __len__(self): return _LowLevel.ckbytelist___len__(self) def pop(self): return _LowLevel.ckbytelist_pop(self) def __getslice__(self, *args): return _LowLevel.ckbytelist___getslice__(self, *args) def __setslice__(self, *args): return _LowLevel.ckbytelist___setslice__(self, *args) def __delslice__(self, *args): return _LowLevel.ckbytelist___delslice__(self, *args) def __delitem__(self, *args): return _LowLevel.ckbytelist___delitem__(self, *args) def __getitem__(self, *args): return _LowLevel.ckbytelist___getitem__(self, *args) def __setitem__(self, *args): return _LowLevel.ckbytelist___setitem__(self, *args) def append(self, *args): return _LowLevel.ckbytelist_append(self, *args) def empty(self): return _LowLevel.ckbytelist_empty(self) def size(self): return _LowLevel.ckbytelist_size(self) def clear(self): return _LowLevel.ckbytelist_clear(self) def swap(self, *args): return _LowLevel.ckbytelist_swap(self, *args) def get_allocator(self): return _LowLevel.ckbytelist_get_allocator(self) def begin(self): return _LowLevel.ckbytelist_begin(self) def end(self): return _LowLevel.ckbytelist_end(self) def rbegin(self): return _LowLevel.ckbytelist_rbegin(self) def rend(self): return _LowLevel.ckbytelist_rend(self) def pop_back(self): return _LowLevel.ckbytelist_pop_back(self) def erase(self, *args): return _LowLevel.ckbytelist_erase(self, *args) def __init__(self, *args): this = _LowLevel.new_ckbytelist(*args) try: self.this.append(this) except: self.this = this def push_back(self, *args): return _LowLevel.ckbytelist_push_back(self, *args) def front(self): return _LowLevel.ckbytelist_front(self) def back(self): return _LowLevel.ckbytelist_back(self) def assign(self, *args): return _LowLevel.ckbytelist_assign(self, *args) def resize(self, *args): return _LowLevel.ckbytelist_resize(self, *args) def insert(self, *args): return _LowLevel.ckbytelist_insert(self, *args) def reserve(self, *args): return _LowLevel.ckbytelist_reserve(self, *args) def capacity(self): return _LowLevel.ckbytelist_capacity(self) __swig_destroy__ = _LowLevel.delete_ckbytelist __del__ = lambda self : None; ckbytelist_swigregister = _LowLevel.ckbytelist_swigregister ckbytelist_swigregister(ckbytelist) class ckattrlist(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ckattrlist, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ckattrlist, name) __repr__ = _swig_repr def iterator(self): return _LowLevel.ckattrlist_iterator(self) def __iter__(self): return self.iterator() def __nonzero__(self): return _LowLevel.ckattrlist___nonzero__(self) def __bool__(self): return _LowLevel.ckattrlist___bool__(self) def __len__(self): return _LowLevel.ckattrlist___len__(self) def pop(self): return _LowLevel.ckattrlist_pop(self) def __getslice__(self, *args): return _LowLevel.ckattrlist___getslice__(self, *args) def __setslice__(self, *args): return _LowLevel.ckattrlist___setslice__(self, *args) def __delslice__(self, *args): return _LowLevel.ckattrlist___delslice__(self, *args) def __delitem__(self, *args): return _LowLevel.ckattrlist___delitem__(self, *args) def __getitem__(self, *args): return _LowLevel.ckattrlist___getitem__(self, *args) def __setitem__(self, *args): return _LowLevel.ckattrlist___setitem__(self, *args) def append(self, *args): return _LowLevel.ckattrlist_append(self, *args) def empty(self): return _LowLevel.ckattrlist_empty(self) def size(self): return _LowLevel.ckattrlist_size(self) def clear(self): return _LowLevel.ckattrlist_clear(self) def swap(self, *args): return _LowLevel.ckattrlist_swap(self, *args) def get_allocator(self): return _LowLevel.ckattrlist_get_allocator(self) def begin(self): return _LowLevel.ckattrlist_begin(self) def end(self): return _LowLevel.ckattrlist_end(self) def rbegin(self): return _LowLevel.ckattrlist_rbegin(self) def rend(self): return _LowLevel.ckattrlist_rend(self) def pop_back(self): return _LowLevel.ckattrlist_pop_back(self) def erase(self, *args): return _LowLevel.ckattrlist_erase(self, *args) def __init__(self, *args): this = _LowLevel.new_ckattrlist(*args) try: self.this.append(this) except: self.this = this def push_back(self, *args): return _LowLevel.ckattrlist_push_back(self, *args) def front(self): return _LowLevel.ckattrlist_front(self) def back(self): return _LowLevel.ckattrlist_back(self) def assign(self, *args): return _LowLevel.ckattrlist_assign(self, *args) def resize(self, *args): return _LowLevel.ckattrlist_resize(self, *args) def insert(self, *args): return _LowLevel.ckattrlist_insert(self, *args) def reserve(self, *args): return _LowLevel.ckattrlist_reserve(self, *args) def capacity(self): return _LowLevel.ckattrlist_capacity(self) __swig_destroy__ = _LowLevel.delete_ckattrlist __del__ = lambda self : None; ckattrlist_swigregister = _LowLevel.ckattrlist_swigregister ckattrlist_swigregister(ckattrlist) class ckobjlist(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ckobjlist, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ckobjlist, name) __repr__ = _swig_repr def iterator(self): return _LowLevel.ckobjlist_iterator(self) def __iter__(self): return self.iterator() def __nonzero__(self): return _LowLevel.ckobjlist___nonzero__(self) def __bool__(self): return _LowLevel.ckobjlist___bool__(self) def __len__(self): return _LowLevel.ckobjlist___len__(self) def pop(self): return _LowLevel.ckobjlist_pop(self) def __getslice__(self, *args): return _LowLevel.ckobjlist___getslice__(self, *args) def __setslice__(self, *args): return _LowLevel.ckobjlist___setslice__(self, *args) def __delslice__(self, *args): return _LowLevel.ckobjlist___delslice__(self, *args) def __delitem__(self, *args): return _LowLevel.ckobjlist___delitem__(self, *args) def __getitem__(self, *args): return _LowLevel.ckobjlist___getitem__(self, *args) def __setitem__(self, *args): return _LowLevel.ckobjlist___setitem__(self, *args) def append(self, *args): return _LowLevel.ckobjlist_append(self, *args) def empty(self): return _LowLevel.ckobjlist_empty(self) def size(self): return _LowLevel.ckobjlist_size(self) def clear(self): return _LowLevel.ckobjlist_clear(self) def swap(self, *args): return _LowLevel.ckobjlist_swap(self, *args) def get_allocator(self): return _LowLevel.ckobjlist_get_allocator(self) def begin(self): return _LowLevel.ckobjlist_begin(self) def end(self): return _LowLevel.ckobjlist_end(self) def rbegin(self): return _LowLevel.ckobjlist_rbegin(self) def rend(self): return _LowLevel.ckobjlist_rend(self) def pop_back(self): return _LowLevel.ckobjlist_pop_back(self) def erase(self, *args): return _LowLevel.ckobjlist_erase(self, *args) def __init__(self, *args): this = _LowLevel.new_ckobjlist(*args) try: self.this.append(this) except: self.this = this def push_back(self, *args): return _LowLevel.ckobjlist_push_back(self, *args) def front(self): return _LowLevel.ckobjlist_front(self) def back(self): return _LowLevel.ckobjlist_back(self) def assign(self, *args): return _LowLevel.ckobjlist_assign(self, *args) def resize(self, *args): return _LowLevel.ckobjlist_resize(self, *args) def insert(self, *args): return _LowLevel.ckobjlist_insert(self, *args) def reserve(self, *args): return _LowLevel.ckobjlist_reserve(self, *args) def capacity(self): return _LowLevel.ckobjlist_capacity(self) __swig_destroy__ = _LowLevel.delete_ckobjlist __del__ = lambda self : None; ckobjlist_swigregister = _LowLevel.ckobjlist_swigregister ckobjlist_swigregister(ckobjlist) class CK_SESSION_HANDLE(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_SESSION_HANDLE, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_SESSION_HANDLE, name) __repr__ = _swig_repr def __init__(self): this = _LowLevel.new_CK_SESSION_HANDLE() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_SESSION_HANDLE __del__ = lambda self : None; def assign(self, *args): return _LowLevel.CK_SESSION_HANDLE_assign(self, *args) def value(self): return _LowLevel.CK_SESSION_HANDLE_value(self) def cast(self): return _LowLevel.CK_SESSION_HANDLE_cast(self) __swig_getmethods__["frompointer"] = lambda x: _LowLevel.CK_SESSION_HANDLE_frompointer if _newclass:frompointer = staticmethod(_LowLevel.CK_SESSION_HANDLE_frompointer) CK_SESSION_HANDLE_swigregister = _LowLevel.CK_SESSION_HANDLE_swigregister CK_SESSION_HANDLE_swigregister(CK_SESSION_HANDLE) def CK_SESSION_HANDLE_frompointer(*args): return _LowLevel.CK_SESSION_HANDLE_frompointer(*args) CK_SESSION_HANDLE_frompointer = _LowLevel.CK_SESSION_HANDLE_frompointer class CK_OBJECT_HANDLE(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_OBJECT_HANDLE, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_OBJECT_HANDLE, name) __repr__ = _swig_repr def __init__(self): this = _LowLevel.new_CK_OBJECT_HANDLE() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_OBJECT_HANDLE __del__ = lambda self : None; def assign(self, *args): return _LowLevel.CK_OBJECT_HANDLE_assign(self, *args) def value(self): return _LowLevel.CK_OBJECT_HANDLE_value(self) def cast(self): return _LowLevel.CK_OBJECT_HANDLE_cast(self) __swig_getmethods__["frompointer"] = lambda x: _LowLevel.CK_OBJECT_HANDLE_frompointer if _newclass:frompointer = staticmethod(_LowLevel.CK_OBJECT_HANDLE_frompointer) CK_OBJECT_HANDLE_swigregister = _LowLevel.CK_OBJECT_HANDLE_swigregister CK_OBJECT_HANDLE_swigregister(CK_OBJECT_HANDLE) def CK_OBJECT_HANDLE_frompointer(*args): return _LowLevel.CK_OBJECT_HANDLE_frompointer(*args) CK_OBJECT_HANDLE_frompointer = _LowLevel.CK_OBJECT_HANDLE_frompointer class byteArray(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, byteArray, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, byteArray, name) __repr__ = _swig_repr def __init__(self, *args): this = _LowLevel.new_byteArray(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_byteArray __del__ = lambda self : None; def __getitem__(self, *args): return _LowLevel.byteArray___getitem__(self, *args) def __setitem__(self, *args): return _LowLevel.byteArray___setitem__(self, *args) def cast(self): return _LowLevel.byteArray_cast(self) __swig_getmethods__["frompointer"] = lambda x: _LowLevel.byteArray_frompointer if _newclass:frompointer = staticmethod(_LowLevel.byteArray_frompointer) byteArray_swigregister = _LowLevel.byteArray_swigregister byteArray_swigregister(byteArray) def byteArray_frompointer(*args): return _LowLevel.byteArray_frompointer(*args) byteArray_frompointer = _LowLevel.byteArray_frompointer class CK_VERSION(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_VERSION, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_VERSION, name) __repr__ = _swig_repr __swig_getmethods__["major"] = _LowLevel.CK_VERSION_major_get if _newclass:major = _swig_property(_LowLevel.CK_VERSION_major_get) __swig_getmethods__["minor"] = _LowLevel.CK_VERSION_minor_get if _newclass:minor = _swig_property(_LowLevel.CK_VERSION_minor_get) def __init__(self): this = _LowLevel.new_CK_VERSION() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_VERSION __del__ = lambda self : None; CK_VERSION_swigregister = _LowLevel.CK_VERSION_swigregister CK_VERSION_swigregister(CK_VERSION) class CK_INFO(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_INFO, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_INFO, name) __repr__ = _swig_repr __swig_getmethods__["cryptokiVersion"] = _LowLevel.CK_INFO_cryptokiVersion_get if _newclass:cryptokiVersion = _swig_property(_LowLevel.CK_INFO_cryptokiVersion_get) __swig_getmethods__["manufacturerID"] = _LowLevel.CK_INFO_manufacturerID_get if _newclass:manufacturerID = _swig_property(_LowLevel.CK_INFO_manufacturerID_get) __swig_getmethods__["flags"] = _LowLevel.CK_INFO_flags_get if _newclass:flags = _swig_property(_LowLevel.CK_INFO_flags_get) __swig_getmethods__["libraryDescription"] = _LowLevel.CK_INFO_libraryDescription_get if _newclass:libraryDescription = _swig_property(_LowLevel.CK_INFO_libraryDescription_get) __swig_getmethods__["libraryVersion"] = _LowLevel.CK_INFO_libraryVersion_get if _newclass:libraryVersion = _swig_property(_LowLevel.CK_INFO_libraryVersion_get) def GetManufacturerID(self): return _LowLevel.CK_INFO_GetManufacturerID(self) def GetLibraryDescription(self): return _LowLevel.CK_INFO_GetLibraryDescription(self) def GetLibraryVersion(self): return _LowLevel.CK_INFO_GetLibraryVersion(self) def __init__(self): this = _LowLevel.new_CK_INFO() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_INFO __del__ = lambda self : None; CK_INFO_swigregister = _LowLevel.CK_INFO_swigregister CK_INFO_swigregister(CK_INFO) class CK_SLOT_INFO(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_SLOT_INFO, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_SLOT_INFO, name) __repr__ = _swig_repr __swig_getmethods__["flags"] = _LowLevel.CK_SLOT_INFO_flags_get if _newclass:flags = _swig_property(_LowLevel.CK_SLOT_INFO_flags_get) __swig_getmethods__["hardwareVersion"] = _LowLevel.CK_SLOT_INFO_hardwareVersion_get if _newclass:hardwareVersion = _swig_property(_LowLevel.CK_SLOT_INFO_hardwareVersion_get) __swig_getmethods__["firmwareVersion"] = _LowLevel.CK_SLOT_INFO_firmwareVersion_get if _newclass:firmwareVersion = _swig_property(_LowLevel.CK_SLOT_INFO_firmwareVersion_get) def GetManufacturerID(self): return _LowLevel.CK_SLOT_INFO_GetManufacturerID(self) def GetSlotDescription(self): return _LowLevel.CK_SLOT_INFO_GetSlotDescription(self) def GetHardwareVersion(self): return _LowLevel.CK_SLOT_INFO_GetHardwareVersion(self) def GetFirmwareVersion(self): return _LowLevel.CK_SLOT_INFO_GetFirmwareVersion(self) def __init__(self): this = _LowLevel.new_CK_SLOT_INFO() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_SLOT_INFO __del__ = lambda self : None; CK_SLOT_INFO_swigregister = _LowLevel.CK_SLOT_INFO_swigregister CK_SLOT_INFO_swigregister(CK_SLOT_INFO) class CK_TOKEN_INFO(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_TOKEN_INFO, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_TOKEN_INFO, name) __repr__ = _swig_repr __swig_getmethods__["flags"] = _LowLevel.CK_TOKEN_INFO_flags_get if _newclass:flags = _swig_property(_LowLevel.CK_TOKEN_INFO_flags_get) __swig_getmethods__["ulMaxSessionCount"] = _LowLevel.CK_TOKEN_INFO_ulMaxSessionCount_get if _newclass:ulMaxSessionCount = _swig_property(_LowLevel.CK_TOKEN_INFO_ulMaxSessionCount_get) __swig_getmethods__["ulSessionCount"] = _LowLevel.CK_TOKEN_INFO_ulSessionCount_get if _newclass:ulSessionCount = _swig_property(_LowLevel.CK_TOKEN_INFO_ulSessionCount_get) __swig_getmethods__["ulMaxRwSessionCount"] = _LowLevel.CK_TOKEN_INFO_ulMaxRwSessionCount_get if _newclass:ulMaxRwSessionCount = _swig_property(_LowLevel.CK_TOKEN_INFO_ulMaxRwSessionCount_get) __swig_getmethods__["ulRwSessionCount"] = _LowLevel.CK_TOKEN_INFO_ulRwSessionCount_get if _newclass:ulRwSessionCount = _swig_property(_LowLevel.CK_TOKEN_INFO_ulRwSessionCount_get) __swig_getmethods__["ulMaxPinLen"] = _LowLevel.CK_TOKEN_INFO_ulMaxPinLen_get if _newclass:ulMaxPinLen = _swig_property(_LowLevel.CK_TOKEN_INFO_ulMaxPinLen_get) __swig_getmethods__["ulMinPinLen"] = _LowLevel.CK_TOKEN_INFO_ulMinPinLen_get if _newclass:ulMinPinLen = _swig_property(_LowLevel.CK_TOKEN_INFO_ulMinPinLen_get) __swig_getmethods__["ulTotalPublicMemory"] = _LowLevel.CK_TOKEN_INFO_ulTotalPublicMemory_get if _newclass:ulTotalPublicMemory = _swig_property(_LowLevel.CK_TOKEN_INFO_ulTotalPublicMemory_get) __swig_getmethods__["ulFreePublicMemory"] = _LowLevel.CK_TOKEN_INFO_ulFreePublicMemory_get if _newclass:ulFreePublicMemory = _swig_property(_LowLevel.CK_TOKEN_INFO_ulFreePublicMemory_get) __swig_getmethods__["ulTotalPrivateMemory"] = _LowLevel.CK_TOKEN_INFO_ulTotalPrivateMemory_get if _newclass:ulTotalPrivateMemory = _swig_property(_LowLevel.CK_TOKEN_INFO_ulTotalPrivateMemory_get) __swig_getmethods__["ulFreePrivateMemory"] = _LowLevel.CK_TOKEN_INFO_ulFreePrivateMemory_get if _newclass:ulFreePrivateMemory = _swig_property(_LowLevel.CK_TOKEN_INFO_ulFreePrivateMemory_get) __swig_getmethods__["hardwareVersion"] = _LowLevel.CK_TOKEN_INFO_hardwareVersion_get if _newclass:hardwareVersion = _swig_property(_LowLevel.CK_TOKEN_INFO_hardwareVersion_get) __swig_getmethods__["firmwareVersion"] = _LowLevel.CK_TOKEN_INFO_firmwareVersion_get if _newclass:firmwareVersion = _swig_property(_LowLevel.CK_TOKEN_INFO_firmwareVersion_get) def GetLabel(self): return _LowLevel.CK_TOKEN_INFO_GetLabel(self) def GetManufacturerID(self): return _LowLevel.CK_TOKEN_INFO_GetManufacturerID(self) def GetModel(self): return _LowLevel.CK_TOKEN_INFO_GetModel(self) def GetSerialNumber(self): return _LowLevel.CK_TOKEN_INFO_GetSerialNumber(self) def GetFirmwareVersion(self): return _LowLevel.CK_TOKEN_INFO_GetFirmwareVersion(self) def GetUtcTime(self): return _LowLevel.CK_TOKEN_INFO_GetUtcTime(self) def __init__(self): this = _LowLevel.new_CK_TOKEN_INFO() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_TOKEN_INFO __del__ = lambda self : None; CK_TOKEN_INFO_swigregister = _LowLevel.CK_TOKEN_INFO_swigregister CK_TOKEN_INFO_swigregister(CK_TOKEN_INFO) class CK_SESSION_INFO(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_SESSION_INFO, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_SESSION_INFO, name) __repr__ = _swig_repr __swig_getmethods__["slotID"] = _LowLevel.CK_SESSION_INFO_slotID_get if _newclass:slotID = _swig_property(_LowLevel.CK_SESSION_INFO_slotID_get) __swig_getmethods__["state"] = _LowLevel.CK_SESSION_INFO_state_get if _newclass:state = _swig_property(_LowLevel.CK_SESSION_INFO_state_get) __swig_getmethods__["flags"] = _LowLevel.CK_SESSION_INFO_flags_get if _newclass:flags = _swig_property(_LowLevel.CK_SESSION_INFO_flags_get) __swig_getmethods__["ulDeviceError"] = _LowLevel.CK_SESSION_INFO_ulDeviceError_get if _newclass:ulDeviceError = _swig_property(_LowLevel.CK_SESSION_INFO_ulDeviceError_get) def __init__(self): this = _LowLevel.new_CK_SESSION_INFO() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_SESSION_INFO __del__ = lambda self : None; CK_SESSION_INFO_swigregister = _LowLevel.CK_SESSION_INFO_swigregister CK_SESSION_INFO_swigregister(CK_SESSION_INFO) class CK_DATE(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_DATE, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_DATE, name) __repr__ = _swig_repr def GetYear(self): return _LowLevel.CK_DATE_GetYear(self) def GetMonth(self): return _LowLevel.CK_DATE_GetMonth(self) def GetDay(self): return _LowLevel.CK_DATE_GetDay(self) def __init__(self): this = _LowLevel.new_CK_DATE() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_DATE __del__ = lambda self : None; CK_DATE_swigregister = _LowLevel.CK_DATE_swigregister CK_DATE_swigregister(CK_DATE) class CK_MECHANISM(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_MECHANISM, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_MECHANISM, name) __repr__ = _swig_repr __swig_setmethods__["mechanism"] = _LowLevel.CK_MECHANISM_mechanism_set __swig_getmethods__["mechanism"] = _LowLevel.CK_MECHANISM_mechanism_get if _newclass:mechanism = _swig_property(_LowLevel.CK_MECHANISM_mechanism_get, _LowLevel.CK_MECHANISM_mechanism_set) __swig_setmethods__["pParameter"] = _LowLevel.CK_MECHANISM_pParameter_set __swig_getmethods__["pParameter"] = _LowLevel.CK_MECHANISM_pParameter_get if _newclass:pParameter = _swig_property(_LowLevel.CK_MECHANISM_pParameter_get, _LowLevel.CK_MECHANISM_pParameter_set) __swig_setmethods__["ulParameterLen"] = _LowLevel.CK_MECHANISM_ulParameterLen_set __swig_getmethods__["ulParameterLen"] = _LowLevel.CK_MECHANISM_ulParameterLen_get if _newclass:ulParameterLen = _swig_property(_LowLevel.CK_MECHANISM_ulParameterLen_get, _LowLevel.CK_MECHANISM_ulParameterLen_set) def __init__(self): this = _LowLevel.new_CK_MECHANISM() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_MECHANISM __del__ = lambda self : None; CK_MECHANISM_swigregister = _LowLevel.CK_MECHANISM_swigregister CK_MECHANISM_swigregister(CK_MECHANISM) class CK_MECHANISM_INFO(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_MECHANISM_INFO, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_MECHANISM_INFO, name) __repr__ = _swig_repr __swig_getmethods__["ulMinKeySize"] = _LowLevel.CK_MECHANISM_INFO_ulMinKeySize_get if _newclass:ulMinKeySize = _swig_property(_LowLevel.CK_MECHANISM_INFO_ulMinKeySize_get) __swig_getmethods__["ulMaxKeySize"] = _LowLevel.CK_MECHANISM_INFO_ulMaxKeySize_get if _newclass:ulMaxKeySize = _swig_property(_LowLevel.CK_MECHANISM_INFO_ulMaxKeySize_get) __swig_getmethods__["flags"] = _LowLevel.CK_MECHANISM_INFO_flags_get if _newclass:flags = _swig_property(_LowLevel.CK_MECHANISM_INFO_flags_get) def __init__(self): this = _LowLevel.new_CK_MECHANISM_INFO() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_MECHANISM_INFO __del__ = lambda self : None; CK_MECHANISM_INFO_swigregister = _LowLevel.CK_MECHANISM_INFO_swigregister CK_MECHANISM_INFO_swigregister(CK_MECHANISM_INFO) FALSE = _LowLevel.FALSE TRUE = _LowLevel.TRUE CK_TRUE = _LowLevel.CK_TRUE CK_FALSE = _LowLevel.CK_FALSE CK_UNAVAILABLE_INFORMATION = _LowLevel.CK_UNAVAILABLE_INFORMATION CK_EFFECTIVELY_INFINITE = _LowLevel.CK_EFFECTIVELY_INFINITE CK_INVALID_HANDLE = _LowLevel.CK_INVALID_HANDLE CKN_SURRENDER = _LowLevel.CKN_SURRENDER CKF_TOKEN_PRESENT = _LowLevel.CKF_TOKEN_PRESENT CKF_REMOVABLE_DEVICE = _LowLevel.CKF_REMOVABLE_DEVICE CKF_HW_SLOT = _LowLevel.CKF_HW_SLOT CKF_RNG = _LowLevel.CKF_RNG CKF_WRITE_PROTECTED = _LowLevel.CKF_WRITE_PROTECTED CKF_LOGIN_REQUIRED = _LowLevel.CKF_LOGIN_REQUIRED CKF_USER_PIN_INITIALIZED = _LowLevel.CKF_USER_PIN_INITIALIZED CKF_RESTORE_KEY_NOT_NEEDED = _LowLevel.CKF_RESTORE_KEY_NOT_NEEDED CKF_CLOCK_ON_TOKEN = _LowLevel.CKF_CLOCK_ON_TOKEN CKF_PROTECTED_AUTHENTICATION_PATH = _LowLevel.CKF_PROTECTED_AUTHENTICATION_PATH CKF_DUAL_CRYPTO_OPERATIONS = _LowLevel.CKF_DUAL_CRYPTO_OPERATIONS CKF_TOKEN_INITIALIZED = _LowLevel.CKF_TOKEN_INITIALIZED CKF_SECONDARY_AUTHENTICATION = _LowLevel.CKF_SECONDARY_AUTHENTICATION CKF_USER_PIN_COUNT_LOW = _LowLevel.CKF_USER_PIN_COUNT_LOW CKF_USER_PIN_FINAL_TRY = _LowLevel.CKF_USER_PIN_FINAL_TRY CKF_USER_PIN_LOCKED = _LowLevel.CKF_USER_PIN_LOCKED CKF_USER_PIN_TO_BE_CHANGED = _LowLevel.CKF_USER_PIN_TO_BE_CHANGED CKF_SO_PIN_COUNT_LOW = _LowLevel.CKF_SO_PIN_COUNT_LOW CKF_SO_PIN_FINAL_TRY = _LowLevel.CKF_SO_PIN_FINAL_TRY CKF_SO_PIN_LOCKED = _LowLevel.CKF_SO_PIN_LOCKED CKF_SO_PIN_TO_BE_CHANGED = _LowLevel.CKF_SO_PIN_TO_BE_CHANGED CKU_SO = _LowLevel.CKU_SO CKU_USER = _LowLevel.CKU_USER CKS_RO_PUBLIC_SESSION = _LowLevel.CKS_RO_PUBLIC_SESSION CKS_RO_USER_FUNCTIONS = _LowLevel.CKS_RO_USER_FUNCTIONS CKS_RW_PUBLIC_SESSION = _LowLevel.CKS_RW_PUBLIC_SESSION CKS_RW_USER_FUNCTIONS = _LowLevel.CKS_RW_USER_FUNCTIONS CKS_RW_SO_FUNCTIONS = _LowLevel.CKS_RW_SO_FUNCTIONS CKF_RW_SESSION = _LowLevel.CKF_RW_SESSION CKF_SERIAL_SESSION = _LowLevel.CKF_SERIAL_SESSION CKO_DATA = _LowLevel.CKO_DATA CKO_CERTIFICATE = _LowLevel.CKO_CERTIFICATE CKO_PUBLIC_KEY = _LowLevel.CKO_PUBLIC_KEY CKO_PRIVATE_KEY = _LowLevel.CKO_PRIVATE_KEY CKO_SECRET_KEY = _LowLevel.CKO_SECRET_KEY CKO_HW_FEATURE = _LowLevel.CKO_HW_FEATURE CKO_DOMAIN_PARAMETERS = _LowLevel.CKO_DOMAIN_PARAMETERS CKO_MECHANISM = _LowLevel.CKO_MECHANISM CKO_VENDOR_DEFINED = _LowLevel.CKO_VENDOR_DEFINED CKH_MONOTONIC_COUNTER = _LowLevel.CKH_MONOTONIC_COUNTER CKH_CLOCK = _LowLevel.CKH_CLOCK CKH_VENDOR_DEFINED = _LowLevel.CKH_VENDOR_DEFINED CKK_RSA = _LowLevel.CKK_RSA CKK_DSA = _LowLevel.CKK_DSA CKK_DH = _LowLevel.CKK_DH CKK_ECDSA = _LowLevel.CKK_ECDSA CKK_EC = _LowLevel.CKK_EC CKK_X9_42_DH = _LowLevel.CKK_X9_42_DH CKK_KEA = _LowLevel.CKK_KEA CKK_GENERIC_SECRET = _LowLevel.CKK_GENERIC_SECRET CKK_RC2 = _LowLevel.CKK_RC2 CKK_RC4 = _LowLevel.CKK_RC4 CKK_DES = _LowLevel.CKK_DES CKK_DES2 = _LowLevel.CKK_DES2 CKK_DES3 = _LowLevel.CKK_DES3 CKK_CAST = _LowLevel.CKK_CAST CKK_CAST3 = _LowLevel.CKK_CAST3 CKK_CAST5 = _LowLevel.CKK_CAST5 CKK_CAST128 = _LowLevel.CKK_CAST128 CKK_RC5 = _LowLevel.CKK_RC5 CKK_IDEA = _LowLevel.CKK_IDEA CKK_SKIPJACK = _LowLevel.CKK_SKIPJACK CKK_BATON = _LowLevel.CKK_BATON CKK_JUNIPER = _LowLevel.CKK_JUNIPER CKK_CDMF = _LowLevel.CKK_CDMF CKK_AES = _LowLevel.CKK_AES CKK_BLOWFISH = _LowLevel.CKK_BLOWFISH CKK_TWOFISH = _LowLevel.CKK_TWOFISH CKK_VENDOR_DEFINED = _LowLevel.CKK_VENDOR_DEFINED CKC_X_509 = _LowLevel.CKC_X_509 CKC_X_509_ATTR_CERT = _LowLevel.CKC_X_509_ATTR_CERT CKC_WTLS = _LowLevel.CKC_WTLS CKC_VENDOR_DEFINED = _LowLevel.CKC_VENDOR_DEFINED CKA_CLASS = _LowLevel.CKA_CLASS CKA_TOKEN = _LowLevel.CKA_TOKEN CKA_PRIVATE = _LowLevel.CKA_PRIVATE CKA_LABEL = _LowLevel.CKA_LABEL CKA_APPLICATION = _LowLevel.CKA_APPLICATION CKA_VALUE = _LowLevel.CKA_VALUE CKA_OBJECT_ID = _LowLevel.CKA_OBJECT_ID CKA_CERTIFICATE_TYPE = _LowLevel.CKA_CERTIFICATE_TYPE CKA_ISSUER = _LowLevel.CKA_ISSUER CKA_SERIAL_NUMBER = _LowLevel.CKA_SERIAL_NUMBER CKA_AC_ISSUER = _LowLevel.CKA_AC_ISSUER CKA_OWNER = _LowLevel.CKA_OWNER CKA_ATTR_TYPES = _LowLevel.CKA_ATTR_TYPES CKA_TRUSTED = _LowLevel.CKA_TRUSTED CKA_KEY_TYPE = _LowLevel.CKA_KEY_TYPE CKA_SUBJECT = _LowLevel.CKA_SUBJECT CKA_ID = _LowLevel.CKA_ID CKA_SENSITIVE = _LowLevel.CKA_SENSITIVE CKA_ENCRYPT = _LowLevel.CKA_ENCRYPT CKA_DECRYPT = _LowLevel.CKA_DECRYPT CKA_WRAP = _LowLevel.CKA_WRAP CKA_UNWRAP = _LowLevel.CKA_UNWRAP CKA_SIGN = _LowLevel.CKA_SIGN CKA_SIGN_RECOVER = _LowLevel.CKA_SIGN_RECOVER CKA_VERIFY = _LowLevel.CKA_VERIFY CKA_VERIFY_RECOVER = _LowLevel.CKA_VERIFY_RECOVER CKA_DERIVE = _LowLevel.CKA_DERIVE CKA_START_DATE = _LowLevel.CKA_START_DATE CKA_END_DATE = _LowLevel.CKA_END_DATE CKA_MODULUS = _LowLevel.CKA_MODULUS CKA_MODULUS_BITS = _LowLevel.CKA_MODULUS_BITS CKA_PUBLIC_EXPONENT = _LowLevel.CKA_PUBLIC_EXPONENT CKA_PRIVATE_EXPONENT = _LowLevel.CKA_PRIVATE_EXPONENT CKA_PRIME_1 = _LowLevel.CKA_PRIME_1 CKA_PRIME_2 = _LowLevel.CKA_PRIME_2 CKA_EXPONENT_1 = _LowLevel.CKA_EXPONENT_1 CKA_EXPONENT_2 = _LowLevel.CKA_EXPONENT_2 CKA_COEFFICIENT = _LowLevel.CKA_COEFFICIENT CKA_PRIME = _LowLevel.CKA_PRIME CKA_SUBPRIME = _LowLevel.CKA_SUBPRIME CKA_BASE = _LowLevel.CKA_BASE CKA_PRIME_BITS = _LowLevel.CKA_PRIME_BITS CKA_SUBPRIME_BITS = _LowLevel.CKA_SUBPRIME_BITS CKA_SUB_PRIME_BITS = _LowLevel.CKA_SUB_PRIME_BITS CKA_VALUE_BITS = _LowLevel.CKA_VALUE_BITS CKA_VALUE_LEN = _LowLevel.CKA_VALUE_LEN CKA_EXTRACTABLE = _LowLevel.CKA_EXTRACTABLE CKA_LOCAL = _LowLevel.CKA_LOCAL CKA_NEVER_EXTRACTABLE = _LowLevel.CKA_NEVER_EXTRACTABLE CKA_ALWAYS_SENSITIVE = _LowLevel.CKA_ALWAYS_SENSITIVE CKA_KEY_GEN_MECHANISM = _LowLevel.CKA_KEY_GEN_MECHANISM CKA_MODIFIABLE = _LowLevel.CKA_MODIFIABLE CKA_ECDSA_PARAMS = _LowLevel.CKA_ECDSA_PARAMS CKA_EC_PARAMS = _LowLevel.CKA_EC_PARAMS CKA_EC_POINT = _LowLevel.CKA_EC_POINT CKA_SECONDARY_AUTH = _LowLevel.CKA_SECONDARY_AUTH CKA_AUTH_PIN_FLAGS = _LowLevel.CKA_AUTH_PIN_FLAGS CKA_HW_FEATURE_TYPE = _LowLevel.CKA_HW_FEATURE_TYPE CKA_RESET_ON_INIT = _LowLevel.CKA_RESET_ON_INIT CKA_HAS_RESET = _LowLevel.CKA_HAS_RESET CKA_VENDOR_DEFINED = _LowLevel.CKA_VENDOR_DEFINED CKM_RSA_PKCS_KEY_PAIR_GEN = _LowLevel.CKM_RSA_PKCS_KEY_PAIR_GEN CKM_RSA_PKCS = _LowLevel.CKM_RSA_PKCS CKM_RSA_9796 = _LowLevel.CKM_RSA_9796 CKM_RSA_X_509 = _LowLevel.CKM_RSA_X_509 CKM_MD2_RSA_PKCS = _LowLevel.CKM_MD2_RSA_PKCS CKM_MD5_RSA_PKCS = _LowLevel.CKM_MD5_RSA_PKCS CKM_SHA1_RSA_PKCS = _LowLevel.CKM_SHA1_RSA_PKCS CKM_RIPEMD128_RSA_PKCS = _LowLevel.CKM_RIPEMD128_RSA_PKCS CKM_RIPEMD160_RSA_PKCS = _LowLevel.CKM_RIPEMD160_RSA_PKCS CKM_RSA_PKCS_OAEP = _LowLevel.CKM_RSA_PKCS_OAEP CKM_RSA_X9_31_KEY_PAIR_GEN = _LowLevel.CKM_RSA_X9_31_KEY_PAIR_GEN CKM_RSA_X9_31 = _LowLevel.CKM_RSA_X9_31 CKM_SHA1_RSA_X9_31 = _LowLevel.CKM_SHA1_RSA_X9_31 CKM_RSA_PKCS_PSS = _LowLevel.CKM_RSA_PKCS_PSS CKM_SHA1_RSA_PKCS_PSS = _LowLevel.CKM_SHA1_RSA_PKCS_PSS CKM_DSA_KEY_PAIR_GEN = _LowLevel.CKM_DSA_KEY_PAIR_GEN CKM_DSA = _LowLevel.CKM_DSA CKM_DSA_SHA1 = _LowLevel.CKM_DSA_SHA1 CKM_DH_PKCS_KEY_PAIR_GEN = _LowLevel.CKM_DH_PKCS_KEY_PAIR_GEN CKM_DH_PKCS_DERIVE = _LowLevel.CKM_DH_PKCS_DERIVE CKM_X9_42_DH_KEY_PAIR_GEN = _LowLevel.CKM_X9_42_DH_KEY_PAIR_GEN CKM_X9_42_DH_DERIVE = _LowLevel.CKM_X9_42_DH_DERIVE CKM_X9_42_DH_HYBRID_DERIVE = _LowLevel.CKM_X9_42_DH_HYBRID_DERIVE CKM_X9_42_MQV_DERIVE = _LowLevel.CKM_X9_42_MQV_DERIVE CKM_SHA256_RSA_PKCS = _LowLevel.CKM_SHA256_RSA_PKCS CKM_SHA384_RSA_PKCS = _LowLevel.CKM_SHA384_RSA_PKCS CKM_SHA512_RSA_PKCS = _LowLevel.CKM_SHA512_RSA_PKCS CKM_SHA256_RSA_PKCS_PSS = _LowLevel.CKM_SHA256_RSA_PKCS_PSS CKM_SHA384_RSA_PKCS_PSS = _LowLevel.CKM_SHA384_RSA_PKCS_PSS CKM_SHA512_RSA_PKCS_PSS = _LowLevel.CKM_SHA512_RSA_PKCS_PSS CKM_RC2_KEY_GEN = _LowLevel.CKM_RC2_KEY_GEN CKM_RC2_ECB = _LowLevel.CKM_RC2_ECB CKM_RC2_CBC = _LowLevel.CKM_RC2_CBC CKM_RC2_MAC = _LowLevel.CKM_RC2_MAC CKM_RC2_MAC_GENERAL = _LowLevel.CKM_RC2_MAC_GENERAL CKM_RC2_CBC_PAD = _LowLevel.CKM_RC2_CBC_PAD CKM_RC4_KEY_GEN = _LowLevel.CKM_RC4_KEY_GEN CKM_RC4 = _LowLevel.CKM_RC4 CKM_DES_KEY_GEN = _LowLevel.CKM_DES_KEY_GEN CKM_DES_ECB = _LowLevel.CKM_DES_ECB CKM_DES_CBC = _LowLevel.CKM_DES_CBC CKM_DES_MAC = _LowLevel.CKM_DES_MAC CKM_DES_MAC_GENERAL = _LowLevel.CKM_DES_MAC_GENERAL CKM_DES_CBC_PAD = _LowLevel.CKM_DES_CBC_PAD CKM_DES2_KEY_GEN = _LowLevel.CKM_DES2_KEY_GEN CKM_DES3_KEY_GEN = _LowLevel.CKM_DES3_KEY_GEN CKM_DES3_ECB = _LowLevel.CKM_DES3_ECB CKM_DES3_CBC = _LowLevel.CKM_DES3_CBC CKM_DES3_MAC = _LowLevel.CKM_DES3_MAC CKM_DES3_MAC_GENERAL = _LowLevel.CKM_DES3_MAC_GENERAL CKM_DES3_CBC_PAD = _LowLevel.CKM_DES3_CBC_PAD CKM_CDMF_KEY_GEN = _LowLevel.CKM_CDMF_KEY_GEN CKM_CDMF_ECB = _LowLevel.CKM_CDMF_ECB CKM_CDMF_CBC = _LowLevel.CKM_CDMF_CBC CKM_CDMF_MAC = _LowLevel.CKM_CDMF_MAC CKM_CDMF_MAC_GENERAL = _LowLevel.CKM_CDMF_MAC_GENERAL CKM_CDMF_CBC_PAD = _LowLevel.CKM_CDMF_CBC_PAD CKM_DES_OFB64 = _LowLevel.CKM_DES_OFB64 CKM_DES_OFB8 = _LowLevel.CKM_DES_OFB8 CKM_DES_CFB64 = _LowLevel.CKM_DES_CFB64 CKM_DES_CFB8 = _LowLevel.CKM_DES_CFB8 CKM_MD2 = _LowLevel.CKM_MD2 CKM_MD2_HMAC = _LowLevel.CKM_MD2_HMAC CKM_MD2_HMAC_GENERAL = _LowLevel.CKM_MD2_HMAC_GENERAL CKM_MD5 = _LowLevel.CKM_MD5 CKM_MD5_HMAC = _LowLevel.CKM_MD5_HMAC CKM_MD5_HMAC_GENERAL = _LowLevel.CKM_MD5_HMAC_GENERAL CKM_SHA_1 = _LowLevel.CKM_SHA_1 CKM_SHA_1_HMAC = _LowLevel.CKM_SHA_1_HMAC CKM_SHA_1_HMAC_GENERAL = _LowLevel.CKM_SHA_1_HMAC_GENERAL CKM_RIPEMD128 = _LowLevel.CKM_RIPEMD128 CKM_RIPEMD128_HMAC = _LowLevel.CKM_RIPEMD128_HMAC CKM_RIPEMD128_HMAC_GENERAL = _LowLevel.CKM_RIPEMD128_HMAC_GENERAL CKM_RIPEMD160 = _LowLevel.CKM_RIPEMD160 CKM_RIPEMD160_HMAC = _LowLevel.CKM_RIPEMD160_HMAC CKM_RIPEMD160_HMAC_GENERAL = _LowLevel.CKM_RIPEMD160_HMAC_GENERAL CKM_SHA256 = _LowLevel.CKM_SHA256 CKM_SHA256_HMAC = _LowLevel.CKM_SHA256_HMAC CKM_SHA256_HMAC_GENERAL = _LowLevel.CKM_SHA256_HMAC_GENERAL CKM_SHA384 = _LowLevel.CKM_SHA384 CKM_SHA384_HMAC = _LowLevel.CKM_SHA384_HMAC CKM_SHA384_HMAC_GENERAL = _LowLevel.CKM_SHA384_HMAC_GENERAL CKM_SHA512 = _LowLevel.CKM_SHA512 CKM_SHA512_HMAC = _LowLevel.CKM_SHA512_HMAC CKM_SHA512_HMAC_GENERAL = _LowLevel.CKM_SHA512_HMAC_GENERAL CKM_CAST_KEY_GEN = _LowLevel.CKM_CAST_KEY_GEN CKM_CAST_ECB = _LowLevel.CKM_CAST_ECB CKM_CAST_CBC = _LowLevel.CKM_CAST_CBC CKM_CAST_MAC = _LowLevel.CKM_CAST_MAC CKM_CAST_MAC_GENERAL = _LowLevel.CKM_CAST_MAC_GENERAL CKM_CAST_CBC_PAD = _LowLevel.CKM_CAST_CBC_PAD CKM_CAST3_KEY_GEN = _LowLevel.CKM_CAST3_KEY_GEN CKM_CAST3_ECB = _LowLevel.CKM_CAST3_ECB CKM_CAST3_CBC = _LowLevel.CKM_CAST3_CBC CKM_CAST3_MAC = _LowLevel.CKM_CAST3_MAC CKM_CAST3_MAC_GENERAL = _LowLevel.CKM_CAST3_MAC_GENERAL CKM_CAST3_CBC_PAD = _LowLevel.CKM_CAST3_CBC_PAD CKM_CAST5_KEY_GEN = _LowLevel.CKM_CAST5_KEY_GEN CKM_CAST128_KEY_GEN = _LowLevel.CKM_CAST128_KEY_GEN CKM_CAST5_ECB = _LowLevel.CKM_CAST5_ECB CKM_CAST128_ECB = _LowLevel.CKM_CAST128_ECB CKM_CAST5_CBC = _LowLevel.CKM_CAST5_CBC CKM_CAST128_CBC = _LowLevel.CKM_CAST128_CBC CKM_CAST5_MAC = _LowLevel.CKM_CAST5_MAC CKM_CAST128_MAC = _LowLevel.CKM_CAST128_MAC CKM_CAST5_MAC_GENERAL = _LowLevel.CKM_CAST5_MAC_GENERAL CKM_CAST128_MAC_GENERAL = _LowLevel.CKM_CAST128_MAC_GENERAL CKM_CAST5_CBC_PAD = _LowLevel.CKM_CAST5_CBC_PAD CKM_CAST128_CBC_PAD = _LowLevel.CKM_CAST128_CBC_PAD CKM_RC5_KEY_GEN = _LowLevel.CKM_RC5_KEY_GEN CKM_RC5_ECB = _LowLevel.CKM_RC5_ECB CKM_RC5_CBC = _LowLevel.CKM_RC5_CBC CKM_RC5_MAC = _LowLevel.CKM_RC5_MAC CKM_RC5_MAC_GENERAL = _LowLevel.CKM_RC5_MAC_GENERAL CKM_RC5_CBC_PAD = _LowLevel.CKM_RC5_CBC_PAD CKM_IDEA_KEY_GEN = _LowLevel.CKM_IDEA_KEY_GEN CKM_IDEA_ECB = _LowLevel.CKM_IDEA_ECB CKM_IDEA_CBC = _LowLevel.CKM_IDEA_CBC CKM_IDEA_MAC = _LowLevel.CKM_IDEA_MAC CKM_IDEA_MAC_GENERAL = _LowLevel.CKM_IDEA_MAC_GENERAL CKM_IDEA_CBC_PAD = _LowLevel.CKM_IDEA_CBC_PAD CKM_GENERIC_SECRET_KEY_GEN = _LowLevel.CKM_GENERIC_SECRET_KEY_GEN CKM_CONCATENATE_BASE_AND_KEY = _LowLevel.CKM_CONCATENATE_BASE_AND_KEY CKM_CONCATENATE_BASE_AND_DATA = _LowLevel.CKM_CONCATENATE_BASE_AND_DATA CKM_CONCATENATE_DATA_AND_BASE = _LowLevel.CKM_CONCATENATE_DATA_AND_BASE CKM_XOR_BASE_AND_DATA = _LowLevel.CKM_XOR_BASE_AND_DATA CKM_EXTRACT_KEY_FROM_KEY = _LowLevel.CKM_EXTRACT_KEY_FROM_KEY CKM_SSL3_PRE_MASTER_KEY_GEN = _LowLevel.CKM_SSL3_PRE_MASTER_KEY_GEN CKM_SSL3_MASTER_KEY_DERIVE = _LowLevel.CKM_SSL3_MASTER_KEY_DERIVE CKM_SSL3_KEY_AND_MAC_DERIVE = _LowLevel.CKM_SSL3_KEY_AND_MAC_DERIVE CKM_SSL3_MASTER_KEY_DERIVE_DH = _LowLevel.CKM_SSL3_MASTER_KEY_DERIVE_DH CKM_TLS_PRE_MASTER_KEY_GEN = _LowLevel.CKM_TLS_PRE_MASTER_KEY_GEN CKM_TLS_MASTER_KEY_DERIVE = _LowLevel.CKM_TLS_MASTER_KEY_DERIVE CKM_TLS_KEY_AND_MAC_DERIVE = _LowLevel.CKM_TLS_KEY_AND_MAC_DERIVE CKM_TLS_MASTER_KEY_DERIVE_DH = _LowLevel.CKM_TLS_MASTER_KEY_DERIVE_DH CKM_TLS_PRF = _LowLevel.CKM_TLS_PRF CKM_SSL3_MD5_MAC = _LowLevel.CKM_SSL3_MD5_MAC CKM_SSL3_SHA1_MAC = _LowLevel.CKM_SSL3_SHA1_MAC CKM_MD5_KEY_DERIVATION = _LowLevel.CKM_MD5_KEY_DERIVATION CKM_MD2_KEY_DERIVATION = _LowLevel.CKM_MD2_KEY_DERIVATION CKM_SHA1_KEY_DERIVATION = _LowLevel.CKM_SHA1_KEY_DERIVATION CKM_SHA256_KEY_DERIVATION = _LowLevel.CKM_SHA256_KEY_DERIVATION CKM_SHA384_KEY_DERIVATION = _LowLevel.CKM_SHA384_KEY_DERIVATION CKM_SHA512_KEY_DERIVATION = _LowLevel.CKM_SHA512_KEY_DERIVATION CKM_PBE_MD2_DES_CBC = _LowLevel.CKM_PBE_MD2_DES_CBC CKM_PBE_MD5_DES_CBC = _LowLevel.CKM_PBE_MD5_DES_CBC CKM_PBE_MD5_CAST_CBC = _LowLevel.CKM_PBE_MD5_CAST_CBC CKM_PBE_MD5_CAST3_CBC = _LowLevel.CKM_PBE_MD5_CAST3_CBC CKM_PBE_MD5_CAST5_CBC = _LowLevel.CKM_PBE_MD5_CAST5_CBC CKM_PBE_MD5_CAST128_CBC = _LowLevel.CKM_PBE_MD5_CAST128_CBC CKM_PBE_SHA1_CAST5_CBC = _LowLevel.CKM_PBE_SHA1_CAST5_CBC CKM_PBE_SHA1_CAST128_CBC = _LowLevel.CKM_PBE_SHA1_CAST128_CBC CKM_PBE_SHA1_RC4_128 = _LowLevel.CKM_PBE_SHA1_RC4_128 CKM_PBE_SHA1_RC4_40 = _LowLevel.CKM_PBE_SHA1_RC4_40 CKM_PBE_SHA1_DES3_EDE_CBC = _LowLevel.CKM_PBE_SHA1_DES3_EDE_CBC CKM_PBE_SHA1_DES2_EDE_CBC = _LowLevel.CKM_PBE_SHA1_DES2_EDE_CBC CKM_PBE_SHA1_RC2_128_CBC = _LowLevel.CKM_PBE_SHA1_RC2_128_CBC CKM_PBE_SHA1_RC2_40_CBC = _LowLevel.CKM_PBE_SHA1_RC2_40_CBC CKM_PKCS5_PBKD2 = _LowLevel.CKM_PKCS5_PBKD2 CKM_PBA_SHA1_WITH_SHA1_HMAC = _LowLevel.CKM_PBA_SHA1_WITH_SHA1_HMAC CKM_WTLS_PRE_MASTER_KEY_GEN = _LowLevel.CKM_WTLS_PRE_MASTER_KEY_GEN CKM_WTLS_MASTER_KEY_DERIVE = _LowLevel.CKM_WTLS_MASTER_KEY_DERIVE CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC = _LowLevel.CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC CKM_WTLS_PRF = _LowLevel.CKM_WTLS_PRF CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE = _LowLevel.CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE = _LowLevel.CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE CKM_KEY_WRAP_LYNKS = _LowLevel.CKM_KEY_WRAP_LYNKS CKM_KEY_WRAP_SET_OAEP = _LowLevel.CKM_KEY_WRAP_SET_OAEP CKM_CMS_SIG = _LowLevel.CKM_CMS_SIG CKM_SKIPJACK_KEY_GEN = _LowLevel.CKM_SKIPJACK_KEY_GEN CKM_SKIPJACK_ECB64 = _LowLevel.CKM_SKIPJACK_ECB64 CKM_SKIPJACK_CBC64 = _LowLevel.CKM_SKIPJACK_CBC64 CKM_SKIPJACK_OFB64 = _LowLevel.CKM_SKIPJACK_OFB64 CKM_SKIPJACK_CFB64 = _LowLevel.CKM_SKIPJACK_CFB64 CKM_SKIPJACK_CFB32 = _LowLevel.CKM_SKIPJACK_CFB32 CKM_SKIPJACK_CFB16 = _LowLevel.CKM_SKIPJACK_CFB16 CKM_SKIPJACK_CFB8 = _LowLevel.CKM_SKIPJACK_CFB8 CKM_SKIPJACK_WRAP = _LowLevel.CKM_SKIPJACK_WRAP CKM_SKIPJACK_PRIVATE_WRAP = _LowLevel.CKM_SKIPJACK_PRIVATE_WRAP CKM_SKIPJACK_RELAYX = _LowLevel.CKM_SKIPJACK_RELAYX CKM_KEA_KEY_PAIR_GEN = _LowLevel.CKM_KEA_KEY_PAIR_GEN CKM_KEA_KEY_DERIVE = _LowLevel.CKM_KEA_KEY_DERIVE CKM_FORTEZZA_TIMESTAMP = _LowLevel.CKM_FORTEZZA_TIMESTAMP CKM_BATON_KEY_GEN = _LowLevel.CKM_BATON_KEY_GEN CKM_BATON_ECB128 = _LowLevel.CKM_BATON_ECB128 CKM_BATON_ECB96 = _LowLevel.CKM_BATON_ECB96 CKM_BATON_CBC128 = _LowLevel.CKM_BATON_CBC128 CKM_BATON_COUNTER = _LowLevel.CKM_BATON_COUNTER CKM_BATON_SHUFFLE = _LowLevel.CKM_BATON_SHUFFLE CKM_BATON_WRAP = _LowLevel.CKM_BATON_WRAP CKM_ECDSA_KEY_PAIR_GEN = _LowLevel.CKM_ECDSA_KEY_PAIR_GEN CKM_EC_KEY_PAIR_GEN = _LowLevel.CKM_EC_KEY_PAIR_GEN CKM_ECDSA = _LowLevel.CKM_ECDSA CKM_ECDSA_SHA1 = _LowLevel.CKM_ECDSA_SHA1 CKM_ECDH1_DERIVE = _LowLevel.CKM_ECDH1_DERIVE CKM_ECDH1_COFACTOR_DERIVE = _LowLevel.CKM_ECDH1_COFACTOR_DERIVE CKM_ECMQV_DERIVE = _LowLevel.CKM_ECMQV_DERIVE CKM_JUNIPER_KEY_GEN = _LowLevel.CKM_JUNIPER_KEY_GEN CKM_JUNIPER_ECB128 = _LowLevel.CKM_JUNIPER_ECB128 CKM_JUNIPER_CBC128 = _LowLevel.CKM_JUNIPER_CBC128 CKM_JUNIPER_COUNTER = _LowLevel.CKM_JUNIPER_COUNTER CKM_JUNIPER_SHUFFLE = _LowLevel.CKM_JUNIPER_SHUFFLE CKM_JUNIPER_WRAP = _LowLevel.CKM_JUNIPER_WRAP CKM_FASTHASH = _LowLevel.CKM_FASTHASH CKM_AES_KEY_GEN = _LowLevel.CKM_AES_KEY_GEN CKM_AES_ECB = _LowLevel.CKM_AES_ECB CKM_AES_CBC = _LowLevel.CKM_AES_CBC CKM_AES_MAC = _LowLevel.CKM_AES_MAC CKM_AES_MAC_GENERAL = _LowLevel.CKM_AES_MAC_GENERAL CKM_AES_CBC_PAD = _LowLevel.CKM_AES_CBC_PAD CKM_BLOWFISH_KEY_GEN = _LowLevel.CKM_BLOWFISH_KEY_GEN CKM_BLOWFISH_CBC = _LowLevel.CKM_BLOWFISH_CBC CKM_TWOFISH_KEY_GEN = _LowLevel.CKM_TWOFISH_KEY_GEN CKM_TWOFISH_CBC = _LowLevel.CKM_TWOFISH_CBC CKM_DES_ECB_ENCRYPT_DATA = _LowLevel.CKM_DES_ECB_ENCRYPT_DATA CKM_DES_CBC_ENCRYPT_DATA = _LowLevel.CKM_DES_CBC_ENCRYPT_DATA CKM_DES3_ECB_ENCRYPT_DATA = _LowLevel.CKM_DES3_ECB_ENCRYPT_DATA CKM_DES3_CBC_ENCRYPT_DATA = _LowLevel.CKM_DES3_CBC_ENCRYPT_DATA CKM_AES_ECB_ENCRYPT_DATA = _LowLevel.CKM_AES_ECB_ENCRYPT_DATA CKM_AES_CBC_ENCRYPT_DATA = _LowLevel.CKM_AES_CBC_ENCRYPT_DATA CKM_DSA_PARAMETER_GEN = _LowLevel.CKM_DSA_PARAMETER_GEN CKM_DH_PKCS_PARAMETER_GEN = _LowLevel.CKM_DH_PKCS_PARAMETER_GEN CKM_X9_42_DH_PARAMETER_GEN = _LowLevel.CKM_X9_42_DH_PARAMETER_GEN CKM_VENDOR_DEFINED = _LowLevel.CKM_VENDOR_DEFINED CKF_HW = _LowLevel.CKF_HW CKF_ENCRYPT = _LowLevel.CKF_ENCRYPT CKF_DECRYPT = _LowLevel.CKF_DECRYPT CKF_DIGEST = _LowLevel.CKF_DIGEST CKF_SIGN = _LowLevel.CKF_SIGN CKF_SIGN_RECOVER = _LowLevel.CKF_SIGN_RECOVER CKF_VERIFY = _LowLevel.CKF_VERIFY CKF_VERIFY_RECOVER = _LowLevel.CKF_VERIFY_RECOVER CKF_GENERATE = _LowLevel.CKF_GENERATE CKF_GENERATE_KEY_PAIR = _LowLevel.CKF_GENERATE_KEY_PAIR CKF_WRAP = _LowLevel.CKF_WRAP CKF_UNWRAP = _LowLevel.CKF_UNWRAP CKF_DERIVE = _LowLevel.CKF_DERIVE CKF_EC_F_P = _LowLevel.CKF_EC_F_P CKF_EC_F_2M = _LowLevel.CKF_EC_F_2M CKF_EC_ECPARAMETERS = _LowLevel.CKF_EC_ECPARAMETERS CKF_EC_NAMEDCURVE = _LowLevel.CKF_EC_NAMEDCURVE CKF_EC_UNCOMPRESS = _LowLevel.CKF_EC_UNCOMPRESS CKF_EC_COMPRESS = _LowLevel.CKF_EC_COMPRESS CKF_EXTENSION = _LowLevel.CKF_EXTENSION CKR_OK = _LowLevel.CKR_OK CKR_CANCEL = _LowLevel.CKR_CANCEL CKR_HOST_MEMORY = _LowLevel.CKR_HOST_MEMORY CKR_SLOT_ID_INVALID = _LowLevel.CKR_SLOT_ID_INVALID CKR_GENERAL_ERROR = _LowLevel.CKR_GENERAL_ERROR CKR_FUNCTION_FAILED = _LowLevel.CKR_FUNCTION_FAILED CKR_ARGUMENTS_BAD = _LowLevel.CKR_ARGUMENTS_BAD CKR_NO_EVENT = _LowLevel.CKR_NO_EVENT CKR_NEED_TO_CREATE_THREADS = _LowLevel.CKR_NEED_TO_CREATE_THREADS CKR_CANT_LOCK = _LowLevel.CKR_CANT_LOCK CKR_ATTRIBUTE_READ_ONLY = _LowLevel.CKR_ATTRIBUTE_READ_ONLY CKR_ATTRIBUTE_SENSITIVE = _LowLevel.CKR_ATTRIBUTE_SENSITIVE CKR_ATTRIBUTE_TYPE_INVALID = _LowLevel.CKR_ATTRIBUTE_TYPE_INVALID CKR_ATTRIBUTE_VALUE_INVALID = _LowLevel.CKR_ATTRIBUTE_VALUE_INVALID CKR_DATA_INVALID = _LowLevel.CKR_DATA_INVALID CKR_DATA_LEN_RANGE = _LowLevel.CKR_DATA_LEN_RANGE CKR_DEVICE_ERROR = _LowLevel.CKR_DEVICE_ERROR CKR_DEVICE_MEMORY = _LowLevel.CKR_DEVICE_MEMORY CKR_DEVICE_REMOVED = _LowLevel.CKR_DEVICE_REMOVED CKR_ENCRYPTED_DATA_INVALID = _LowLevel.CKR_ENCRYPTED_DATA_INVALID CKR_ENCRYPTED_DATA_LEN_RANGE = _LowLevel.CKR_ENCRYPTED_DATA_LEN_RANGE CKR_FUNCTION_CANCELED = _LowLevel.CKR_FUNCTION_CANCELED CKR_FUNCTION_NOT_PARALLEL = _LowLevel.CKR_FUNCTION_NOT_PARALLEL CKR_FUNCTION_NOT_SUPPORTED = _LowLevel.CKR_FUNCTION_NOT_SUPPORTED CKR_KEY_HANDLE_INVALID = _LowLevel.CKR_KEY_HANDLE_INVALID CKR_KEY_SIZE_RANGE = _LowLevel.CKR_KEY_SIZE_RANGE CKR_KEY_TYPE_INCONSISTENT = _LowLevel.CKR_KEY_TYPE_INCONSISTENT CKR_KEY_NOT_NEEDED = _LowLevel.CKR_KEY_NOT_NEEDED CKR_KEY_CHANGED = _LowLevel.CKR_KEY_CHANGED CKR_KEY_NEEDED = _LowLevel.CKR_KEY_NEEDED CKR_KEY_INDIGESTIBLE = _LowLevel.CKR_KEY_INDIGESTIBLE CKR_KEY_FUNCTION_NOT_PERMITTED = _LowLevel.CKR_KEY_FUNCTION_NOT_PERMITTED CKR_KEY_NOT_WRAPPABLE = _LowLevel.CKR_KEY_NOT_WRAPPABLE CKR_KEY_UNEXTRACTABLE = _LowLevel.CKR_KEY_UNEXTRACTABLE CKR_MECHANISM_INVALID = _LowLevel.CKR_MECHANISM_INVALID CKR_MECHANISM_PARAM_INVALID = _LowLevel.CKR_MECHANISM_PARAM_INVALID CKR_OBJECT_HANDLE_INVALID = _LowLevel.CKR_OBJECT_HANDLE_INVALID CKR_OPERATION_ACTIVE = _LowLevel.CKR_OPERATION_ACTIVE CKR_OPERATION_NOT_INITIALIZED = _LowLevel.CKR_OPERATION_NOT_INITIALIZED CKR_PIN_INCORRECT = _LowLevel.CKR_PIN_INCORRECT CKR_PIN_INVALID = _LowLevel.CKR_PIN_INVALID CKR_PIN_LEN_RANGE = _LowLevel.CKR_PIN_LEN_RANGE CKR_PIN_EXPIRED = _LowLevel.CKR_PIN_EXPIRED CKR_PIN_LOCKED = _LowLevel.CKR_PIN_LOCKED CKR_SESSION_CLOSED = _LowLevel.CKR_SESSION_CLOSED CKR_SESSION_COUNT = _LowLevel.CKR_SESSION_COUNT CKR_SESSION_HANDLE_INVALID = _LowLevel.CKR_SESSION_HANDLE_INVALID CKR_SESSION_PARALLEL_NOT_SUPPORTED = _LowLevel.CKR_SESSION_PARALLEL_NOT_SUPPORTED CKR_SESSION_READ_ONLY = _LowLevel.CKR_SESSION_READ_ONLY CKR_SESSION_EXISTS = _LowLevel.CKR_SESSION_EXISTS CKR_SESSION_READ_ONLY_EXISTS = _LowLevel.CKR_SESSION_READ_ONLY_EXISTS CKR_SESSION_READ_WRITE_SO_EXISTS = _LowLevel.CKR_SESSION_READ_WRITE_SO_EXISTS CKR_SIGNATURE_INVALID = _LowLevel.CKR_SIGNATURE_INVALID CKR_SIGNATURE_LEN_RANGE = _LowLevel.CKR_SIGNATURE_LEN_RANGE CKR_TEMPLATE_INCOMPLETE = _LowLevel.CKR_TEMPLATE_INCOMPLETE CKR_TEMPLATE_INCONSISTENT = _LowLevel.CKR_TEMPLATE_INCONSISTENT CKR_TOKEN_NOT_PRESENT = _LowLevel.CKR_TOKEN_NOT_PRESENT CKR_TOKEN_NOT_RECOGNIZED = _LowLevel.CKR_TOKEN_NOT_RECOGNIZED CKR_TOKEN_WRITE_PROTECTED = _LowLevel.CKR_TOKEN_WRITE_PROTECTED CKR_UNWRAPPING_KEY_HANDLE_INVALID = _LowLevel.CKR_UNWRAPPING_KEY_HANDLE_INVALID CKR_UNWRAPPING_KEY_SIZE_RANGE = _LowLevel.CKR_UNWRAPPING_KEY_SIZE_RANGE CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT = _LowLevel.CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT CKR_USER_ALREADY_LOGGED_IN = _LowLevel.CKR_USER_ALREADY_LOGGED_IN CKR_USER_NOT_LOGGED_IN = _LowLevel.CKR_USER_NOT_LOGGED_IN CKR_USER_PIN_NOT_INITIALIZED = _LowLevel.CKR_USER_PIN_NOT_INITIALIZED CKR_USER_TYPE_INVALID = _LowLevel.CKR_USER_TYPE_INVALID CKR_USER_ANOTHER_ALREADY_LOGGED_IN = _LowLevel.CKR_USER_ANOTHER_ALREADY_LOGGED_IN CKR_USER_TOO_MANY_TYPES = _LowLevel.CKR_USER_TOO_MANY_TYPES CKR_WRAPPED_KEY_INVALID = _LowLevel.CKR_WRAPPED_KEY_INVALID CKR_WRAPPED_KEY_LEN_RANGE = _LowLevel.CKR_WRAPPED_KEY_LEN_RANGE CKR_WRAPPING_KEY_HANDLE_INVALID = _LowLevel.CKR_WRAPPING_KEY_HANDLE_INVALID CKR_WRAPPING_KEY_SIZE_RANGE = _LowLevel.CKR_WRAPPING_KEY_SIZE_RANGE CKR_WRAPPING_KEY_TYPE_INCONSISTENT = _LowLevel.CKR_WRAPPING_KEY_TYPE_INCONSISTENT CKR_RANDOM_SEED_NOT_SUPPORTED = _LowLevel.CKR_RANDOM_SEED_NOT_SUPPORTED CKR_RANDOM_NO_RNG = _LowLevel.CKR_RANDOM_NO_RNG CKR_DOMAIN_PARAMS_INVALID = _LowLevel.CKR_DOMAIN_PARAMS_INVALID CKR_BUFFER_TOO_SMALL = _LowLevel.CKR_BUFFER_TOO_SMALL CKR_SAVED_STATE_INVALID = _LowLevel.CKR_SAVED_STATE_INVALID CKR_INFORMATION_SENSITIVE = _LowLevel.CKR_INFORMATION_SENSITIVE CKR_STATE_UNSAVEABLE = _LowLevel.CKR_STATE_UNSAVEABLE CKR_CRYPTOKI_NOT_INITIALIZED = _LowLevel.CKR_CRYPTOKI_NOT_INITIALIZED CKR_CRYPTOKI_ALREADY_INITIALIZED = _LowLevel.CKR_CRYPTOKI_ALREADY_INITIALIZED CKR_MUTEX_BAD = _LowLevel.CKR_MUTEX_BAD CKR_MUTEX_NOT_LOCKED = _LowLevel.CKR_MUTEX_NOT_LOCKED CKR_VENDOR_DEFINED = _LowLevel.CKR_VENDOR_DEFINED CKF_LIBRARY_CANT_CREATE_OS_THREADS = _LowLevel.CKF_LIBRARY_CANT_CREATE_OS_THREADS CKF_OS_LOCKING_OK = _LowLevel.CKF_OS_LOCKING_OK CKF_DONT_BLOCK = _LowLevel.CKF_DONT_BLOCK CKG_MGF1_SHA1 = _LowLevel.CKG_MGF1_SHA1 CKZ_DATA_SPECIFIED = _LowLevel.CKZ_DATA_SPECIFIED CKD_NULL = _LowLevel.CKD_NULL CKD_SHA1_KDF = _LowLevel.CKD_SHA1_KDF CKD_SHA1_KDF_ASN1 = _LowLevel.CKD_SHA1_KDF_ASN1 CKD_SHA1_KDF_CONCATENATE = _LowLevel.CKD_SHA1_KDF_CONCATENATE CKP_PKCS5_PBKD2_HMAC_SHA1 = _LowLevel.CKP_PKCS5_PBKD2_HMAC_SHA1 CKZ_SALT_SPECIFIED = _LowLevel.CKZ_SALT_SPECIFIED class CPKCS11Lib(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CPKCS11Lib, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CPKCS11Lib, name) __repr__ = _swig_repr def __init__(self): this = _LowLevel.new_CPKCS11Lib() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CPKCS11Lib __del__ = lambda self : None; def Load(self, *args): return _LowLevel.CPKCS11Lib_Load(self, *args) def Unload(self): return _LowLevel.CPKCS11Lib_Unload(self) def C_Initialize(self): return _LowLevel.CPKCS11Lib_C_Initialize(self) def C_Finalize(self): return _LowLevel.CPKCS11Lib_C_Finalize(self) def C_GetInfo(self, *args): return _LowLevel.CPKCS11Lib_C_GetInfo(self, *args) def C_GetSlotList(self, *args): return _LowLevel.CPKCS11Lib_C_GetSlotList(self, *args) def C_GetSlotInfo(self, *args): return _LowLevel.CPKCS11Lib_C_GetSlotInfo(self, *args) def C_GetTokenInfo(self, *args): return _LowLevel.CPKCS11Lib_C_GetTokenInfo(self, *args) def C_InitToken(self, *args): return _LowLevel.CPKCS11Lib_C_InitToken(self, *args) def C_InitPIN(self, *args): return _LowLevel.CPKCS11Lib_C_InitPIN(self, *args) def C_SetPIN(self, *args): return _LowLevel.CPKCS11Lib_C_SetPIN(self, *args) def C_OpenSession(self, *args): return _LowLevel.CPKCS11Lib_C_OpenSession(self, *args) def C_CloseSession(self, *args): return _LowLevel.CPKCS11Lib_C_CloseSession(self, *args) def C_CloseAllSessions(self, *args): return _LowLevel.CPKCS11Lib_C_CloseAllSessions(self, *args) def C_GetSessionInfo(self, *args): return _LowLevel.CPKCS11Lib_C_GetSessionInfo(self, *args) def C_Login(self, *args): return _LowLevel.CPKCS11Lib_C_Login(self, *args) def C_Logout(self, *args): return _LowLevel.CPKCS11Lib_C_Logout(self, *args) def C_CreateObject(self, *args): return _LowLevel.CPKCS11Lib_C_CreateObject(self, *args) def C_DestroyObject(self, *args): return _LowLevel.CPKCS11Lib_C_DestroyObject(self, *args) def C_GetObjectSize(self, *args): return _LowLevel.CPKCS11Lib_C_GetObjectSize(self, *args) def C_GetAttributeValue(self, *args): return _LowLevel.CPKCS11Lib_C_GetAttributeValue(self, *args) def C_SetAttributeValue(self, *args): return _LowLevel.CPKCS11Lib_C_SetAttributeValue(self, *args) def C_FindObjectsInit(self, *args): return _LowLevel.CPKCS11Lib_C_FindObjectsInit(self, *args) def C_FindObjects(self, *args): return _LowLevel.CPKCS11Lib_C_FindObjects(self, *args) def C_FindObjectsFinal(self, *args): return _LowLevel.CPKCS11Lib_C_FindObjectsFinal(self, *args) def C_EncryptInit(self, *args): return _LowLevel.CPKCS11Lib_C_EncryptInit(self, *args) def C_Encrypt(self, *args): return _LowLevel.CPKCS11Lib_C_Encrypt(self, *args) def C_EncryptUpdate(self, *args): return _LowLevel.CPKCS11Lib_C_EncryptUpdate(self, *args) def C_EncryptFinal(self, *args): return _LowLevel.CPKCS11Lib_C_EncryptFinal(self, *args) def C_DecryptInit(self, *args): return _LowLevel.CPKCS11Lib_C_DecryptInit(self, *args) def C_Decrypt(self, *args): return _LowLevel.CPKCS11Lib_C_Decrypt(self, *args) def C_DecryptUpdate(self, *args): return _LowLevel.CPKCS11Lib_C_DecryptUpdate(self, *args) def C_DecryptFinal(self, *args): return _LowLevel.CPKCS11Lib_C_DecryptFinal(self, *args) def C_DigestInit(self, *args): return _LowLevel.CPKCS11Lib_C_DigestInit(self, *args) def C_Digest(self, *args): return _LowLevel.CPKCS11Lib_C_Digest(self, *args) def C_DigestUpdate(self, *args): return _LowLevel.CPKCS11Lib_C_DigestUpdate(self, *args) def C_DigestKey(self, *args): return _LowLevel.CPKCS11Lib_C_DigestKey(self, *args) def C_DigestFinal(self, *args): return _LowLevel.CPKCS11Lib_C_DigestFinal(self, *args) def C_SignInit(self, *args): return _LowLevel.CPKCS11Lib_C_SignInit(self, *args) def C_Sign(self, *args): return _LowLevel.CPKCS11Lib_C_Sign(self, *args) def C_SignUpdate(self, *args): return _LowLevel.CPKCS11Lib_C_SignUpdate(self, *args) def C_SignFinal(self, *args): return _LowLevel.CPKCS11Lib_C_SignFinal(self, *args) def C_VerifyInit(self, *args): return _LowLevel.CPKCS11Lib_C_VerifyInit(self, *args) def C_Verify(self, *args): return _LowLevel.CPKCS11Lib_C_Verify(self, *args) def C_VerifyUpdate(self, *args): return _LowLevel.CPKCS11Lib_C_VerifyUpdate(self, *args) def C_VerifyFinal(self, *args): return _LowLevel.CPKCS11Lib_C_VerifyFinal(self, *args) def C_GenerateKey(self, *args): return _LowLevel.CPKCS11Lib_C_GenerateKey(self, *args) def C_GenerateKeyPair(self, *args): return _LowLevel.CPKCS11Lib_C_GenerateKeyPair(self, *args) def C_WrapKey(self, *args): return _LowLevel.CPKCS11Lib_C_WrapKey(self, *args) def C_UnwrapKey(self, *args): return _LowLevel.CPKCS11Lib_C_UnwrapKey(self, *args) def C_SeedRandom(self, *args): return _LowLevel.CPKCS11Lib_C_SeedRandom(self, *args) def C_GenerateRandom(self, *args): return _LowLevel.CPKCS11Lib_C_GenerateRandom(self, *args) def C_WaitForSlotEvent(self, *args): return _LowLevel.CPKCS11Lib_C_WaitForSlotEvent(self, *args) def C_GetMechanismList(self, *args): return _LowLevel.CPKCS11Lib_C_GetMechanismList(self, *args) def C_GetMechanismInfo(self, *args): return _LowLevel.CPKCS11Lib_C_GetMechanismInfo(self, *args) CPKCS11Lib_swigregister = _LowLevel.CPKCS11Lib_swigregister CPKCS11Lib_swigregister(CPKCS11Lib) class CK_ATTRIBUTE_SMART(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CK_ATTRIBUTE_SMART, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CK_ATTRIBUTE_SMART, name) __repr__ = _swig_repr def Reset(self): return _LowLevel.CK_ATTRIBUTE_SMART_Reset(self) def ResetValue(self): return _LowLevel.CK_ATTRIBUTE_SMART_ResetValue(self) def Reserve(self, *args): return _LowLevel.CK_ATTRIBUTE_SMART_Reserve(self, *args) def GetType(self): return _LowLevel.CK_ATTRIBUTE_SMART_GetType(self) def SetType(self, *args): return _LowLevel.CK_ATTRIBUTE_SMART_SetType(self, *args) def GetLen(self): return _LowLevel.CK_ATTRIBUTE_SMART_GetLen(self) def IsString(self): return _LowLevel.CK_ATTRIBUTE_SMART_IsString(self) def IsBool(self): return _LowLevel.CK_ATTRIBUTE_SMART_IsBool(self) def IsNum(self): return _LowLevel.CK_ATTRIBUTE_SMART_IsNum(self) def IsBin(self): return _LowLevel.CK_ATTRIBUTE_SMART_IsBin(self) def GetString(self): return _LowLevel.CK_ATTRIBUTE_SMART_GetString(self) def SetString(self, *args): return _LowLevel.CK_ATTRIBUTE_SMART_SetString(self, *args) def GetNum(self): return _LowLevel.CK_ATTRIBUTE_SMART_GetNum(self) def SetNum(self, *args): return _LowLevel.CK_ATTRIBUTE_SMART_SetNum(self, *args) def GetBool(self): return _LowLevel.CK_ATTRIBUTE_SMART_GetBool(self) def SetBool(self, *args): return _LowLevel.CK_ATTRIBUTE_SMART_SetBool(self, *args) def GetBin(self): return _LowLevel.CK_ATTRIBUTE_SMART_GetBin(self) def SetBin(self, *args): return _LowLevel.CK_ATTRIBUTE_SMART_SetBin(self, *args) def __init__(self): this = _LowLevel.new_CK_ATTRIBUTE_SMART() try: self.this.append(this) except: self.this = this __swig_destroy__ = _LowLevel.delete_CK_ATTRIBUTE_SMART __del__ = lambda self : None; CK_ATTRIBUTE_SMART_swigregister = _LowLevel.CK_ATTRIBUTE_SMART_swigregister CK_ATTRIBUTE_SMART_swigregister(CK_ATTRIBUTE_SMART) # This file is compatible with both classic and new-style classes. PyKCS11-1.2.4/Makefile0000644000175000017500000000153011744467525016025 0ustar rousseaurousseau00000000000000# give some default values PREFIX ?= /usr DESTDIR ?= / ifeq (, $(PYTHON)) PYTHON=python endif build: build-stamp build-stamp: src/unix_pykcs11_wrap.cpp $(PYTHON) setup.py build touch build-stamp install: build $(PYTHON) setup.py install --prefix=$(PREFIX) --root=$(DESTDIR) clean distclean: $(PYTHON) setup.py clean rm -f src/unix_pykcs11_wrap.cpp rm -rf build rm -f *.pyc PyKCS11/*.pyc rm -f PyKCS11/LowLevel.py rm -f build-stamp rebuild: clean build src/unix_pykcs11_wrap.cpp: src/pykcs11.i cd src ; swig -c++ -python pykcs11.i ; mv pykcs11_wrap.cxx unix_pykcs11_wrap.cpp ; mv LowLevel.py ../PyKCS11 src/pykcs11.i: src/opensc/pkcs11.h src/pkcs11lib.h src/pykcs11string.h src/ck_attribute_smart.h touch $@ dist: $(PYTHON) setup.py sdist doc: build rm -rf html epydoc --verbose PyKCS11 .PHONY: build install clean rebuild dist doc PyKCS11-1.2.4/PyKCS11.sln0000644000175000017500000000202711055022765016164 0ustar rousseaurousseau00000000000000Microsoft Visual Studio Solution File, Format Version 8.00 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PyKCS11", "PyKCS11.vcproj", "{F41B86D5-7C16-4FEC-9ECC-315805589C14}" ProjectSection(ProjectDependencies) = postProject EndProjectSection EndProject Global GlobalSection(DPCodeReviewSolutionGUID) = preSolution DPCodeReviewSolutionGUID = {00000000-0000-0000-0000-000000000000} EndGlobalSection GlobalSection(SolutionConfiguration) = preSolution Debug = Debug Release = Release EndGlobalSection GlobalSection(ProjectConfiguration) = postSolution {F41B86D5-7C16-4FEC-9ECC-315805589C14}.Debug.ActiveCfg = Debug|Win32 {F41B86D5-7C16-4FEC-9ECC-315805589C14}.Debug.Build.0 = Debug|Win32 {F41B86D5-7C16-4FEC-9ECC-315805589C14}.Release.ActiveCfg = Release|Win32 {F41B86D5-7C16-4FEC-9ECC-315805589C14}.Release.Build.0 = Release|Win32 EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution EndGlobalSection GlobalSection(ExtensibilityAddIns) = postSolution EndGlobalSection EndGlobal PyKCS11-1.2.4/PyKCS11.vcproj0000644000175000017500000001564311104332413016670 0ustar rousseaurousseau00000000000000