Ticket #126: pkcs11-spy-fix.patch

File pkcs11-spy-fix.patch, 17.5 KB (added by harningt, 2 years ago)
  • src/pkcs11/pkcs11-spy.c

    === src/pkcs11/pkcs11-spy.c
    ==================================================================
     
    158158        return rv; 
    159159} 
    160160 
     161static CK_RV check_po()  
     162{ 
     163  if(!po) { 
     164    fprintf(spy_output, "Error: Instance finalized early"); 
     165        return retne(CKR_CRYPTOKI_NOT_INITIALIZED); 
     166  } 
     167  return CKR_OK; 
     168} 
     169#define CHECK_PO() do { CK_RV ret = check_po(); if(ret != CKR_OK) return ret; } while(0) 
     170 
    161171static void spy_dump_string_in(const char *name, CK_VOID_PTR data, CK_ULONG size) 
    162172{ 
    163173  fprintf(spy_output, "[in] %s ", name); 
     
    244254{ 
    245255  CK_RV rv; 
    246256  enter("C_Finalize"); 
     257  CHECK_PO(); 
     258   
    247259  rv = po->C_Finalize(pReserved); 
    248260  /* After Finalize do not use the module again */ 
    249261  C_UnloadModule(modhandle); 
    250262  po = NULL; 
     263   
    251264  return retne(rv); 
    252265} 
    253266 
     
    255268{ 
    256269  CK_RV rv; 
    257270  enter("C_GetInfo"); 
     271  CHECK_PO(); 
    258272  rv = po->C_GetInfo(pInfo); 
    259273  if(rv == CKR_OK) { 
    260274    print_ck_info(spy_output, pInfo); 
     
    269283  CK_RV rv; 
    270284  enter("C_GetSlotList"); 
    271285  spy_dump_ulong_in("tokenPresent", tokenPresent); 
     286  CHECK_PO(); 
    272287  rv = po->C_GetSlotList(tokenPresent, pSlotList, pulCount); 
    273288  if(rv == CKR_OK) { 
    274289    spy_dump_desc_out("pSlotList"); 
     
    284299  CK_RV rv; 
    285300  enter("C_GetSlotInfo"); 
    286301  spy_dump_ulong_in("slotID", slotID); 
     302  CHECK_PO(); 
    287303  rv = po->C_GetSlotInfo(slotID, pInfo); 
    288304  if(rv == CKR_OK) { 
    289305    spy_dump_desc_out("pInfo"); 
     
    298314  CK_RV rv; 
    299315  enter("C_GetTokenInfo"); 
    300316  spy_dump_ulong_in("slotID", slotID); 
     317  CHECK_PO(); 
    301318  rv = po->C_GetTokenInfo(slotID, pInfo); 
    302319  if(rv == CKR_OK) { 
    303320    spy_dump_desc_out("pInfo"); 
     
    313330  CK_RV rv; 
    314331  enter("C_GetMechanismList"); 
    315332  spy_dump_ulong_in("slotID", slotID); 
     333  CHECK_PO(); 
    316334  rv = po->C_GetMechanismList(slotID, pMechanismList, pulCount); 
    317335  if(rv == CKR_OK) { 
    318336    spy_dump_array_out("pMechanismList", *pulCount); 
     
    334352  } else { 
    335353    fprintf(spy_output, " Unknown Mechanism (%08lx)  \n", type); 
    336354  } 
     355  CHECK_PO(); 
    337356  rv = po->C_GetMechanismInfo(slotID, type, pInfo); 
    338357  if(rv == CKR_OK) { 
    339358    spy_dump_desc_out("pInfo"); 
     
    352371  spy_dump_ulong_in("slotID", slotID); 
    353372  spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen); 
    354373  spy_dump_string_in("pLabel[32]", pLabel, 32); 
     374  CHECK_PO(); 
    355375  rv = po->C_InitToken (slotID, pPin, ulPinLen, pLabel); 
    356376  return retne(rv); 
    357377} 
     
    364384  enter("C_InitPIN"); 
    365385  spy_dump_ulong_in("hSession", hSession); 
    366386  spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen); 
     387  CHECK_PO(); 
    367388  rv = po->C_InitPIN(hSession, pPin, ulPinLen); 
    368389  return retne(rv); 
    369390} 
     
    379400  spy_dump_ulong_in("hSession", hSession); 
    380401  spy_dump_string_in("pOldPin[ulOldLen]", pOldPin, ulOldLen); 
    381402  spy_dump_string_in("pNewPin[ulNewLen]", pNewPin, ulNewLen); 
     403  CHECK_PO(); 
    382404  rv = po->C_SetPIN(hSession, pOldPin, ulOldLen, 
    383405                    pNewPin, ulNewLen); 
    384406  return retne(rv); 
     
    396418  spy_dump_ulong_in("flags", flags); 
    397419  fprintf(spy_output, "pApplication=%p\n", pApplication); 
    398420  fprintf(spy_output, "Notify=%p\n", (void *)Notify); 
     421  CHECK_PO(); 
    399422  rv = po->C_OpenSession(slotID, flags, pApplication, 
    400423                         Notify, phSession); 
    401424  spy_dump_ulong_out("*phSession", *phSession); 
     
    408431  CK_RV rv; 
    409432  enter("C_CloseSession"); 
    410433  spy_dump_ulong_in("hSession", hSession); 
     434  CHECK_PO(); 
    411435  rv = po->C_CloseSession(hSession); 
    412436  return retne(rv); 
    413437} 
     
    418442  CK_RV rv; 
    419443  enter("C_CloseAllSessions"); 
    420444  spy_dump_ulong_in("slotID", slotID); 
     445  CHECK_PO(); 
    421446  rv = po->C_CloseAllSessions(slotID); 
    422447  return retne(rv); 
    423448} 
     
    429454  CK_RV rv; 
    430455  enter("C_GetSessionInfo"); 
    431456  spy_dump_ulong_in("hSession", hSession); 
     457  CHECK_PO(); 
    432458  rv = po->C_GetSessionInfo(hSession, pInfo); 
    433459  if(rv == CKR_OK) { 
    434460    spy_dump_desc_out("pInfo"); 
     
    445471  CK_RV rv; 
    446472  enter("C_GetOperationState"); 
    447473  spy_dump_ulong_in("hSession", hSession); 
     474  CHECK_PO(); 
    448475  rv = po->C_GetOperationState(hSession, pOperationState, 
    449476                               pulOperationStateLen); 
    450477  if (rv == CKR_OK) { 
     
    468495                     pOperationState, ulOperationStateLen); 
    469496  spy_dump_ulong_in("hEncryptionKey", hEncryptionKey); 
    470497  spy_dump_ulong_in("hAuthenticationKey", hAuthenticationKey); 
     498  CHECK_PO(); 
    471499  rv = po->C_SetOperationState(hSession, pOperationState, 
    472500                               ulOperationStateLen, 
    473501                               hEncryptionKey, 
     
    487515  fprintf(spy_output, "[in] userType = %s\n", 
    488516          lookup_enum(USR_T, userType)); 
    489517  spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen); 
     518  CHECK_PO(); 
    490519  rv = po->C_Login(hSession, userType, pPin, ulPinLen); 
    491520  return retne(rv); 
    492521} 
     
    496525  CK_RV rv; 
    497526  enter("C_Logout"); 
    498527  spy_dump_ulong_in("hSession", hSession); 
     528  CHECK_PO(); 
    499529  rv = po->C_Logout(hSession); 
    500530  return retne(rv); 
    501531} 
     
    509539  enter("C_CreateObject"); 
    510540  spy_dump_ulong_in("hSession", hSession); 
    511541  spy_attribute_list_in("pTemplate", pTemplate, ulCount); 
     542  CHECK_PO(); 
    512543  rv = po->C_CreateObject(hSession, pTemplate, ulCount, phObject); 
    513544  if (rv == CKR_OK) { 
    514545    spy_dump_ulong_out("*phObject", *phObject); 
     
    527558  spy_dump_ulong_in("hSession", hSession); 
    528559  spy_dump_ulong_in("hObject", hObject); 
    529560  spy_attribute_list_in("pTemplate", pTemplate, ulCount); 
     561  CHECK_PO(); 
    530562  rv = po->C_CopyObject(hSession, hObject, pTemplate, ulCount, phNewObject); 
    531563  if (rv == CKR_OK) { 
    532564    spy_dump_ulong_out("*phNewObject", *phNewObject); 
     
    542574  enter("C_DestroyObject"); 
    543575  spy_dump_ulong_in("hSession", hSession); 
    544576  spy_dump_ulong_in("hObject", hObject); 
     577  CHECK_PO(); 
    545578  rv = po->C_DestroyObject(hSession, hObject); 
    546579  return retne(rv); 
    547580} 
     
    555588  enter("C_GetObjectSize"); 
    556589  spy_dump_ulong_in("hSession", hSession); 
    557590  spy_dump_ulong_in("hObject", hObject); 
     591  CHECK_PO(); 
    558592  rv = po->C_GetObjectSize(hSession, hObject, pulSize); 
    559593  if (rv == CKR_OK) { 
    560594    spy_dump_ulong_out("*pulSize", *pulSize); 
     
    579613   *   true errors for C_GetAttributeValue.'' 
    580614   * That's why we ignore these error codes, because we want to display 
    581615   * all other attributes anyway (they may have been returned correctly) */ 
     616  CHECK_PO(); 
    582617  rv = po->C_GetAttributeValue(hSession, hObject, pTemplate, ulCount); 
    583618  if (rv == CKR_OK || rv == CKR_ATTRIBUTE_SENSITIVE || 
    584619          rv == CKR_ATTRIBUTE_TYPE_INVALID || rv == CKR_BUFFER_TOO_SMALL) { 
     
    598633  spy_dump_ulong_in("hSession", hSession); 
    599634  spy_dump_ulong_in("hObject", hObject); 
    600635  spy_attribute_list_in("pTemplate", pTemplate, ulCount); 
     636  CHECK_PO(); 
    601637  rv = po->C_SetAttributeValue(hSession, hObject, pTemplate, ulCount); 
    602638  return retne(rv); 
    603639} 
     
    611647  enter("C_FindObjectsInit"); 
    612648  spy_dump_ulong_in("hSession", hSession); 
    613649  spy_attribute_list_in("pTemplate", pTemplate, ulCount); 
     650  CHECK_PO(); 
    614651  rv = po->C_FindObjectsInit(hSession, pTemplate, ulCount); 
    615652  return retne(rv); 
    616653} 
     
    625662  enter("C_FindObjects"); 
    626663  spy_dump_ulong_in("hSession", hSession); 
    627664  spy_dump_ulong_in("ulMaxObjectCount", ulMaxObjectCount); 
     665  CHECK_PO(); 
    628666  rv = po->C_FindObjects(hSession, phObject, ulMaxObjectCount, 
    629667                         pulObjectCount); 
    630668  if (rv == CKR_OK) { 
     
    643681  CK_RV rv; 
    644682  enter("C_FindObjectsFinal"); 
    645683  spy_dump_ulong_in("hSession", hSession); 
     684  CHECK_PO(); 
    646685  rv = po->C_FindObjectsFinal(hSession); 
    647686  return retne(rv); 
    648687} 
     
    657696  fprintf(spy_output, "pMechanism->type=%s\n", 
    658697          lookup_enum(MEC_T, pMechanism->mechanism)); 
    659698  spy_dump_ulong_in("hKey", hKey); 
     699  CHECK_PO(); 
    660700  rv = po->C_EncryptInit(hSession, pMechanism, hKey); 
    661701  return retne(rv); 
    662702} 
     
    672712  enter("C_Encrypt"); 
    673713  spy_dump_ulong_in("hSession", hSession); 
    674714  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen); 
     715  CHECK_PO(); 
    675716  rv = po->C_Encrypt(hSession, pData, ulDataLen, 
    676717                     pEncryptedData, pulEncryptedDataLen); 
    677718  if (rv == CKR_OK) { 
     
    692733  enter("C_EncryptUpdate"); 
    693734  spy_dump_ulong_in("hSession", hSession); 
    694735  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen); 
     736  CHECK_PO(); 
    695737  rv = po->C_EncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart, 
    696738                           pulEncryptedPartLen); 
    697739  if (rv == CKR_OK) { 
     
    708750  CK_RV rv; 
    709751  enter("C_EncryptFinal"); 
    710752  spy_dump_ulong_in("hSession", hSession); 
     753  CHECK_PO(); 
    711754  rv = po->C_EncryptFinal(hSession, pLastEncryptedPart, 
    712755                          pulLastEncryptedPartLen); 
    713756  if (rv == CKR_OK) { 
     
    728771  fprintf(spy_output, "pMechanism->type=%s\n", 
    729772          lookup_enum(MEC_T, pMechanism->mechanism)); 
    730773  spy_dump_ulong_in("hKey", hKey); 
     774  CHECK_PO(); 
    731775  rv = po->C_DecryptInit(hSession, pMechanism, hKey); 
    732776  return retne(rv); 
    733777} 
     
    744788  spy_dump_ulong_in("hSession", hSession); 
    745789  spy_dump_string_in("pEncryptedData[ulEncryptedDataLen]", 
    746790                      pEncryptedData, ulEncryptedDataLen); 
     791  CHECK_PO(); 
    747792  rv = po->C_Decrypt(hSession, pEncryptedData, ulEncryptedDataLen, 
    748793                     pData, pulDataLen); 
    749794  if (rv == CKR_OK) { 
     
    764809  spy_dump_ulong_in("hSession", hSession); 
    765810  spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]", 
    766811                      pEncryptedPart, ulEncryptedPartLen); 
     812  CHECK_PO(); 
    767813  rv = po->C_DecryptUpdate(hSession, pEncryptedPart, ulEncryptedPartLen, 
    768814                           pPart, pulPartLen); 
    769815  if (rv == CKR_OK) { 
     
    780826  CK_RV rv; 
    781827  enter("C_DecryptFinal"); 
    782828  spy_dump_ulong_in("hSession", hSession); 
     829  CHECK_PO(); 
    783830  rv = po->C_DecryptFinal(hSession, pLastPart, pulLastPartLen); 
    784831  if (rv == CKR_OK) { 
    785832    spy_dump_string_out("pLastPart[*pulLastPartLen]", 
     
    796843  spy_dump_ulong_in("hSession", hSession); 
    797844  fprintf(spy_output, "pMechanism->type=%s\n", 
    798845          lookup_enum(MEC_T, pMechanism->mechanism)); 
     846  CHECK_PO(); 
    799847  rv = po->C_DigestInit(hSession, pMechanism); 
    800848  return retne(rv); 
    801849} 
     
    811859  enter("C_Digest"); 
    812860  spy_dump_ulong_in("hSession", hSession); 
    813861  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen); 
     862  CHECK_PO(); 
    814863  rv = po->C_Digest(hSession, pData, ulDataLen, pDigest, pulDigestLen); 
    815864  if (rv == CKR_OK) { 
    816865    spy_dump_string_out("pDigest[*pulDigestLen]", 
     
    828877  enter("C_DigestUpdate"); 
    829878  spy_dump_ulong_in("hSession", hSession); 
    830879  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen); 
     880  CHECK_PO(); 
    831881  rv = po->C_DigestUpdate(hSession, pPart, ulPartLen); 
    832882  return retne(rv); 
    833883} 
     
    840890  enter("C_DigestKey"); 
    841891  spy_dump_ulong_in("hSession", hSession); 
    842892  spy_dump_ulong_in("hKey", hKey); 
     893  CHECK_PO(); 
    843894  rv = po->C_DigestKey(hSession, hKey); 
    844895  return retne(rv); 
    845896} 
     
    852903  CK_RV rv; 
    853904  enter("C_DigestFinal"); 
    854905  spy_dump_ulong_in("hSession", hSession); 
     906  CHECK_PO(); 
    855907  rv = po->C_DigestFinal(hSession, pDigest, pulDigestLen); 
    856908  if (rv == CKR_OK) { 
    857909    spy_dump_string_out("pDigest[*pulDigestLen]", 
     
    870922  fprintf(spy_output, "pMechanism->type=%s\n", 
    871923          lookup_enum(MEC_T, pMechanism->mechanism)); 
    872924  spy_dump_ulong_in("hKey", hKey); 
     925  CHECK_PO(); 
    873926  rv = po->C_SignInit(hSession, pMechanism, hKey); 
    874927  return retne(rv); 
    875928} 
     
    885938  enter("C_Sign"); 
    886939  spy_dump_ulong_in("hSession", hSession); 
    887940  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen); 
     941  CHECK_PO(); 
    888942  rv = po->C_Sign(hSession, pData, ulDataLen, pSignature, pulSignatureLen); 
    889943  if (rv == CKR_OK) { 
    890944    spy_dump_string_out("pSignature[*pulSignatureLen]", 
     
    902956  enter("C_SignUpdate"); 
    903957  spy_dump_ulong_in("hSession", hSession); 
    904958  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen); 
     959  CHECK_PO(); 
    905960  rv = po->C_SignUpdate(hSession, pPart, ulPartLen); 
    906961  return retne(rv); 
    907962} 
     
    914969  CK_RV rv; 
    915970  enter("C_SignFinal"); 
    916971  spy_dump_ulong_in("hSession", hSession); 
     972  CHECK_PO(); 
    917973  rv = po->C_SignFinal(hSession, pSignature, pulSignatureLen); 
    918974  if (rv == CKR_OK) { 
    919975    spy_dump_string_out("pSignature[*pulSignatureLen]", 
     
    933989  fprintf(spy_output, "pMechanism->type=%s\n", 
    934990          lookup_enum(MEC_T, pMechanism->mechanism)); 
    935991  spy_dump_ulong_in("hKey", hKey); 
     992  CHECK_PO(); 
    936993  rv = po->C_SignRecoverInit(hSession, pMechanism, hKey); 
    937994  return retne(rv); 
    938995} 
     
    9481005  enter("C_SignRecover"); 
    9491006  spy_dump_ulong_in("hSession", hSession); 
    9501007  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen); 
     1008  CHECK_PO(); 
    9511009  rv = po->C_SignRecover(hSession, pData, ulDataLen, 
    9521010                         pSignature, pulSignatureLen); 
    9531011  if (rv == CKR_OK) { 
     
    9671025  fprintf(spy_output, "pMechanism->type=%s\n", 
    9681026          lookup_enum(MEC_T, pMechanism->mechanism)); 
    9691027  spy_dump_ulong_in("hKey", hKey); 
     1028  CHECK_PO(); 
    9701029  rv = po->C_VerifyInit(hSession, pMechanism, hKey); 
    9711030  return retne(rv); 
    9721031} 
     
    9841043  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen); 
    9851044  spy_dump_string_in("pSignature[ulSignatureLen]", 
    9861045                     pSignature, ulSignatureLen); 
     1046  CHECK_PO(); 
    9871047  rv = po->C_Verify(hSession, pData, ulDataLen, pSignature, ulSignatureLen); 
    9881048  return retne(rv); 
    9891049} 
     
    9971057  enter("C_VerifyUpdate"); 
    9981058  spy_dump_ulong_in("hSession", hSession); 
    9991059  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen); 
     1060  CHECK_PO(); 
    10001061  rv = po->C_VerifyUpdate(hSession, pPart, ulPartLen); 
    10011062  return retne(rv); 
    10021063} 
     
    10111072  spy_dump_ulong_in("hSession", hSession); 
    10121073  spy_dump_string_in("pSignature[ulSignatureLen]", 
    10131074                     pSignature, ulSignatureLen); 
     1075  CHECK_PO(); 
    10141076  rv = po->C_VerifyFinal(hSession, pSignature, ulSignatureLen); 
    10151077  return retne(rv); 
    10161078} 
     
    10261088  fprintf(spy_output, "pMechanism->type=%s\n", 
    10271089          lookup_enum(MEC_T, pMechanism->mechanism)); 
    10281090  spy_dump_ulong_in("hKey", hKey); 
     1091  CHECK_PO(); 
    10291092  rv = po->C_VerifyRecoverInit(hSession, pMechanism, hKey); 
    10301093  return retne(rv); 
    10311094} 
     
    10421105  spy_dump_ulong_in("hSession", hSession); 
    10431106  spy_dump_string_in("pSignature[ulSignatureLen]", 
    10441107                     pSignature, ulSignatureLen); 
     1108  CHECK_PO(); 
    10451109  rv = po->C_VerifyRecover(hSession, pSignature, ulSignatureLen, 
    10461110                           pData, pulDataLen); 
    10471111  if (rv == CKR_OK) { 
     
    10601124  enter("C_DigestEncryptUpdate"); 
    10611125  spy_dump_ulong_in("hSession", hSession); 
    10621126  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen); 
     1127  CHECK_PO(); 
    10631128  rv = po->C_DigestEncryptUpdate(hSession, pPart, ulPartLen, 
    10641129                                 pEncryptedPart, pulEncryptedPartLen); 
    10651130  if (rv == CKR_OK) { 
     
    10811146  spy_dump_ulong_in("hSession", hSession); 
    10821147  spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]", 
    10831148                      pEncryptedPart, ulEncryptedPartLen); 
     1149  CHECK_PO(); 
    10841150  rv = po->C_DecryptDigestUpdate(hSession, pEncryptedPart, 
    10851151                                 ulEncryptedPartLen, 
    10861152                                 pPart,  pulPartLen); 
     
    11011167  enter("C_SignEncryptUpdate"); 
    11021168  spy_dump_ulong_in("hSession", hSession); 
    11031169  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen); 
     1170  CHECK_PO(); 
    11041171  rv = po->C_SignEncryptUpdate(hSession, pPart, ulPartLen, 
    11051172                               pEncryptedPart, pulEncryptedPartLen); 
    11061173  if (rv == CKR_OK) { 
     
    11221189  spy_dump_ulong_in("hSession", hSession); 
    11231190  spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]", 
    11241191                      pEncryptedPart, ulEncryptedPartLen); 
     1192  CHECK_PO(); 
    11251193  rv = po->C_DecryptVerifyUpdate(hSession, pEncryptedPart, 
    11261194                                 ulEncryptedPartLen, pPart, 
    11271195                                 pulPartLen); 
     
    11431211  fprintf(spy_output, "pMechanism->type=%s\n", 
    11441212          lookup_enum(MEC_T, pMechanism->mechanism)); 
    11451213  spy_attribute_list_in("pTemplate", pTemplate, ulCount); 
     1214  CHECK_PO(); 
    11461215  rv = po->C_GenerateKey(hSession, pMechanism, pTemplate, 
    11471216                         ulCount, phKey); 
    11481217  if (rv == CKR_OK) { 
     
    11691238                        pPublicKeyTemplate, ulPublicKeyAttributeCount); 
    11701239  spy_attribute_list_in("pPrivateKeyTemplate", 
    11711240                        pPrivateKeyTemplate, ulPrivateKeyAttributeCount); 
     1241  CHECK_PO(); 
    11721242  rv = po->C_GenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate, 
    11731243                             ulPublicKeyAttributeCount, pPrivateKeyTemplate, 
    11741244                             ulPrivateKeyAttributeCount, phPublicKey, 
     
    11951265          lookup_enum(MEC_T, pMechanism->mechanism)); 
    11961266  spy_dump_ulong_in("hWrappingKey", hWrappingKey); 
    11971267  spy_dump_ulong_in("hKey", hKey); 
     1268  CHECK_PO(); 
    11981269  rv = po->C_WrapKey(hSession, pMechanism, hWrappingKey, 
    11991270                     hKey, pWrappedKey, pulWrappedKeyLen); 
    12001271  if (rv == CKR_OK) { 
     
    12221293  spy_dump_string_in("pWrappedKey[ulWrappedKeyLen]", 
    12231294                      pWrappedKey, ulWrappedKeyLen); 
    12241295  spy_attribute_list_in("pTemplate", pTemplate, ulAttributeCount); 
     1296  CHECK_PO(); 
    12251297  rv = po->C_UnwrapKey(hSession, pMechanism, hUnwrappingKey, 
    12261298                       pWrappedKey, ulWrappedKeyLen, pTemplate, 
    12271299                       ulAttributeCount, phKey); 
     
    12451317          lookup_enum(MEC_T, pMechanism->mechanism)); 
    12461318  spy_dump_ulong_in("hBaseKey", hBaseKey); 
    12471319  spy_attribute_list_in("pTemplate", pTemplate, ulAttributeCount); 
     1320  CHECK_PO(); 
    12481321  rv = po->C_DeriveKey(hSession, pMechanism, hBaseKey, 
    12491322                       pTemplate, ulAttributeCount, phKey); 
    12501323  if (rv == CKR_OK) { 
     
    12611334  enter("C_SeedRandom"); 
    12621335  spy_dump_ulong_in("hSession", hSession); 
    12631336  spy_dump_string_in("pSeed[ulSeedLen]", pSeed, ulSeedLen); 
     1337  CHECK_PO(); 
    12641338  rv = po->C_SeedRandom(hSession, pSeed, ulSeedLen); 
    12651339  return retne(rv); 
    12661340} 
     
    12731347  CK_RV rv; 
    12741348  enter("C_GenerateRandom"); 
    12751349  spy_dump_ulong_in("hSession", hSession); 
     1350  CHECK_PO(); 
    12761351  rv = po->C_GenerateRandom(hSession, RandomData, ulRandomLen); 
    12771352  if (rv == CKR_OK) { 
    12781353    spy_dump_string_out("RandomData[ulRandomLen]", 
     
    12871362  CK_RV rv; 
    12881363  enter("C_GetFunctionStatus"); 
    12891364  spy_dump_ulong_in("hSession", hSession); 
     1365  CHECK_PO(); 
    12901366  rv = po->C_GetFunctionStatus(hSession); 
    12911367  return retne(rv); 
    12921368} 
     
    12961372  CK_RV rv; 
    12971373  enter("C_CancelFunction"); 
    12981374  spy_dump_ulong_in("hSession", hSession); 
     1375  CHECK_PO(); 
    12991376  rv = po->C_CancelFunction(hSession); 
    13001377  return retne(rv); 
    13011378} 
     
    13061383{ 
    13071384  CK_RV rv; 
    13081385  enter("C_WaitForSlotEvent"); 
     1386  CHECK_PO(); 
    13091387  rv = po->C_WaitForSlotEvent(flags, pSlot, pRserved); 
    13101388  return retne(rv); 
    13111389}