开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
trivial.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：47k
源码类别：

CA认证

开发平台：

WINDOWS

trivial.c：源码内容
  1. /* 
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is a trivial PKCS#11 test program.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #ifdef DEBUG
  35. static const char CVS_ID[] = "@(#) $RCSfile: trivial.c,v $ $Revision: 1.2 $ $Date: 2000/07/20 21:48:26 $ $Name: NSS_3_1_1_RTM $";
  36. #endif /* DEBUG */
  38. /*
  39.  * This is a very trivial program I wrote for testing out a 
  40.  * couple data-only Cryptoki modules for NSS.  It's not a "real"
  41.  * test program that prints out nice "PASS" or "FAIL" messages;
  42.  * it just makes calls and dumps data.
  43.  */
  45. #include "config.h"
  47. #ifdef HAVE_NSPR_H
  48. #include "nspr.h"
  49. #else
  50. #error "NSPR is required."
  51. #endif
  53. #ifdef WITH_NSS
  54. #define FGMR 1
  55. #include "ck.h"
  56. #else
  57. #include "pkcs11t.h"
  58. #include "pkcs11.h"
  59. #endif
  61. /* The RSA versions are sloppier with namespaces */
  62. #ifndef CK_TRUE
  63. #define CK_TRUE TRUE
  64. #endif
  66. #ifndef CK_FALSE
  67. #define CK_FALSE FALSE
  68. #endif
  70. int
  71. rmain
  72. (
  73.   int argc,
  74.   char *argv[]
  75. );
  77. int
  78. main
  79. (
  80.   int argc,
  81.   char *argv[]
  82. )
  83. {
  84.   int rv = 0;
  86.   PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 14);
  87.   rv = rmain(argc, argv);
  88.   PR_Cleanup();
  90.   return rv;
  91. }
  93. static CK_ATTRIBUTE_TYPE all_known_attribute_types[] = {
  94.   CKA_CLASS,
  95.   CKA_TOKEN,
  96.   CKA_PRIVATE,
  97.   CKA_LABEL,
  98.   CKA_APPLICATION,
  99.   CKA_VALUE,
  100.   CKA_CERTIFICATE_TYPE,
  101.   CKA_ISSUER,
  102.   CKA_SERIAL_NUMBER,
  103.   CKA_KEY_TYPE,
  104.   CKA_SUBJECT,
  105.   CKA_ID,
  106.   CKA_SENSITIVE,
  107.   CKA_ENCRYPT,
  108.   CKA_DECRYPT,
  109.   CKA_WRAP,
  110.   CKA_UNWRAP,
  111.   CKA_SIGN,
  112.   CKA_SIGN_RECOVER,
  113.   CKA_VERIFY,
  114.   CKA_VERIFY_RECOVER,
  115.   CKA_DERIVE,
  116.   CKA_START_DATE,
  117.   CKA_END_DATE,
  118.   CKA_MODULUS,
  119.   CKA_MODULUS_BITS,
  120.   CKA_PUBLIC_EXPONENT,
  121.   CKA_PRIVATE_EXPONENT,
  122.   CKA_PRIME_1,
  123.   CKA_PRIME_2,
  124.   CKA_EXPONENT_1,
  125.   CKA_EXPONENT_2,
  126.   CKA_COEFFICIENT,
  127.   CKA_PRIME,
  128.   CKA_SUBPRIME,
  129.   CKA_BASE,
  130.   CKA_VALUE_BITS,
  131.   CKA_VALUE_LEN,
  132.   CKA_EXTRACTABLE,
  133.   CKA_LOCAL,
  134.   CKA_NEVER_EXTRACTABLE,
  135.   CKA_ALWAYS_SENSITIVE,
  136.   CKA_MODIFIABLE,
  137. #ifdef CKA_NETSCAPE
  138.   CKA_NETSCAPE_URL,
  139.   CKA_NETSCAPE_EMAIL,
  140.   CKA_NETSCAPE_SMIME_INFO,
  141.   CKA_NETSCAPE_SMIME_TIMESTAMP,
  142.   CKA_NETSCAPE_PKCS8_SALT,
  143.   CKA_NETSCAPE_PASSWORD_CHECK,
  144.   CKA_NETSCAPE_EXPIRES,
  145. #endif /* CKA_NETSCAPE */
  146. #ifdef CKA_TRUST
  147.   CKA_TRUST_DIGITAL_SIGNATURE,
  148.   CKA_TRUST_NON_REPUDIATION,
  149.   CKA_TRUST_KEY_ENCIPHERMENT,
  150.   CKA_TRUST_DATA_ENCIPHERMENT,
  151.   CKA_TRUST_KEY_AGREEMENT,
  152.   CKA_TRUST_KEY_CERT_SIGN,
  153.   CKA_TRUST_CRL_SIGN,
  154.   CKA_TRUST_SERVER_AUTH,
  155.   CKA_TRUST_CLIENT_AUTH,
  156.   CKA_TRUST_CODE_SIGNING,
  157.   CKA_TRUST_EMAIL_PROTECTION,
  158.   CKA_TRUST_IPSEC_END_SYSTEM,
  159.   CKA_TRUST_IPSEC_TUNNEL,
  160.   CKA_TRUST_IPSEC_USER,
  161.   CKA_TRUST_TIME_STAMPING,
  162. #endif /* CKA_TRUST */
  163. };
  165. static number_of_all_known_attribute_types = 
  166.   (sizeof(all_known_attribute_types)/sizeof(all_known_attribute_types[0]));
  168. int
  169. usage
  170. (
  171.   char *argv0
  172. )
  173. {
  174.   PR_fprintf(PR_STDERR, "Usage: %s [-i {string|--}] <library>.son", argv0);
  175.   return 1;
  176. }
  178. int
  179. rmain
  180. (
  181.   int argc,
  182.   char *argv[]
  183. )
  184. {
  185.   char *argv0 = argv[0];
  186.   PRLibrary *lib;
  187.   CK_C_GetFunctionList gfl;
  188.   CK_FUNCTION_LIST_PTR epv = (CK_FUNCTION_LIST_PTR)NULL;
  189.   CK_RV ck_rv;
  190.   CK_INFO info;
  191.   CK_ULONG nSlots;
  192.   CK_SLOT_ID *pSlots;
  193.   CK_ULONG i;
  194.   CK_C_INITIALIZE_ARGS ia, *iap;
  196.   (void)memset(&ia, 0, sizeof(CK_C_INITIALIZE_ARGS));
  197.   iap = (CK_C_INITIALIZE_ARGS *)NULL;
  198.   while( argv++, --argc ) {
  199.     if( '-' == argv[0][0] ) {
  200.       switch( argv[0][1] ) {
  201.       case 'i':
  202.         iap = &ia;
  203.         if( ((char *)NULL != argv[1]) && ('-' != argv[1][0]) ) {
  204. #ifdef WITH_NSS
  205.           ia.pConfig = argv[1];
  206.           ia.ulConfigLen = strlen(argv[1]);
  207.           argv++, --argc;
  208. #else
  209.           return usage(argv0);
  210. #endif /* WITH_NSS */
  211.         }
  212.         break;
  213.       case '-':
  214.         argv++, --argc;
  215.         goto endargs;
  216.       default:
  217.         return usage(argv0);
  218.       }
  219.     } else {
  220.       break;
  221.     }
  222.   }
  223.  endargs:;
  225.   if( 1 != argc ) {
  226.     return usage(argv0);
  227.   }
  229.   lib = PR_LoadLibrary(argv[0]);
  230.   if( (PRLibrary *)NULL == lib ) {
  231.     PR_fprintf(PR_STDERR, "Can't load %s: %ld, %ldn", argv[1], PR_GetError(), PR_GetOSError());
  232.     return 1;
  233.   }
  235.   gfl = (CK_C_GetFunctionList)PR_FindSymbol(lib, "C_GetFunctionList");
  236.   if( (CK_C_GetFunctionList)NULL == gfl ) {
  237.     PR_fprintf(PR_STDERR, "Can't find C_GetFunctionList in %s: %ld, %ldn", argv[1], 
  238.                PR_GetError(), PR_GetOSError());
  239.     return 1;
  240.   }
  242.   ck_rv = (*gfl)(&epv);
  243.   if( CKR_OK != ck_rv ) {
  244.     PR_fprintf(PR_STDERR, "CK_GetFunctionList returned 0x%08xn", ck_rv);
  245.     return 1;
  246.   }
  248.   PR_fprintf(PR_STDOUT, "Module %s loaded, epv = 0x%08x.nn", argv[1], (CK_ULONG)epv);
  250.   /* C_Initialize */
  251.   ck_rv = epv->C_Initialize(iap);
  252.   if( CKR_OK != ck_rv ) {
  253.     PR_fprintf(PR_STDERR, "C_Initialize returned 0x%08xn", ck_rv);
  254.     return 1;
  255.   }
  257.   /* C_GetInfo */
  258.   (void)memset(&info, 0, sizeof(CK_INFO));
  259.   ck_rv = epv->C_GetInfo(&info);
  260.   if( CKR_OK != ck_rv ) {
  261.     PR_fprintf(PR_STDERR, "C_GetInfo returned 0x%08xn", ck_rv);
  262.     return 1;
  263.   }
  265.   PR_fprintf(PR_STDOUT, "Module Info:n");
  266.   PR_fprintf(PR_STDOUT, "    cryptokiVersion = %lu.%02lun", 
  267.              (PRUint32)info.cryptokiVersion.major, (PRUint32)info.cryptokiVersion.minor);
  268.   PR_fprintf(PR_STDOUT, "    manufacturerID = "%.32s"n", info.manufacturerID);
  269.   PR_fprintf(PR_STDOUT, "    flags = 0x%08lxn", info.flags);
  270.   PR_fprintf(PR_STDOUT, "    libraryDescription = "%.32s"n", info.libraryDescription);
  271.   PR_fprintf(PR_STDOUT, "    libraryVersion = %lu.%02lun", 
  272.              (PRUint32)info.libraryVersion.major, (PRUint32)info.libraryVersion.minor);
  273.   PR_fprintf(PR_STDOUT, "n");
  275.   /* C_GetSlotList */
  276.   nSlots = 0;
  277.   ck_rv = epv->C_GetSlotList(CK_FALSE, (CK_SLOT_ID_PTR)CK_NULL_PTR, &nSlots);
  278.   switch( ck_rv ) {
  279.   case CKR_BUFFER_TOO_SMALL:
  280.   case CKR_OK:
  281.     break;
  282.   default:
  283.     PR_fprintf(PR_STDERR, "C_GetSlotList(FALSE, NULL, ) returned 0x%08xn", ck_rv);
  284.     return 1;
  285.   }
  287.   PR_fprintf(PR_STDOUT, "There are %lu slots.n", nSlots);
  289.   pSlots = (CK_SLOT_ID_PTR)PR_Calloc(nSlots, sizeof(CK_SLOT_ID));
  290.   if( (CK_SLOT_ID_PTR)NULL == pSlots ) {
  291.     PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]n", nSlots * sizeof(CK_SLOT_ID));
  292.     return 1;
  293.   }
  295.   ck_rv = epv->C_GetSlotList(CK_FALSE, pSlots, &nSlots);
  296.   if( CKR_OK != ck_rv ) {
  297.     PR_fprintf(PR_STDERR, "C_GetSlotList(FALSE, , ) returned 0x%08xn", ck_rv);
  298.     return 1;
  299.   }
  301.   for( i = 0; i < nSlots; i++ ) {
  302.     PR_fprintf(PR_STDOUT, "    [%lu]: CK_SLOT_ID = %lun", (i+1), pSlots[i]);
  303.   }
  305.   PR_fprintf(PR_STDOUT, "n");
  307.   /* C_GetSlotInfo */
  308.   for( i = 0; i < nSlots; i++ ) {
  309.     CK_SLOT_INFO sinfo;
  311.     PR_fprintf(PR_STDOUT, "[%lu]: CK_SLOT_ID = %lun", (i+1), pSlots[i]);
  313.     (void)memset(&sinfo, 0, sizeof(CK_SLOT_INFO));
  314.     ck_rv = epv->C_GetSlotInfo(pSlots[i], &sinfo);
  315.     if( CKR_OK != ck_rv ) {
  316.       PR_fprintf(PR_STDERR, "C_GetSlotInfo(%lu, ) returned 0x%08xn", pSlots[i], ck_rv);
  317.       return 1;
  318.     }
  320.     PR_fprintf(PR_STDOUT, "    Slot Info:n");
  321.     PR_fprintf(PR_STDOUT, "        slotDescription = "%.64s"n", sinfo.slotDescription);
  322.     PR_fprintf(PR_STDOUT, "        manufacturerID = "%.32s"n", sinfo.manufacturerID);
  323.     PR_fprintf(PR_STDOUT, "        flags = 0x%08lxn", sinfo.flags);
  324.     PR_fprintf(PR_STDOUT, "            -> TOKEN PRESENT = %sn", 
  325.                sinfo.flags & CKF_TOKEN_PRESENT ? "TRUE" : "FALSE");
  326.     PR_fprintf(PR_STDOUT, "            -> REMOVABLE DEVICE = %sn",
  327.                sinfo.flags & CKF_REMOVABLE_DEVICE ? "TRUE" : "FALSE");
  328.     PR_fprintf(PR_STDOUT, "            -> HW SLOT = %sn", 
  329.                sinfo.flags & CKF_HW_SLOT ? "TRUE" : "FALSE");
  330.     PR_fprintf(PR_STDOUT, "        hardwareVersion = %lu.%02lun", 
  331.                (PRUint32)sinfo.hardwareVersion.major, (PRUint32)sinfo.hardwareVersion.minor);
  332.     PR_fprintf(PR_STDOUT, "        firmwareVersion = %lu.%02lun",
  333.                (PRUint32)sinfo.firmwareVersion.major, (PRUint32)sinfo.firmwareVersion.minor);
  335.     if( sinfo.flags & CKF_TOKEN_PRESENT ) {
  336.       CK_TOKEN_INFO tinfo;
  337.       CK_MECHANISM_TYPE *pMechanismList;
  338.       CK_ULONG nMechanisms = 0;
  339.       CK_ULONG j;
  341.       (void)memset(&tinfo, 0, sizeof(CK_TOKEN_INFO));
  342.       ck_rv = epv->C_GetTokenInfo(pSlots[i], &tinfo);
  343.       if( CKR_OK != ck_rv ) {
  344.         PR_fprintf(PR_STDERR, "C_GetTokenInfo(%lu, ) returned 0x%08xn", pSlots[i], ck_rv);
  345.         return 1;
  346.       }
  348.       PR_fprintf(PR_STDOUT, "    Token Info:n");
  349.       PR_fprintf(PR_STDOUT, "        label = "%.32s"n", tinfo.label);
  350.       PR_fprintf(PR_STDOUT, "        manufacturerID = "%.32s"n", tinfo.manufacturerID);
  351.       PR_fprintf(PR_STDOUT, "        model = "%.16s"n", tinfo.model);
  352.       PR_fprintf(PR_STDOUT, "        serialNumber = "%.16s"n", tinfo.serialNumber);
  353.       PR_fprintf(PR_STDOUT, "        flags = 0x%08lxn", tinfo.flags);
  354.       PR_fprintf(PR_STDOUT, "            -> RNG = %sn",
  355.                  tinfo.flags & CKF_RNG ? "TRUE" : "FALSE");
  356.       PR_fprintf(PR_STDOUT, "            -> WRITE PROTECTED = %sn",
  357.                  tinfo.flags & CKF_WRITE_PROTECTED ? "TRUE" : "FALSE");
  358.       PR_fprintf(PR_STDOUT, "            -> LOGIN REQUIRED = %sn",
  359.                  tinfo.flags & CKF_LOGIN_REQUIRED ? "TRUE" : "FALSE");
  360.       PR_fprintf(PR_STDOUT, "            -> USER PIN INITIALIZED = %sn",
  361.                  tinfo.flags & CKF_USER_PIN_INITIALIZED ? "TRUE" : "FALSE");
  362.       PR_fprintf(PR_STDOUT, "            -> RESTORE KEY NOT NEEDED = %sn",
  363.                  tinfo.flags & CKF_RESTORE_KEY_NOT_NEEDED ? "TRUE" : "FALSE");
  364.       PR_fprintf(PR_STDOUT, "            -> CLOCK ON TOKEN = %sn",
  365.                  tinfo.flags & CKF_CLOCK_ON_TOKEN ? "TRUE" : "FALSE");
  366. #ifdef CKF_SUPPORTS_PARALLEL
  367.       PR_fprintf(PR_STDOUT, "            -> SUPPORTS PARALLEL = %sn",
  368.                  tinfo.flags & CKF_SUPPORTS_PARALLEL ? "TRUE" : "FALSE");
  369. #endif /* CKF_SUPPORTS_PARALLEL */
  370.       PR_fprintf(PR_STDOUT, "            -> PROTECTED AUTHENTICATION PATH = %sn",
  371.                  tinfo.flags & CKF_PROTECTED_AUTHENTICATION_PATH ? "TRUE" : "FALSE");
  372.       PR_fprintf(PR_STDOUT, "            -> DUAL_CRYPTO_OPERATIONS = %sn", 
  373.                  tinfo.flags & CKF_DUAL_CRYPTO_OPERATIONS ? "TRUE" : "FALSE");
  374.       PR_fprintf(PR_STDOUT, "        ulMaxSessionCount = %lun", tinfo.ulMaxSessionCount);
  375.       PR_fprintf(PR_STDOUT, "        ulSessionCount = %lun", tinfo.ulSessionCount);
  376.       PR_fprintf(PR_STDOUT, "        ulMaxRwSessionCount = %lun", tinfo.ulMaxRwSessionCount);
  377.       PR_fprintf(PR_STDOUT, "        ulRwSessionCount = %lun", tinfo.ulRwSessionCount);
  378.       PR_fprintf(PR_STDOUT, "        ulMaxPinLen = %lun", tinfo.ulMaxPinLen);
  379.       PR_fprintf(PR_STDOUT, "        ulMinPinLen = %lun", tinfo.ulMinPinLen);
  380.       PR_fprintf(PR_STDOUT, "        ulTotalPublicMemory = %lun", tinfo.ulTotalPublicMemory);
  381.       PR_fprintf(PR_STDOUT, "        ulFreePublicMemory = %lun", tinfo.ulFreePublicMemory);
  382.       PR_fprintf(PR_STDOUT, "        ulTotalPrivateMemory = %lun", tinfo.ulTotalPrivateMemory);
  383.       PR_fprintf(PR_STDOUT, "        ulFreePrivateMemory = %lun", tinfo.ulFreePrivateMemory);
  384.       PR_fprintf(PR_STDOUT, "        hardwareVersion = %lu.%02lun", 
  385.                  (PRUint32)tinfo.hardwareVersion.major, (PRUint32)tinfo.hardwareVersion.minor);
  386.       PR_fprintf(PR_STDOUT, "        firmwareVersion = %lu.%02lun",
  387.                  (PRUint32)tinfo.firmwareVersion.major, (PRUint32)tinfo.firmwareVersion.minor);
  388.       PR_fprintf(PR_STDOUT, "        utcTime = "%.16s"n", tinfo.utcTime);
  391.       ck_rv = epv->C_GetMechanismList(pSlots[i], (CK_MECHANISM_TYPE_PTR)CK_NULL_PTR, &nMechanisms);
  392.       switch( ck_rv ) {
  393.       case CKR_BUFFER_TOO_SMALL:
  394.       case CKR_OK:
  395.         break;
  396.       default:
  397.         PR_fprintf(PR_STDERR, "C_GetMechanismList(%lu, NULL, ) returned 0x%08xn", pSlots[i], ck_rv);
  398.         return 1;
  399.       }
  401.       PR_fprintf(PR_STDOUT, "    %lu mechanisms:n", nMechanisms);
  403.       pMechanismList = (CK_MECHANISM_TYPE_PTR)PR_Calloc(nMechanisms, sizeof(CK_MECHANISM_TYPE));
  404.       if( (CK_MECHANISM_TYPE_PTR)NULL == pMechanismList ) {
  405.         PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]n", 
  406.                    nMechanisms * sizeof(CK_MECHANISM_TYPE));
  407.         return 1;
  408.       }
  410.       ck_rv = epv->C_GetMechanismList(pSlots[i], pMechanismList, &nMechanisms);
  411.       if( CKR_OK != ck_rv ) {
  412.         PR_fprintf(PR_STDERR, "C_GetMechanismList(%lu, , ) returned 0x%08xn", pSlots[i], ck_rv);
  413.         return 1;
  414.       }
  416.       for( j = 0; j < nMechanisms; j++ ) {
  417.         PR_fprintf(PR_STDOUT, "        {%lu}: CK_MECHANISM_TYPE = %lun", (j+1), pMechanismList[j]);
  418.       }
  420.       PR_fprintf(PR_STDOUT, "n");
  422.       for( j = 0; j < nMechanisms; j++ ) {
  423.         CK_MECHANISM_INFO minfo;
  425.         (void)memset(&minfo, 0, sizeof(CK_MECHANISM_INFO));
  426.         ck_rv = epv->C_GetMechanismInfo(pSlots[i], pMechanismList[j], &minfo);
  427.         if( CKR_OK != ck_rv ) {
  428.           PR_fprintf(PR_STDERR, "C_GetMechanismInfo(%lu, %lu, ) returned 0x%08xn", pSlots[i], 
  429.                      pMechanismList[j]);
  430.           return 1;
  431.         }
  433.         PR_fprintf(PR_STDOUT, "    [%lu]: CK_MECHANISM_TYPE = %lun", (j+1), pMechanismList[j]);
  434.         PR_fprintf(PR_STDOUT, "    ulMinKeySize = %lun", minfo.ulMinKeySize);
  435.         PR_fprintf(PR_STDOUT, "    ulMaxKeySize = %lun", minfo.ulMaxKeySize);
  436.         PR_fprintf(PR_STDOUT, "    flags = 0x%08xn", minfo.flags);
  437.         PR_fprintf(PR_STDOUT, "        -> HW = %sn", minfo.flags & CKF_HW ? "TRUE" : "FALSE");
  438.         PR_fprintf(PR_STDOUT, "        -> ENCRYPT = %sn", minfo.flags & CKF_ENCRYPT ? "TRUE" : "FALSE");
  439.         PR_fprintf(PR_STDOUT, "        -> DECRYPT = %sn", minfo.flags & CKF_DECRYPT ? "TRUE" : "FALSE");
  440.         PR_fprintf(PR_STDOUT, "        -> DIGEST = %sn", minfo.flags & CKF_DIGEST ? "TRUE" : "FALSE");
  441.         PR_fprintf(PR_STDOUT, "        -> SIGN = %sn", minfo.flags & CKF_SIGN ? "TRUE" : "FALSE");
  442.         PR_fprintf(PR_STDOUT, "        -> SIGN_RECOVER = %sn", minfo.flags & CKF_SIGN_RECOVER ? "TRUE" : "FALSE");
  443.         PR_fprintf(PR_STDOUT, "        -> VERIFY = %sn", minfo.flags & CKF_VERIFY ? "TRUE" : "FALSE");
  444.         PR_fprintf(PR_STDOUT, "        -> VERIFY_RECOVER = %sn", minfo.flags & CKF_VERIFY_RECOVER ? "TRUE" : "FALSE");
  445.         PR_fprintf(PR_STDOUT, "        -> GENERATE = %sn", minfo.flags & CKF_GENERATE ? "TRUE" : "FALSE");
  446.         PR_fprintf(PR_STDOUT, "        -> GENERATE_KEY_PAIR = %sn", minfo.flags & CKF_GENERATE_KEY_PAIR ? "TRUE" : "FALSE");
  447.         PR_fprintf(PR_STDOUT, "        -> WRAP = %sn", minfo.flags & CKF_WRAP ? "TRUE" : "FALSE");
  448.         PR_fprintf(PR_STDOUT, "        -> UNWRAP = %sn", minfo.flags & CKF_UNWRAP ? "TRUE" : "FALSE");
  449.         PR_fprintf(PR_STDOUT, "        -> DERIVE = %sn", minfo.flags & CKF_DERIVE ? "TRUE" : "FALSE");
  450.         PR_fprintf(PR_STDOUT, "        -> EXTENSION = %sn", minfo.flags & CKF_EXTENSION ? "TRUE" : "FALSE");
  452.         PR_fprintf(PR_STDOUT, "n");
  453.       }
  455.       if( tinfo.flags & CKF_LOGIN_REQUIRED ) {
  456.         PR_fprintf(PR_STDERR, "*** LOGIN REQUIRED but not yet implemented ***n");
  457.         /* all the stuff about logging in as SO and setting the user pin if needed, etc. */
  458.         return 2;
  459.       }
  461.       /* session to find objects */
  462.       {
  463.         CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
  464.         CK_SESSION_INFO sinfo;
  465.         CK_ATTRIBUTE_PTR pTemplate;
  466.         CK_ULONG tnObjects = 0;
  468.         ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
  469.         if( CKR_OK != ck_rv ) {
  470.           PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08xn", pSlots[i], ck_rv);
  471.           return 1;
  472.         }
  474.         PR_fprintf(PR_STDOUT, "    Opened a session: handle = 0x%08xn", h);
  476.         (void)memset(&sinfo, 0, sizeof(CK_SESSION_INFO));
  477.         ck_rv = epv->C_GetSessionInfo(h, &sinfo);
  478.         if( CKR_OK != ck_rv ) {
  479.           PR_fprintf(PR_STDOUT, "C_GetSessionInfo(%lu, ) returned 0x%08xn", h, ck_rv);
  480.           return 1;
  481.         }
  483.         PR_fprintf(PR_STDOUT, "    SESSION INFO:n");
  484.         PR_fprintf(PR_STDOUT, "        slotID = %lun", sinfo.slotID);
  485.         PR_fprintf(PR_STDOUT, "        state = %lun", sinfo.state);
  486.         PR_fprintf(PR_STDOUT, "        flags = 0x%08xn", sinfo.flags);
  487. #ifdef CKF_EXCLUSIVE_SESSION
  488.         PR_fprintf(PR_STDOUT, "            -> EXCLUSIVE SESSION = %sn", sinfo.flags & CKF_EXCLUSIVE_SESSION ? "TRUE" : "FALSE");
  489. #endif /* CKF_EXCLUSIVE_SESSION */
  490.         PR_fprintf(PR_STDOUT, "            -> RW SESSION = %sn", sinfo.flags & CKF_RW_SESSION ? "TRUE" : "FALSE");
  491.         PR_fprintf(PR_STDOUT, "            -> SERIAL SESSION = %sn", sinfo.flags & CKF_SERIAL_SESSION ? "TRUE" : "FALSE");
  492. #ifdef CKF_INSERTION_CALLBACK
  493.         PR_fprintf(PR_STDOUT, "            -> INSERTION CALLBACK = %sn", sinfo.flags & CKF_INSERTION_CALLBACK ? "TRUE" : "FALSE");
  494. #endif /* CKF_INSERTION_CALLBACK */
  495.         PR_fprintf(PR_STDOUT, "        ulDeviceError = %lun", sinfo.ulDeviceError);
  496.         PR_fprintf(PR_STDOUT, "n");
  498.         ck_rv = epv->C_FindObjectsInit(h, (CK_ATTRIBUTE_PTR)CK_NULL_PTR, 0);
  499.         if( CKR_OK != ck_rv ) {
  500.           PR_fprintf(PR_STDOUT, "C_FindObjectsInit(%lu, NULL_PTR, 0) returned 0x%08xn", h, ck_rv);
  501.           return 1;
  502.         }
  504.         pTemplate = (CK_ATTRIBUTE_PTR)PR_Calloc(number_of_all_known_attribute_types, sizeof(CK_ATTRIBUTE));
  505.         if( (CK_ATTRIBUTE_PTR)NULL == pTemplate ) {
  506.           PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]n", 
  507.                      number_of_all_known_attribute_types * sizeof(CK_ATTRIBUTE));
  508.           return 1;
  509.         }
  511.         PR_fprintf(PR_STDOUT, "    All objects:n");
  513.         while(1) {
  514.           CK_OBJECT_HANDLE o = (CK_OBJECT_HANDLE)0;
  515.           CK_ULONG nObjects = 0;
  516.           CK_ULONG k;
  517.           CK_ULONG nAttributes = 0;
  518.           CK_ATTRIBUTE_PTR pT2;
  519.           CK_ULONG l;
  521.           ck_rv = epv->C_FindObjects(h, &o, 1, &nObjects);
  522.           if( CKR_OK != ck_rv ) {
  523.             PR_fprintf(PR_STDERR, "C_FindObjects(%lu, , 1, ) returned 0x%08xn", h, ck_rv);
  524.             return 1;
  525.           }
  527.           if( 0 == nObjects ) {
  528.             PR_fprintf(PR_STDOUT, "n");
  529.             break;
  530.           }
  532.           tnObjects++;
  534.           PR_fprintf(PR_STDOUT, "        OBJECT HANDLE %lu:n", o);
  536.           for( k = 0; k < number_of_all_known_attribute_types; k++ ) {
  537.             pTemplate[k].type = all_known_attribute_types[k];
  538.             pTemplate[k].pValue = (CK_VOID_PTR)CK_NULL_PTR;
  539.             pTemplate[k].ulValueLen = 0;
  540.           }
  542.           ck_rv = epv->C_GetAttributeValue(h, o, pTemplate, number_of_all_known_attribute_types);
  543.           switch( ck_rv ) {
  544.           case CKR_OK:
  545.           case CKR_ATTRIBUTE_SENSITIVE:
  546.           case CKR_ATTRIBUTE_TYPE_INVALID:
  547.           case CKR_BUFFER_TOO_SMALL:
  548.             break;
  549.           default:
  550.             PR_fprintf(PR_STDERR, "C_GetAtributeValue(%lu, %lu, {all attribute types}, %lu) returned 0x%08xn",
  551.                        h, o, number_of_all_known_attribute_types, ck_rv);
  552.             return 1;
  553.           }
  555.           for( k = 0; k < number_of_all_known_attribute_types; k++ ) {
  556.             if( -1 != (CK_LONG)pTemplate[k].ulValueLen ) {
  557.               nAttributes++;
  558.             }
  559.           }
  561.           if( 1 ) {
  562.             PR_fprintf(PR_STDOUT, "            %lu attributes:n", nAttributes);
  563.             for( k = 0; k < number_of_all_known_attribute_types; k++ ) {
  564.               if( -1 != (CK_LONG)pTemplate[k].ulValueLen ) {
  565.                 PR_fprintf(PR_STDOUT, "                0x%08x (len = %lu)n", pTemplate[k].type, 
  566.                            pTemplate[k].ulValueLen);
  567.               }
  568.             }
  569.             PR_fprintf(PR_STDOUT, "n");
  570.           }
  572.           pT2 = (CK_ATTRIBUTE_PTR)PR_Calloc(nAttributes, sizeof(CK_ATTRIBUTE));
  573.           if( (CK_ATTRIBUTE_PTR)NULL == pT2 ) {
  574.             PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]n", 
  575.                        nAttributes * sizeof(CK_ATTRIBUTE));
  576.             return 1;
  577.           }
  579.           for( l = 0, k = 0; k < number_of_all_known_attribute_types; k++ ) {
  580.             if( -1 != (CK_LONG)pTemplate[k].ulValueLen ) {
  581.               pT2[l].type = pTemplate[k].type;
  582.               pT2[l].ulValueLen = pTemplate[k].ulValueLen;
  583.               pT2[l].pValue = (CK_VOID_PTR)PR_Malloc(pT2[l].ulValueLen);
  584.               if( (CK_VOID_PTR)NULL == pT2[l].pValue ) {
  585.                 PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]n", pT2[l].ulValueLen);
  586.                 return 1;
  587.               }
  588.               l++;
  589.             }
  590.           }
  592.           PR_ASSERT( l == nAttributes );
  594.           ck_rv = epv->C_GetAttributeValue(h, o, pT2, nAttributes);
  595.           switch( ck_rv ) {
  596.           case CKR_OK:
  597.           case CKR_ATTRIBUTE_SENSITIVE:
  598.           case CKR_ATTRIBUTE_TYPE_INVALID:
  599.           case CKR_BUFFER_TOO_SMALL:
  600.             break;
  601.           default:
  602.             PR_fprintf(PR_STDERR, "C_GetAtributeValue(%lu, %lu, {existant attribute types}, %lu) returned 0x%08xn",
  603.                        h, o, nAttributes, ck_rv);
  604.             return 1;
  605.           }
  607.           for( l = 0; l < nAttributes; l++ ) {
  608.             PR_fprintf(PR_STDOUT, "            type = 0x%08x, len = %ld", pT2[l].type, (CK_LONG)pT2[l].ulValueLen);
  609.             if( -1 == (CK_LONG)pT2[l].ulValueLen ) {
  610.               ;
  611.             } else {
  612.               CK_ULONG m;
  614.               if( pT2[l].ulValueLen <= 8 ) {
  615.                 PR_fprintf(PR_STDOUT, ", value = ");
  616.               } else {
  617.                 PR_fprintf(PR_STDOUT, ", value = n                ");
  618.               }
  620.               for( m = 0; (m < pT2[l].ulValueLen) && (m < 20); m++ ) {
  621.                 PR_fprintf(PR_STDOUT, "%02x", (CK_ULONG)(0xff & ((CK_CHAR_PTR)pT2[l].pValue)[m]));
  622.               }
  624.               PR_fprintf(PR_STDOUT, " ");
  626.               for( m = 0; (m < pT2[l].ulValueLen) && (m < 20); m++ ) {
  627.                 CK_CHAR c = ((CK_CHAR_PTR)pT2[l].pValue)[m];
  628.                 if( (c < 0x20) || (c >= 0x7f) ) {
  629.                   c = '.';
  630.                 }
  631.                 PR_fprintf(PR_STDOUT, "%c", c);
  632.               }
  633.             }
  635.             PR_fprintf(PR_STDOUT, "n");
  636.           }
  637.           
  638.           PR_fprintf(PR_STDOUT, "n");
  640.           for( l = 0; l < nAttributes; l++ ) {
  641.             PR_Free(pT2[l].pValue);
  642.           }
  643.           PR_Free(pT2);
  644.         } /* while(1) */
  646.         ck_rv = epv->C_FindObjectsFinal(h);
  647.         if( CKR_OK != ck_rv ) {
  648.           PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h, ck_rv);
  649.           return 1;
  650.         }
  652.         PR_fprintf(PR_STDOUT, "    (%lu objects total)n", tnObjects);
  654.         ck_rv = epv->C_CloseSession(h);
  655.         if( CKR_OK != ck_rv ) {
  656.           PR_fprintf(PR_STDERR, "C_CloseSession(%lu) returned 0x%08xn", h, ck_rv);
  657.           return 1;
  658.         }
  659.       } /* session to find objects */
  661.       /* session to create, find, and delete a couple session objects */
  662.       {
  663.         CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
  664.         CK_ATTRIBUTE one[7], two[7], three[7], delta[1], mask[1];
  665.         CK_OBJECT_CLASS cko_data = CKO_DATA;
  666.         CK_BBOOL false = CK_FALSE, true = CK_TRUE;
  667.         char *key = "TEST PROGRAM";
  668.         CK_ULONG key_len = strlen(key);
  669.         CK_OBJECT_HANDLE hOneIn = (CK_OBJECT_HANDLE)0, hTwoIn = (CK_OBJECT_HANDLE)0, 
  670.           hThreeIn = (CK_OBJECT_HANDLE)0, hDeltaIn = (CK_OBJECT_HANDLE)0;
  671.         CK_OBJECT_HANDLE found[10];
  672.         CK_ULONG nFound;
  674.         ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
  675.         if( CKR_OK != ck_rv ) {
  676.           PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08xn", pSlots[i], ck_rv);
  677.           return 1;
  678.         }
  680.         PR_fprintf(PR_STDOUT, "    Opened a session: handle = 0x%08xn", h);
  682.         one[0].type = CKA_CLASS;
  683.         one[0].pValue = &cko_data;
  684.         one[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  685.         one[1].type = CKA_TOKEN;
  686.         one[1].pValue = &false;
  687.         one[1].ulValueLen = sizeof(CK_BBOOL);
  688.         one[2].type = CKA_PRIVATE;
  689.         one[2].pValue = &false;
  690.         one[2].ulValueLen = sizeof(CK_BBOOL);
  691.         one[3].type = CKA_MODIFIABLE;
  692.         one[3].pValue = &true;
  693.         one[3].ulValueLen = sizeof(CK_BBOOL);
  694.         one[4].type = CKA_LABEL;
  695.         one[4].pValue = "Test data object one";
  696.         one[4].ulValueLen = strlen(one[4].pValue);
  697.         one[5].type = CKA_APPLICATION;
  698.         one[5].pValue = key;
  699.         one[5].ulValueLen = key_len;
  700.         one[6].type = CKA_VALUE;
  701.         one[6].pValue = "Object one";
  702.         one[6].ulValueLen = strlen(one[6].pValue);
  704.         two[0].type = CKA_CLASS;
  705.         two[0].pValue = &cko_data;
  706.         two[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  707.         two[1].type = CKA_TOKEN;
  708.         two[1].pValue = &false;
  709.         two[1].ulValueLen = sizeof(CK_BBOOL);
  710.         two[2].type = CKA_PRIVATE;
  711.         two[2].pValue = &false;
  712.         two[2].ulValueLen = sizeof(CK_BBOOL);
  713.         two[3].type = CKA_MODIFIABLE;
  714.         two[3].pValue = &true;
  715.         two[3].ulValueLen = sizeof(CK_BBOOL);
  716.         two[4].type = CKA_LABEL;
  717.         two[4].pValue = "Test data object two";
  718.         two[4].ulValueLen = strlen(two[4].pValue);
  719.         two[5].type = CKA_APPLICATION;
  720.         two[5].pValue = key;
  721.         two[5].ulValueLen = key_len;
  722.         two[6].type = CKA_VALUE;
  723.         two[6].pValue = "Object two";
  724.         two[6].ulValueLen = strlen(two[6].pValue);
  726.         three[0].type = CKA_CLASS;
  727.         three[0].pValue = &cko_data;
  728.         three[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  729.         three[1].type = CKA_TOKEN;
  730.         three[1].pValue = &false;
  731.         three[1].ulValueLen = sizeof(CK_BBOOL);
  732.         three[2].type = CKA_PRIVATE;
  733.         three[2].pValue = &false;
  734.         three[2].ulValueLen = sizeof(CK_BBOOL);
  735.         three[3].type = CKA_MODIFIABLE;
  736.         three[3].pValue = &true;
  737.         three[3].ulValueLen = sizeof(CK_BBOOL);
  738.         three[4].type = CKA_LABEL;
  739.         three[4].pValue = "Test data object three";
  740.         three[4].ulValueLen = strlen(three[4].pValue);
  741.         three[5].type = CKA_APPLICATION;
  742.         three[5].pValue = key;
  743.         three[5].ulValueLen = key_len;
  744.         three[6].type = CKA_VALUE;
  745.         three[6].pValue = "Object three";
  746.         three[6].ulValueLen = strlen(three[6].pValue);
  748.         ck_rv = epv->C_CreateObject(h, one, 7, &hOneIn);
  749.         if( CKR_OK != ck_rv ) {
  750.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, one, 7, ) returned 0x%08xn", h, ck_rv);
  751.           return 1;
  752.         }
  754.         PR_fprintf(PR_STDOUT, "    Created object one: handle = %lun", hOneIn);
  756.         ck_rv = epv->C_CreateObject(h, two, 7, &hTwoIn);
  757.         if( CKR_OK != ck_rv ) {
  758.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, two, 7, ) returned 0x%08xn", h, ck_rv);
  759.           return 1;
  760.         }
  762.         PR_fprintf(PR_STDOUT, "    Created object two: handle = %lun", hTwoIn);
  764.         ck_rv = epv->C_CreateObject(h, three, 7, &hThreeIn);
  765.         if( CKR_OK != ck_rv ) {
  766.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, three, 7, ) returned 0x%08xn", h, ck_rv);
  767.           return 1;
  768.         }
  770.         PR_fprintf(PR_STDOUT, "    Created object three: handle = %lun", hThreeIn);
  772.         delta[0].type = CKA_VALUE;
  773.         delta[0].pValue = "Copied object";
  774.         delta[0].ulValueLen = strlen(delta[0].pValue);
  776.         ck_rv = epv->C_CopyObject(h, hThreeIn, delta, 1, &hDeltaIn);
  777.         if( CKR_OK != ck_rv ) {
  778.           PR_fprintf(PR_STDERR, "C_CopyObject(%lu, %lu, delta, 1, ) returned 0x%08xn", 
  779.                      h, hThreeIn, ck_rv);
  780.           return 1;
  781.         }
  783.         PR_fprintf(PR_STDOUT, "    Copied object three: new handle = %lun", hDeltaIn);
  785.         mask[0].type = CKA_APPLICATION;
  786.         mask[0].pValue = key;
  787.         mask[0].ulValueLen = key_len;
  789.         ck_rv = epv->C_FindObjectsInit(h, mask, 1);
  790.         if( CKR_OK != ck_rv ) {
  791.           PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 1) returned 0x%08xn", 
  792.                      h, ck_rv);
  793.           return 1;
  794.         }
  796.         (void)memset(&found, 0, sizeof(found));
  797.         nFound = 0;
  798.         ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
  799.         if( CKR_OK != ck_rv ) {
  800.           PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08xn", 
  801.                      h, ck_rv);
  802.           return 1;
  803.         }
  805.         if( 4 != nFound ) {
  806.           PR_fprintf(PR_STDERR, "Found %lu objects, not 4.n", nFound);
  807.           return 1;
  808.         }
  810.         PR_fprintf(PR_STDOUT, "    Found 4 objects: %lu, %lu, %lu, %lun", 
  811.                    found[0], found[1], found[2], found[3]);
  813.         ck_rv = epv->C_FindObjectsFinal(h);
  814.         if( CKR_OK != ck_rv ) {
  815.           PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h, ck_rv);
  816.           return 1;
  817.         }
  819.         ck_rv = epv->C_DestroyObject(h, hThreeIn);
  820.         if( CKR_OK != ck_rv ) {
  821.           PR_fprintf(PR_STDERR, "C_DestroyObject(%lu, %lu) returned 0x%08xn", h, hThreeIn, ck_rv);
  822.           return 1;
  823.         }
  825.         PR_fprintf(PR_STDOUT, "    Destroyed object three (handle = %lu)n", hThreeIn);
  827.         delta[0].type = CKA_APPLICATION;
  828.         delta[0].pValue = "Changed application";
  829.         delta[0].ulValueLen = strlen(delta[0].pValue);
  831.         ck_rv = epv->C_SetAttributeValue(h, hTwoIn, delta, 1);
  832.         if( CKR_OK != ck_rv ) {
  833.           PR_fprintf(PR_STDERR, "C_SetAttributeValue(%lu, %lu, delta, 1) returned 0x%08xn", 
  834.                      h, hTwoIn, ck_rv);
  835.           return 1;
  836.         }
  838.         PR_fprintf(PR_STDOUT, "    Changed object two (handle = %lu).n", hTwoIn);
  840.         /* Can another session find these session objects? */
  841.         {
  842.           CK_SESSION_HANDLE h2 = (CK_SESSION_HANDLE)0;
  844.           ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h2);
  845.           if( CKR_OK != ck_rv ) {
  846.             PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08xn", pSlots[i], ck_rv);
  847.             return 1;
  848.           }
  850.           PR_fprintf(PR_STDOUT, "    Opened a second session: handle = 0x%08xn", h2);
  852.           /* mask is still the same */
  854.           ck_rv = epv->C_FindObjectsInit(h2, mask, 1);
  855.           if( CKR_OK != ck_rv ) {
  856.             PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 1) returned 0x%08xn", 
  857.                        h2, ck_rv);
  858.             return 1;
  859.           }
  861.           (void)memset(&found, 0, sizeof(found));
  862.           nFound = 0;
  863.           ck_rv = epv->C_FindObjects(h2, found, 10, &nFound);
  864.           if( CKR_OK != ck_rv ) {
  865.             PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08xn", 
  866.                        h2, ck_rv);
  867.             return 1;
  868.           }
  870.           if( 2 != nFound ) {
  871.             PR_fprintf(PR_STDERR, "Found %lu objects, not 2.n", nFound);
  872.             return 1;
  873.           }
  875.           PR_fprintf(PR_STDOUT, "    Found 2 objects: %lu, %lun", 
  876.                      found[0], found[1]);
  878.           ck_rv = epv->C_FindObjectsFinal(h2);
  879.           if( CKR_OK != ck_rv ) {
  880.             PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h2, ck_rv);
  881.             return 1;
  882.           }
  884.           /* Leave the session hanging open, we'll CloseAllSessions later */
  885.         } /* Can another session find these session objects? */
  887.         ck_rv = epv->C_CloseAllSessions(pSlots[i]);
  888.         if( CKR_OK != ck_rv ) {
  889.           PR_fprintf(PR_STDERR, "C_CloseAllSessions(%lu) returned 0x%08xn", pSlots[i], ck_rv);
  890.           return 1;
  891.         }
  892.       } /* session to create, find, and delete a couple session objects */
  894.       /* Might be interesting to do a find here to verify that all session objects are gone. */
  896.       if( tinfo.flags & CKF_WRITE_PROTECTED ) {
  897.         PR_fprintf(PR_STDOUT, "Token is write protected, skipping token-object tests.n");
  898.       } else {
  899.         CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
  900.         CK_ATTRIBUTE tobj[7], tsobj[7], stobj[7], delta[1], mask[2];
  901.         CK_OBJECT_CLASS cko_data = CKO_DATA;
  902.         CK_BBOOL false = CK_FALSE, true = CK_TRUE;
  903.         char *key = "TEST PROGRAM";
  904.         CK_ULONG key_len = strlen(key);
  905.         CK_OBJECT_HANDLE hTIn = (CK_OBJECT_HANDLE)0, hTSIn = (CK_OBJECT_HANDLE)0, 
  906.           hSTIn = (CK_OBJECT_HANDLE)0, hDeltaIn = (CK_OBJECT_HANDLE)0;
  907.         CK_OBJECT_HANDLE found[10];
  908.         CK_ULONG nFound;
  910.         ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
  911.         if( CKR_OK != ck_rv ) {
  912.           PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08xn", pSlots[i], ck_rv);
  913.           return 1;
  914.         }
  916.         PR_fprintf(PR_STDOUT, "    Opened a session: handle = 0x%08xn", h);
  918.         tobj[0].type = CKA_CLASS;
  919.         tobj[0].pValue = &cko_data;
  920.         tobj[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  921.         tobj[1].type = CKA_TOKEN;
  922.         tobj[1].pValue = &true;
  923.         tobj[1].ulValueLen = sizeof(CK_BBOOL);
  924.         tobj[2].type = CKA_PRIVATE;
  925.         tobj[2].pValue = &false;
  926.         tobj[2].ulValueLen = sizeof(CK_BBOOL);
  927.         tobj[3].type = CKA_MODIFIABLE;
  928.         tobj[3].pValue = &true;
  929.         tobj[3].ulValueLen = sizeof(CK_BBOOL);
  930.         tobj[4].type = CKA_LABEL;
  931.         tobj[4].pValue = "Test data object token";
  932.         tobj[4].ulValueLen = strlen(tobj[4].pValue);
  933.         tobj[5].type = CKA_APPLICATION;
  934.         tobj[5].pValue = key;
  935.         tobj[5].ulValueLen = key_len;
  936.         tobj[6].type = CKA_VALUE;
  937.         tobj[6].pValue = "Object token";
  938.         tobj[6].ulValueLen = strlen(tobj[6].pValue);
  940.         tsobj[0].type = CKA_CLASS;
  941.         tsobj[0].pValue = &cko_data;
  942.         tsobj[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  943.         tsobj[1].type = CKA_TOKEN;
  944.         tsobj[1].pValue = &true;
  945.         tsobj[1].ulValueLen = sizeof(CK_BBOOL);
  946.         tsobj[2].type = CKA_PRIVATE;
  947.         tsobj[2].pValue = &false;
  948.         tsobj[2].ulValueLen = sizeof(CK_BBOOL);
  949.         tsobj[3].type = CKA_MODIFIABLE;
  950.         tsobj[3].pValue = &true;
  951.         tsobj[3].ulValueLen = sizeof(CK_BBOOL);
  952.         tsobj[4].type = CKA_LABEL;
  953.         tsobj[4].pValue = "Test data object token->session";
  954.         tsobj[4].ulValueLen = strlen(tsobj[4].pValue);
  955.         tsobj[5].type = CKA_APPLICATION;
  956.         tsobj[5].pValue = key;
  957.         tsobj[5].ulValueLen = key_len;
  958.         tsobj[6].type = CKA_VALUE;
  959.         tsobj[6].pValue = "Object token->session";
  960.         tsobj[6].ulValueLen = strlen(tsobj[6].pValue);
  962.         stobj[0].type = CKA_CLASS;
  963.         stobj[0].pValue = &cko_data;
  964.         stobj[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  965.         stobj[1].type = CKA_TOKEN;
  966.         stobj[1].pValue = &false;
  967.         stobj[1].ulValueLen = sizeof(CK_BBOOL);
  968.         stobj[2].type = CKA_PRIVATE;
  969.         stobj[2].pValue = &false;
  970.         stobj[2].ulValueLen = sizeof(CK_BBOOL);
  971.         stobj[3].type = CKA_MODIFIABLE;
  972.         stobj[3].pValue = &true;
  973.         stobj[3].ulValueLen = sizeof(CK_BBOOL);
  974.         stobj[4].type = CKA_LABEL;
  975.         stobj[4].pValue = "Test data object session->token";
  976.         stobj[4].ulValueLen = strlen(stobj[4].pValue);
  977.         stobj[5].type = CKA_APPLICATION;
  978.         stobj[5].pValue = key;
  979.         stobj[5].ulValueLen = key_len;
  980.         stobj[6].type = CKA_VALUE;
  981.         stobj[6].pValue = "Object session->token";
  982.         stobj[6].ulValueLen = strlen(stobj[6].pValue);
  984.         ck_rv = epv->C_CreateObject(h, tobj, 7, &hTIn);
  985.         if( CKR_OK != ck_rv ) {
  986.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08xn", h, ck_rv);
  987.           return 1;
  988.         }
  990.         PR_fprintf(PR_STDOUT, "    Created object token: handle = %lun", hTIn);
  992.         ck_rv = epv->C_CreateObject(h, tsobj, 7, &hTSIn);
  993.         if( CKR_OK != ck_rv ) {
  994.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08xn", h, ck_rv);
  995.           return 1;
  996.         }
  998.         PR_fprintf(PR_STDOUT, "    Created object token->session: handle = %lun", hTSIn);
  999.         ck_rv = epv->C_CreateObject(h, stobj, 7, &hSTIn);
  1000.         if( CKR_OK != ck_rv ) {
  1001.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08xn", h, ck_rv);
  1002.           return 1;
  1003.         }
  1005.         PR_fprintf(PR_STDOUT, "    Created object session->token: handle = %lun", hSTIn);
  1007.         /* I've created two token objects and one session object; find the two */
  1009.         mask[0].type = CKA_APPLICATION;
  1010.         mask[0].pValue = key;
  1011.         mask[0].ulValueLen = key_len;
  1012.         mask[1].type = CKA_TOKEN;
  1013.         mask[1].pValue = &true;
  1014.         mask[1].ulValueLen = sizeof(CK_BBOOL);
  1016.         ck_rv = epv->C_FindObjectsInit(h, mask, 2);
  1017.         if( CKR_OK != ck_rv ) {
  1018.           PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 2) returned 0x%08xn", 
  1019.                      h, ck_rv);
  1020.           return 1;
  1021.         }
  1023.         (void)memset(&found, 0, sizeof(found));
  1024.         nFound = 0;
  1025.         ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
  1026.         if( CKR_OK != ck_rv ) {
  1027.           PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08xn", 
  1028.                      h, ck_rv);
  1029.           return 1;
  1030.         }
  1032.         if( 2 != nFound ) {
  1033.           PR_fprintf(PR_STDERR, "Found %lu objects, not 2.n", nFound);
  1034.           return 1;
  1035.         }
  1037.         PR_fprintf(PR_STDOUT, "    Found 2 objects: %lu, %lun", 
  1038.                    found[0], found[1]);
  1040.         ck_rv = epv->C_FindObjectsFinal(h);
  1041.         if( CKR_OK != ck_rv ) {
  1042.           PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h, ck_rv);
  1043.           return 1;
  1044.         }
  1046.         /* Convert a token to session object */
  1048.         delta[0].type = CKA_TOKEN;
  1049.         delta[0].pValue = &false;
  1050.         delta[0].ulValueLen = sizeof(CK_BBOOL);
  1052.         ck_rv = epv->C_SetAttributeValue(h, hTSIn, delta, 1);
  1053.         if( CKR_OK != ck_rv ) {
  1054.           PR_fprintf(PR_STDERR, "C_SetAttributeValue(%lu, %lu, delta, 1) returned 0x%08xn", 
  1055.                      h, hTSIn, ck_rv);
  1056.           return 1;
  1057.         }
  1059.         PR_fprintf(PR_STDOUT, "    Changed object from token to session (handle = %lu).n", hTSIn);
  1061.         /* Now find again; there should be one */
  1063.         mask[0].type = CKA_APPLICATION;
  1064.         mask[0].pValue = key;
  1065.         mask[0].ulValueLen = key_len;
  1066.         mask[1].type = CKA_TOKEN;
  1067.         mask[1].pValue = &true;
  1068.         mask[1].ulValueLen = sizeof(CK_BBOOL);
  1070.         ck_rv = epv->C_FindObjectsInit(h, mask, 2);
  1071.         if( CKR_OK != ck_rv ) {
  1072.           PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 2) returned 0x%08xn", 
  1073.                      h, ck_rv);
  1074.           return 1;
  1075.         }
  1077.         (void)memset(&found, 0, sizeof(found));
  1078.         nFound = 0;
  1079.         ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
  1080.         if( CKR_OK != ck_rv ) {
  1081.           PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08xn", 
  1082.                      h, ck_rv);
  1083.           return 1;
  1084.         }
  1086.         if( 1 != nFound ) {
  1087.           PR_fprintf(PR_STDERR, "Found %lu objects, not 1.n", nFound);
  1088.           return 1;
  1089.         }
  1091.         PR_fprintf(PR_STDOUT, "    Found 1 objects: %lun", 
  1092.                    found[0]);
  1094.         ck_rv = epv->C_FindObjectsFinal(h);
  1095.         if( CKR_OK != ck_rv ) {
  1096.           PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h, ck_rv);
  1097.           return 1;
  1098.         }
  1100.         /* Convert a session to a token object */
  1102.         delta[0].type = CKA_TOKEN;
  1103.         delta[0].pValue = &true;
  1104.         delta[0].ulValueLen = sizeof(CK_BBOOL);
  1106.         ck_rv = epv->C_SetAttributeValue(h, hSTIn, delta, 1);
  1107.         if( CKR_OK != ck_rv ) {
  1108.           PR_fprintf(PR_STDERR, "C_SetAttributeValue(%lu, %lu, delta, 1) returned 0x%08xn", 
  1109.                      h, hSTIn, ck_rv);
  1110.           return 1;
  1111.         }
  1113.         PR_fprintf(PR_STDOUT, "    Changed object from session to token (handle = %lu).n", hSTIn);
  1115.         /* Now find again; there should be two again */
  1117.         mask[0].type = CKA_APPLICATION;
  1118.         mask[0].pValue = key;
  1119.         mask[0].ulValueLen = key_len;
  1120.         mask[1].type = CKA_TOKEN;
  1121.         mask[1].pValue = &true;
  1122.         mask[1].ulValueLen = sizeof(CK_BBOOL);
  1124.         ck_rv = epv->C_FindObjectsInit(h, mask, 2);
  1125.         if( CKR_OK != ck_rv ) {
  1126.           PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 2) returned 0x%08xn", 
  1127.                      h, ck_rv);
  1128.           return 1;
  1129.         }
  1131.         (void)memset(&found, 0, sizeof(found));
  1132.         nFound = 0;
  1133.         ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
  1134.         if( CKR_OK != ck_rv ) {
  1135.           PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08xn", 
  1136.                      h, ck_rv);
  1137.           return 1;
  1138.         }
  1140.         if( 2 != nFound ) {
  1141.           PR_fprintf(PR_STDERR, "Found %lu objects, not 2.n", nFound);
  1142.           return 1;
  1143.         }
  1145.         PR_fprintf(PR_STDOUT, "    Found 2 objects: %lu, %lun", 
  1146.                    found[0], found[1]);
  1148.         ck_rv = epv->C_FindObjectsFinal(h);
  1149.         if( CKR_OK != ck_rv ) {
  1150.           PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h, ck_rv);
  1151.           return 1;
  1152.         }
  1154.         /* Delete the two (found) token objects to clean up */
  1156.         ck_rv = epv->C_DestroyObject(h, found[0]);
  1157.         if( CKR_OK != ck_rv ) {
  1158.           PR_fprintf(PR_STDERR, "C_DestroyObject(%lu, %lu) returned 0x%08xn", h, found[0], ck_rv);
  1159.           return 1;
  1160.         }
  1162.         PR_fprintf(PR_STDOUT, "    Destroyed token object (handle = %lu)n", found[0]);
  1164.         ck_rv = epv->C_DestroyObject(h, found[1]);
  1165.         if( CKR_OK != ck_rv ) {
  1166.           PR_fprintf(PR_STDERR, "C_DestroyObject(%lu, %lu) returned 0x%08xn", h, found[1], ck_rv);
  1167.           return 1;
  1168.         }
  1170.         PR_fprintf(PR_STDOUT, "    Destroyed token object (handle = %lu)n", found[1]);
  1171.         
  1172.         /* Close the session and all objects should be gone */
  1174.         ck_rv = epv->C_CloseSession(h);
  1175.         if( CKR_OK != ck_rv ) {
  1176.           PR_fprintf(PR_STDERR, "C_CloseSession(%lu) returned 0x%08xn", h, ck_rv);
  1177.           return 1;
  1178.         }
  1179.       } /* if( tinfo.flags & CKF_WRITE_PROTECTED ) */
  1181.       if( tinfo.flags & CKF_WRITE_PROTECTED ) {
  1182.         PR_fprintf(PR_STDOUT, "Token is write protected, skipping leaving a record.n");
  1183.       } else {
  1184.         CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
  1185.         CK_ATTRIBUTE record[7], mask[2];
  1186.         CK_OBJECT_CLASS cko_data = CKO_DATA;
  1187.         CK_BBOOL false = CK_FALSE, true = CK_TRUE;
  1188.         char *key = "TEST RECORD";
  1189.         CK_ULONG key_len = strlen(key);
  1190.         CK_OBJECT_HANDLE hin = (CK_OBJECT_HANDLE)0;
  1191.         char timebuffer[256];
  1193.         ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
  1194.         if( CKR_OK != ck_rv ) {
  1195.           PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08xn", pSlots[i], ck_rv);
  1196.           return 1;
  1197.         }
  1199.         PR_fprintf(PR_STDOUT, "    Opened a session: handle = 0x%08xn", h);
  1201.         /* I can't believe how hard NSPR makes this operation */
  1202.         {
  1203.           time_t now = 0;
  1204.           struct tm *tm;
  1205.           time(&now);
  1206.           tm = localtime(&now);
  1207.           strftime(timebuffer, sizeof(timebuffer), "%Y-%m-%d %T %Z", tm);
  1208.         }
  1210.         record[0].type = CKA_CLASS;
  1211.         record[0].pValue = &cko_data;
  1212.         record[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  1213.         record[1].type = CKA_TOKEN;
  1214.         record[1].pValue = &true;
  1215.         record[1].ulValueLen = sizeof(CK_BBOOL);
  1216.         record[2].type = CKA_PRIVATE;
  1217.         record[2].pValue = &false;
  1218.         record[2].ulValueLen = sizeof(CK_BBOOL);
  1219.         record[3].type = CKA_MODIFIABLE;
  1220.         record[3].pValue = &true;
  1221.         record[3].ulValueLen = sizeof(CK_BBOOL);
  1222.         record[4].type = CKA_LABEL;
  1223.         record[4].pValue = "Test record";
  1224.         record[4].ulValueLen = strlen(record[4].pValue);
  1225.         record[5].type = CKA_APPLICATION;
  1226.         record[5].pValue = key;
  1227.         record[5].ulValueLen = key_len;
  1228.         record[6].type = CKA_VALUE;
  1229.         record[6].pValue = timebuffer;
  1230.         record[6].ulValueLen = strlen(timebuffer)+1;
  1232.         PR_fprintf(PR_STDOUT, "    Timestamping with "%s"n", timebuffer);
  1234.         ck_rv = epv->C_CreateObject(h, record, 7, &hin);
  1235.         if( CKR_OK != ck_rv ) {
  1236.           PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08xn", h, ck_rv);
  1237.           return 1;
  1238.         }
  1240.         PR_fprintf(PR_STDOUT, "    Created record object: handle = %lun", hin);
  1241.         
  1242.         PR_fprintf(PR_STDOUT, "   == All test timestamps ==n");
  1244.         mask[0].type = CKA_CLASS;
  1245.         mask[0].pValue = &cko_data;
  1246.         mask[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
  1247.         mask[1].type = CKA_APPLICATION;
  1248.         mask[1].pValue = key;
  1249.         mask[1].ulValueLen = key_len;
  1251.         ck_rv = epv->C_FindObjectsInit(h, mask, 2);
  1252.         if( CKR_OK != ck_rv ) {
  1253.           PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 1) returned 0x%08xn", 
  1254.                      h, ck_rv);
  1255.           return 1;
  1256.         }
  1258.         while( 1 ) {
  1259.           CK_OBJECT_HANDLE o = (CK_OBJECT_HANDLE)0;
  1260.           CK_ULONG nObjects = 0;
  1261.           CK_ATTRIBUTE value[1];
  1262.           char buffer[1024];
  1264.           ck_rv = epv->C_FindObjects(h, &o, 1, &nObjects);
  1265.           if( CKR_OK != ck_rv ) {
  1266.             PR_fprintf(PR_STDERR, "C_FindObjects(%lu, , 1, ) returned 0x%08xn", h, ck_rv);
  1267.             return 1;
  1268.           }
  1270.           if( 0 == nObjects ) {
  1271.             PR_fprintf(PR_STDOUT, "n");
  1272.             break;
  1273.           }
  1275.           value[0].type = CKA_VALUE;
  1276.           value[0].pValue = buffer;
  1277.           value[0].ulValueLen = sizeof(buffer);
  1279.           ck_rv = epv->C_GetAttributeValue(h, o, value, 1);
  1280.           switch( ck_rv ) {
  1281.           case CKR_OK:
  1282.             PR_fprintf(PR_STDOUT, "    %sn", value[0].pValue);
  1283.             break;
  1284.           case CKR_ATTRIBUTE_SENSITIVE:
  1285.             PR_fprintf(PR_STDOUT, "    [Sensitive???]n");
  1286.             break;
  1287.           case CKR_ATTRIBUTE_TYPE_INVALID:
  1288.             PR_fprintf(PR_STDOUT, "    [Invalid attribute???]n");
  1289.             break;
  1290.           case CKR_BUFFER_TOO_SMALL:
  1291.             PR_fprintf(PR_STDOUT, "    (result > 1k (%lu))n", value[0].ulValueLen);
  1292.             break;
  1293.           default:
  1294.             PR_fprintf(PR_STDERR, "C_GetAtributeValue(%lu, %lu, CKA_VALUE, 1) returned 0x%08xn",
  1295.                        h, o);
  1296.             return 1;
  1297.           }
  1298.         } /* while */
  1300.         ck_rv = epv->C_FindObjectsFinal(h);
  1301.         if( CKR_OK != ck_rv ) {
  1302.           PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08xn", h, ck_rv);
  1303.           return 1;
  1304.         }
  1305.       } /* "leaving a record" else clause */
  1307.     }
  1309.     PR_fprintf(PR_STDOUT, "n");
  1310.   }
  1312.   return 0;
  1313. }