Dispatcher.cs

Go to the documentation of this file.
00001 using System;
00002 using System.Collections;
00003 using DKMSCryptoCore;
00004 using DKMSProtocol;
00005 using DKMSErrorManager;
00006 
00015 namespace CryptoService
00016 {
00021     public class Dispatcher
00022     {
00023         #region Dispatcher class methods    
00024 
00028         public Dispatcher()
00029         {
00030             #if DEBUG               
00031                 // local copy of current Containers instance
00032                 _c = TestCryptoService._c;
00033                 // local copy of current CryptoCore Instance
00034                 _cc = TestCryptoService._cc;                    
00035             #else                
00036                 // local copy of current Containers instance
00037                 _c = Service._c;
00038                 // local copy of current CryptoCore Instance
00039                 _cc = Service._cc;              
00040             #endif
00041 
00042                 // Stmf Instance
00043             _stmf = new CryptoCore.Stmf(_cc);    
00044 
00045             // Smf Instance
00046             _smf = new CryptoCore.Smf(_cc);
00047 
00048             // ProtocolManager Instance
00049             _pm = new ProtocolManager(_cc.HostInfo.Info);
00050         }   
00051 
00057         public void CS_Dispacher(string RxProtocolBlock, out string TxProtocolBlock)
00058         {
00059             UInt32  ret = ErrorManager.DKMS_OK;
00060             
00061     
00062             // Initialization   
00063             TxProtocolBlock = string.Empty;             
00064 
00066             // Fase 1 Parse input data
00067             _pm.RxProtocolBlock = RxProtocolBlock;
00068             ret = _pm.XMLRXParser(out config);                          
00069             if(ret != ErrorManager.DKMS_OK)
00070             {
00071                 _pm.XMLTXParser_Set_Error(ret);
00072                 TxProtocolBlock = _pm.TxProtocolBlock;                  
00073             }
00074             else
00075             {               
00076                 // Verify Integrity                 
00077                 ret = _pm.VerifyDataIntegrity(config.security.hashValue);               
00078                 if(ret != ErrorManager.DKMS_OK)
00079                 {
00080                     _pm.XMLTXParser_Set_Error(ret);
00081                     TxProtocolBlock = _pm.TxProtocolBlock;                  
00082                 }
00083                 else
00084                 {
00085                     // Select the policy container to be use
00086                     string delimStr = "|";
00087                     char[] delimiter = delimStr.ToCharArray();
00088                     string[] groups = config.header.userName.Split(delimiter);
00089                     string group = string.Empty;
00090                     Hashtable currentgroup = new Hashtable(20, 0.1f);
00091 
00092                     if (groups.Length != 2)
00093                     {
00094                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00095                         _pm.XMLTXParser_Set_Error(ret);
00096                         TxProtocolBlock = _pm.TxProtocolBlock;
00097                     }
00098                     else
00099                     {
00100                         if (groups[1]== "dkms_operators")
00101                             currentgroup = _c.operatorsgc.SyncOGContainer;
00102                         else if (groups[1] == "dkms_technicians")
00103                             currentgroup = _c.techniciansgc.SyncTGContainer;
00104                         else if (groups[1] == "dkms_swdevelopers")
00105                             currentgroup = _c.swdevelopersgc.SyncSGContainer;
00106                         else if (groups[1] == "dkms_inserters")
00107                             currentgroup = _c.insertersgc.SyncIGContainer;
00108                         else if (groups[1] == "dkms_custodians")
00109                             currentgroup = _c.custodiansgc.SyncCGContainer;
00110                         else if (groups[1] == "dkms_controllers")
00111                             currentgroup = _c.controllersgc.SyncCGContainer;
00112                         else if (groups[1] == "dkms_admins")
00113                             currentgroup = _c.adminsgc.SyncAGContainer;
00114                         else if (groups[1] == "dkms_swadmins")
00115                             currentgroup = _c.swadminsgc.SyncSGContainer;
00116                         else
00117                         {
00118                             ret = ErrorManager.DKMS_ACCESS_DENIED;
00119                             _pm.XMLTXParser_Set_Error(ret);
00120                             TxProtocolBlock = _pm.TxProtocolBlock;
00121                         }
00122 
00123                         if (ret == ErrorManager.DKMS_OK)
00124                         {
00126                             // Fase 2 Call the right method
00127                             switch (config.body.cmdName)
00128                             {
00129                                 case "DKMS_OpenSession":
00130                                     if (currentgroup.ContainsKey("OpenSession"))
00131                                     {
00132                                         CS_OpenSession();
00133                                     }
00134                                     else
00135                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00136                                     break;
00137                                 case "DKMS_CloseSession":
00138                                     if (currentgroup.ContainsKey("CloseSession"))
00139                                     {
00140                                         CS_CloseSession();
00141                                     }
00142                                     else
00143                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00144                                     break;
00145                                 case "DKMS_GetSessionInfo":
00146                                     if (currentgroup.ContainsKey("GetSessionInfo"))
00147                                     {
00148                                         CS_GetSessionInfo();
00149                                     }
00150                                     else
00151                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00152                                     break;
00153                                 case "DKMS_Login":
00154                                     if (currentgroup.ContainsKey("Login"))
00155                                     {
00156                                         CS_Login();
00157                                     }
00158                                     else
00159                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00160                                     break;
00161                                 case "DKMS_Logout":
00162                                     if (currentgroup.ContainsKey("Logout"))
00163                                     {
00164                                         CS_Logout();
00165                                     }
00166                                     else
00167                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00168                                     break;
00169                                 case "DKMS_CreateObject":
00170                                     if (currentgroup.ContainsKey("CreateObject"))
00171                                     {
00172                                         CS_CreateObject();
00173                                     }
00174                                     else
00175                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00176                                     break;
00177                                 case "DKMS_FindObjectsInit":
00178                                     if (currentgroup.ContainsKey("FindObjectsInit"))
00179                                     {
00180                                         CS_FindObjectsInit();
00181                                     }
00182                                     else
00183                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00184                                     break;
00185                                 case "DKMS_FindObjects":
00186                                     if (currentgroup.ContainsKey("FindObjects"))
00187                                     {
00188                                         CS_FindObjects();
00189                                     }
00190                                     else
00191                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00192                                     break;
00193                                 case "DKMS_FindObjectsFinal":
00194                                     if (currentgroup.ContainsKey("FindObjectsFinal"))
00195                                     {
00196                                         CS_FindObjectsFinal();
00197                                     }
00198                                     else
00199                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00200                                     break;
00201                                 case "DKMS_CompactFindObjects":
00202                                     if (currentgroup.ContainsKey("CompactFindObjects"))
00203                                     {
00204                                         CS_CompactFindObjects();
00205                                     }
00206                                     else
00207                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00208                                     break;
00209                                 case "DKMS_EncryptInit":
00210                                     if (currentgroup.ContainsKey("EncryptInit"))
00211                                     {
00212                                         CS_EncryptInit();
00213                                     }
00214                                     else
00215                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00216                                     break;
00217                                 case "DKMS_Encrypt":
00218                                     if (currentgroup.ContainsKey("Encrypt"))
00219                                     {
00220                                         CS_Encrypt();
00221                                     }
00222                                     else
00223                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00224                                     break;
00225                                 case "DKMS_CompactEncrypt":
00226                                     if (currentgroup.ContainsKey("CompactEncrypt"))
00227                                     {
00228                                         CS_CompactEncrypt();
00229                                     }
00230                                     else
00231                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00232                                     break;
00233                                 case "DKMS_EncryptUpdate":
00234                                     if (currentgroup.ContainsKey("EncryptUpdate"))
00235                                     {
00236                                         CS_EncryptUpdate();
00237                                     }
00238                                     else
00239                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00240                                     break;
00241                                 case "DKMS_EncryptFinal":
00242                                     if (currentgroup.ContainsKey("EncryptFinal"))
00243                                     {
00244                                         CS_EncryptFinal();
00245                                     }
00246                                     else
00247                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00248                                     break;
00249                                 case "DKMS_DecryptInit":
00250                                     if (currentgroup.ContainsKey("DecryptInit"))
00251                                     {
00252                                         CS_DecryptInit();
00253                                     }
00254                                     else
00255                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00256                                     break;
00257                                 case "DKMS_Decrypt":
00258                                     if (currentgroup.ContainsKey("Decrypt"))
00259                                     {
00260                                         CS_Decrypt();
00261                                     }
00262                                     else
00263                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00264                                     break;
00265                                 case "DKMS_CompactDecrypt":
00266                                     if (currentgroup.ContainsKey("CompactDecrypt"))
00267                                     {
00268                                         CS_CompactDecrypt();
00269                                     }
00270                                     else
00271                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00272                                     break;
00273                                 case "DKMS_DecryptUpdate":
00274                                     if (currentgroup.ContainsKey("DecryptUpdate"))
00275                                     {
00276                                         CS_DecryptUpdate();
00277                                     }
00278                                     else
00279                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00280                                     break;
00281                                 case "DKMS_DecryptFinal":
00282                                     if (currentgroup.ContainsKey("DecryptFinal"))
00283                                     {
00284                                         CS_DecryptFinal();
00285                                     }
00286                                     else
00287                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00288                                     break;
00289                                 case "DKMS_GetInfo":
00290                                     if (currentgroup.ContainsKey("GetInfo"))
00291                                     {
00292                                         CS_GetInfo();
00293                                     }
00294                                     else
00295                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00296                                     break;
00297                                 case "DKMS_GetTokenInfo":
00298                                     if (currentgroup.ContainsKey("GetTokenInfo"))
00299                                     {
00300                                         CS_GetTokenInfo();
00301                                     }
00302                                     else
00303                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00304                                     break;
00305                                 case "DKMS_SeedRandom":
00306                                     if (currentgroup.ContainsKey("SeedRandom"))
00307                                     {
00308                                         CS_SeedRandom();
00309                                     }
00310                                     else
00311                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00312                                     break;
00313                                 case "DKMS_GenerateRandom":
00314                                     if (currentgroup.ContainsKey("GenerateRandom"))
00315                                     {
00316                                         CS_GenerateRandom();
00317                                     }
00318                                     else
00319                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00320                                     break;
00321                                 case "DKMS_CompactGenerateRandom":
00322                                     if (currentgroup.ContainsKey("CompactGenerateRandom"))
00323                                     {
00324                                         CS_CompactGenerateRandom();
00325                                     }
00326                                     else
00327                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00328                                     break;
00329                                 case "DKMS_DestroyObject":
00330                                     if (currentgroup.ContainsKey("DestroyObject"))
00331                                     {
00332                                         CS_DestroyObject();
00333                                     }
00334                                     else
00335                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00336                                     break;
00337                                 case "DKMS_GetMechanismList":
00338                                     if (currentgroup.ContainsKey("GetMechanismList"))
00339                                     {
00340                                         CS_GetMechanismList();
00341                                     }
00342                                     else
00343                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00344                                     break;
00345                                 case "DKMS_GetAttributeValue":
00346                                     if (currentgroup.ContainsKey("GetAttributeValue"))
00347                                     {
00348                                         CS_GetAttributeValue();
00349                                     }
00350                                     else
00351                                         ret = ErrorManager.DKMS_ACCESS_DENIED;    
00352                                     break;
00353                                 case "DKMS_DigestInit":
00354                                     if (currentgroup.ContainsKey("DigestInit"))
00355                                     {
00356                                         CS_DigestInit();
00357                                     }
00358                                     else
00359                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00360                                     break;
00361                                 case "DKMS_Digest":
00362                                     if (currentgroup.ContainsKey("Digest"))
00363                                     {
00364                                         CS_Digest();
00365                                     }
00366                                     else
00367                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00368                                     break;
00369                                 case "DKMS_CompactDigest":
00370                                     if (currentgroup.ContainsKey("CompactDigest"))
00371                                     {
00372                                         CS_CompactDigest();
00373                                     }
00374                                     else
00375                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00376                                     break;
00377                                 case "DKMS_DigestUpdate":
00378                                     if (currentgroup.ContainsKey("DigestUpdate"))
00379                                     {
00380                                         CS_DigestUpdate();
00381                                     }
00382                                     else
00383                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00384                                     break;
00385                                 case "DKMS_DigestKey":
00386                                     if (currentgroup.ContainsKey("DigestKey"))
00387                                     {
00388                                         CS_DigestKey();
00389                                     }
00390                                     else
00391                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00392                                     break;
00393                                 case "DKMS_DigestFinal":
00394                                     if (currentgroup.ContainsKey("DigestFinal"))
00395                                     {
00396                                         CS_DigestFinal();
00397                                     }
00398                                     else
00399                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00400                                     break;
00401                                 case "DKMS_SignInit":
00402                                     if (currentgroup.ContainsKey("SignInit"))
00403                                     {
00404                                         CS_SignInit();
00405                                     }
00406                                     else
00407                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00408                                     break;
00409                                 case "DKMS_Sign":
00410                                     if (currentgroup.ContainsKey("Sign"))
00411                                     {
00412                                         CS_Sign();
00413                                     }
00414                                     else
00415                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00416                                     break;
00417                                 case "DKMS_CompactSign":
00418                                     if (currentgroup.ContainsKey("CompactSign"))
00419                                     {
00420                                         CS_CompactSign();
00421                                     }
00422                                     else
00423                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00424                                     break;
00425                                 case "DKMS_SignUpdate":
00426                                     if (currentgroup.ContainsKey("SignUpdate"))
00427                                     {
00428                                         CS_SignUpdate();
00429                                     }
00430                                     else
00431                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00432                                     break;
00433                                 case "DKMS_SignFinal":
00434                                     if (currentgroup.ContainsKey("SignFinal"))
00435                                     {
00436                                         CS_SignFinal();
00437                                     }
00438                                     else
00439                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00440                                     break;
00441                                 case "DKMS_SignRecoverInit":
00442                                     if (currentgroup.ContainsKey("SignRecoverInit"))
00443                                     {
00444                                         CS_SignRecoverInit();
00445                                     }
00446                                     else
00447                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00448                                     break;
00449                                 case "DKMS_SignRecover":
00450                                     if (currentgroup.ContainsKey("SignRecover"))
00451                                     {
00452                                         CS_SignRecover();
00453                                     }
00454                                     else
00455                                         ret = ErrorManager.DKMS_ACCESS_DENIED;    
00456                                     break;
00457                                 case "DKMS_CompactSignRecover":
00458                                     if (currentgroup.ContainsKey("CompactSignRecover"))
00459                                     {
00460                                         CS_CompactSignRecover();
00461                                     }
00462                                     else
00463                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00464                                     break;
00465                                 case "DKMS_VerifyInit":
00466                                     if (currentgroup.ContainsKey("VerifyInit"))
00467                                     {
00468                                         CS_VerifyInit();
00469                                     }
00470                                     else
00471                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00472                                     break;
00473                                 case "DKMS_Verify":
00474                                     if (currentgroup.ContainsKey("Verify"))
00475                                     {
00476                                         CS_Verify();
00477                                     }
00478                                     else
00479                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00480                                     break;
00481                                 case "DKMS_CompactVerify":
00482                                     if (currentgroup.ContainsKey("CompactVerify"))
00483                                     {
00484                                         CS_CompactVerify();
00485                                     }
00486                                     else
00487                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00488                                     break;
00489                                 case "DKMS_VerifyUpdate":
00490                                     if (currentgroup.ContainsKey("VerifyUpdate"))
00491                                     {
00492                                         CS_VerifyUpdate();
00493                                     }
00494                                     else
00495                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00496                                     break;
00497                                 case "DKMS_VerifyFinal":
00498                                     if (currentgroup.ContainsKey("VerifyFinal"))
00499                                     {
00500                                         CS_VerifyFinal();
00501                                     }
00502                                     else
00503                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00504                                     break;
00505                                 case "DKMS_VerifyRecoverInit":
00506                                     if (currentgroup.ContainsKey("VerifyRecoverInit"))
00507                                     {
00508                                         CS_VerifyRecoverInit();
00509                                     }
00510                                     else
00511                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00512                                     break;
00513                                 case "DKMS_VerifyRecover":
00514                                     if (currentgroup.ContainsKey("VerifyRecover"))
00515                                     {
00516                                         CS_VerifyRecover();
00517                                     }
00518                                     else
00519                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00520                                     break;
00521                                 case "DKMS_CompactVerifyRecover":
00522                                     if (currentgroup.ContainsKey("CompactVerifyRecover"))
00523                                     {
00524                                         CS_CompactVerifyRecover();
00525                                     }
00526                                     else
00527                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00528                                     break;
00529                                 case "DKMS_DigestEncryptUpdate":
00530                                     if (currentgroup.ContainsKey("DigestEncryptUpdate"))
00531                                     {
00532                                         CS_DigestEncryptUpdate();
00533                                     }
00534                                     else
00535                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00536                                     break;
00537                                 case "DKMS_DecryptDigestUpdate":
00538                                     if (currentgroup.ContainsKey("DecryptDigestUpdate"))
00539                                     {
00540                                         CS_DecryptDigestUpdate();
00541                                     }
00542                                     else
00543                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00544                                     break;
00545                                 case "DKMS_SignEncryptUpdate":
00546                                     if (currentgroup.ContainsKey("SignEncryptUpdate"))
00547                                     {
00548                                         CS_SignEncryptUpdate();
00549                                     }
00550                                     else
00551                                         ret = ErrorManager.DKMS_ACCESS_DENIED;    
00552                                     break;
00553                                 case "DKMS_DecryptVerifyUpdate":
00554                                     if (currentgroup.ContainsKey("DecryptVerifyUpdate"))
00555                                     {
00556                                         CS_DecryptVerifyUpdate();
00557                                     }
00558                                     else
00559                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00560                                     break;
00561                                 case "DKMS_GenerateKey":
00562                                     if (currentgroup.ContainsKey("GenerateKey"))
00563                                     {
00564                                         CS_GenerateKey();
00565                                     }
00566                                     else
00567                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00568                                     break;
00569                                 case "DKMS_GenerateKeyPair":
00570                                     if (currentgroup.ContainsKey("GenerateKeyPair"))
00571                                     {
00572                                         CS_GenerateKeyPair();
00573                                     }
00574                                     else
00575                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00576                                     break;
00577                                 case "DKMS_WrapKey":
00578                                     if (currentgroup.ContainsKey("WrapKey"))
00579                                     {
00580                                         CS_WrapKey();
00581                                     }
00582                                     else
00583                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00584                                     break;
00585                                 case "DKMS_UnwrapKey":
00586                                     if (currentgroup.ContainsKey("UnwrapKey"))
00587                                     {
00588                                         CS_UnwrapKey();
00589                                     }
00590                                     else
00591                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00592                                     break;
00593                                 case "DKMS_DeriveKey":
00594                                     if (currentgroup.ContainsKey("DeriveKey"))
00595                                     {
00596                                         CS_DeriveKey();
00597                                     }
00598                                     else
00599                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00600                                     break;
00601                                 case "DKMS_SetAttributeValue":
00602                                     if (currentgroup.ContainsKey("SetAttributeValue"))
00603                                     {
00604                                         CS_SetAttributeValue();
00605                                     }
00606                                     else
00607                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00608                                     break;
00609                                 case "DKMS_GetObjectSize":
00610                                     if (currentgroup.ContainsKey("GetObjectSize"))
00611                                     {
00612                                         CS_GetObjectSize();
00613                                     }
00614                                     else
00615                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00616                                     break;
00617                                 case "DKMS_SetPIN":
00618                                     if (currentgroup.ContainsKey("SetPIN"))
00619                                     {
00620                                         CS_SetPIN();
00621                                     }
00622                                     else
00623                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00624                                     break;
00625                                 case "DKMS_InitPIN":
00626                                     if (currentgroup.ContainsKey("InitPIN"))
00627                                     {
00628                                         CS_InitPIN();
00629                                     }
00630                                     else
00631                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00632                                     break;
00633                                 case "DKMS_InitToken":
00634                                     if (currentgroup.ContainsKey("InitToken"))
00635                                     {
00636                                         CS_InitToken();
00637                                     }
00638                                     else
00639                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00640                                     break;
00641                                 case "DKMS_GetMechanismInfo":
00642                                     if (currentgroup.ContainsKey("GetMechanismInfo"))
00643                                     {
00644                                         CS_GetMechanismInfo();
00645                                     }
00646                                     else
00647                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00648                                     break;
00649                                 case "DKMS_GetSlotInfo":
00650                                     if (currentgroup.ContainsKey("GetSlotInfo"))
00651                                     {
00652                                         CS_GetSlotInfo();
00653                                     }
00654                                     else
00655                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00656                                     break;
00657                                 case "DKMS_GetSlotList":
00658                                     if (currentgroup.ContainsKey("GetSlotList"))
00659                                     {
00660                                         CS_GetSlotList();
00661                                     }
00662                                     else
00663                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00664                                     break;
00665                                 case "DKMS_TestDeviceComunication":
00666                                     if (currentgroup.ContainsKey("TestDeviceComunication"))
00667                                     {
00668                                         CS_TestDeviceComunication();
00669                                     }
00670                                     else
00671                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00672                                     break;
00673                                 case "DKMS_SetPolicy":
00674                                     if (currentgroup.ContainsKey("SetPolicy"))
00675                                     {
00676                                         lock (_c.adminsgc.SyncAGContainer.SyncRoot)
00677                                         {
00678                                             lock (_c.controllersgc.SyncCGContainer.SyncRoot)
00679                                             {
00680                                                 lock (_c.custodiansgc.SyncCGContainer.SyncRoot)
00681                                                 {
00682                                                     lock (_c.insertersgc.SyncIGContainer.SyncRoot)
00683                                                     {
00684                                                         lock (_c.operatorsgc.SyncOGContainer.SyncRoot)
00685                                                         {
00686                                                             lock (_c.swadminsgc.SyncSGContainer.SyncRoot)
00687                                                             {
00688                                                                 lock (_c.swdevelopersgc.SyncSGContainer.SyncRoot)
00689                                                                 {
00690                                                                     lock (_c.techniciansgc.SyncTGContainer.SyncRoot)
00691                                                                     {
00692                                                                         CS_SetPolicy();
00693                                                                     }
00694                                                                 }
00695                                                             }
00696                                                         }
00697                                                     }
00698                                                 }
00699                                             }
00700                                         }
00701                                     }
00702                                     else
00703                                         ret = ErrorManager.DKMS_ACCESS_DENIED;
00704                                     break;
00705                                 // Function not found
00706                                 default:
00707                                     ret = ErrorManager.DKMS_FUNCTION_NOT_FOUND;                                    
00708                                     break;
00709                             }
00710 
00711                             // Fill the output buffer if error is found
00712                             if (ret != ErrorManager.DKMS_OK)
00713                                 _pm.XMLTXParser_Set_Error(ret);
00714 
00715                             // Fill the output buffer
00716                             TxProtocolBlock = _pm.TxProtocolBlock;
00717                         }
00718                     }
00719                 }
00720             }
00721         }           
00722             
00727         private void CS_OpenSession()
00728         {               
00729             UInt32                              ret = ErrorManager.DKMS_OK;         
00730             // Function arguments IN
00731             UInt32                              slotID;
00732             CryptoCore.Smf.SESSION_INFO_FLAGS   flags;
00733 
00734 
00736             // Get parameter from DKMSProtocol Data Block                  //
00737             // Param: {UInt32 slotID, SESSION_INFO_FLAGS flags}            // 
00739             /* get slotID */ 
00740             slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
00741             /* get flags */
00742             flags = (CryptoCore.Smf.SESSION_INFO_FLAGS)int.Parse(((ProtocolManager.Param)config.body.param["flags"]).vvalue);
00743                 
00744             // Send Command - OpenSession
00745             ret = _smf.OpenSession(slotID, flags);          
00746                 
00747             // Bad Result
00748             if(ret != ErrorManager.DKMS_OK)
00749             {
00750                 _pm.XMLTXParser_Set_Error(ret);             
00751             }
00752             // Good Result
00753             else
00754             {
00755                 // Increase the counter in the container
00756                 lock (_c.csc.SyncCSContainer.SyncRoot)
00757                 {
00758                     UInt32 ss = (UInt32)_c.csc.SyncCSContainer["sessions"];
00759                     ss++;
00760                     _c.csc.SyncCSContainer["sessions"] = ss;
00761                 }
00762 
00764                 // Fase 3 Build the responce
00765                 /* 1 */
00766                 _pm.XMLTXParser_Set_Start("DKMS_OpenSession", 2);
00767                 /* 2 */
00768                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00769                 _pm.XMLTXParser_Set_ParamAtomic(1, "CurrentSession", ProtocolManager.PARAM_TYPE.UINT32, _smf.CurrentSession.ToString());
00770                 /* 3 */
00771                 _pm.XMLTXParser_Set_End();              
00772             }           
00773         }
00774 
00779         private void CS_CloseSession()
00780         {               
00781             UInt32                              ret = ErrorManager.DKMS_OK;         
00782             // Function arguments IN
00783             UInt32                              hSession;
00784 
00785 
00787             // Get parameter from DKMSProtocol Data Block                  //
00788             // Param: {UInt32 hSession}                                    // 
00790             /* get hSession */
00791             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00792 
00793             // Send Command - CloseSession          
00794             ret = _smf.CloseSession(hSession);
00795 
00796             // Bad Result
00797             if(ret != ErrorManager.DKMS_OK)
00798             {
00799                 _pm.XMLTXParser_Set_Error(ret);             
00800             }
00801             // Good Result
00802             else
00803             {
00804                 // Decrease the counter in the container
00805                 lock (_c.csc.SyncCSContainer.SyncRoot)
00806                 {
00807                     UInt32 ss = (UInt32)_c.csc.SyncCSContainer["sessions"];
00808                     if (ss > 0)
00809                     {
00810                         ss--;
00811                         _c.csc.SyncCSContainer["sessions"] = ss;
00812                     }
00813                     if (ss == 0)
00814                     {
00815                         _cc.Finalize();
00816                         _cc.Initialize(true); 
00817                     }
00818                 }
00819 
00821                 // Fase 3 Build the responce                    
00822                 /* 1 */
00823                 _pm.XMLTXParser_Set_Start("DKMS_CloseSession", 1);
00824                 /* 2 */
00825                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00826                 /* 3 */
00827                 _pm.XMLTXParser_Set_End();              
00828             }           
00829         }       
00830 
00834         private void CS_GetSessionInfo()
00835         {               
00836             UInt32                              ret = ErrorManager.DKMS_OK;         
00837             // Function arguments IN
00838             UInt32                              hSession;
00839             // Function arguments OUT
00840             CryptoCore.Smf.CK_SESSION_INFO      pInfo;
00841 
00842 
00844             // Get parameter from DKMSProtocol Data Block                  //
00845             // Param: {UInt32 hSession, out CK_SESSION_INFO pInfo}         // 
00847             /* get-set hSession */
00848             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00849             _smf.CurrentSession = hSession;
00850 
00852             // Initialization                             //
00854             /* initialize pInfo */
00855             pInfo = new CryptoCore.Smf.CK_SESSION_INFO();
00856 
00857             // Send Command - GetSessionInfo
00858             ret = _smf.GetSessionInfo(out pInfo);
00859 
00860             // Bad Result
00861             if(ret != ErrorManager.DKMS_OK)
00862             {
00863                 _pm.XMLTXParser_Set_Error(ret);             
00864             }
00865             // Good Result
00866             else
00867             {
00869                 // Fase 3 Build the responce                    
00870                 /* 1 */
00871                 _pm.XMLTXParser_Set_Start("DKMS_GetSessionInfo", 2);
00872                 /* 2 */
00873                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00874                 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
00875                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
00876                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.slotID", ProtocolManager.PARAM_TYPE.UINT32, pInfo.slotID.ToString());
00877                 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.state", ProtocolManager.PARAM_TYPE.UINT32, pInfo.state.ToString());
00878                 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.ulDeviceError", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulDeviceError.ToString());
00879                 _pm.XMLTXParser_Set_EndParamStruct();
00880                 /* 3 */
00881                 _pm.XMLTXParser_Set_End();              
00882             }           
00883         }
00884 
00888         private void CS_Login()
00889         {               
00890             UInt32                              ret = ErrorManager.DKMS_OK;             
00891             // Function arguments IN
00892             UInt32                              hSession;
00893             CryptoCore.Smf.CK_USER_TYPE         userType;
00894             string                              Pin;
00895 
00896 
00898             // Get parameter from DKMSProtocol Data Block                  //
00899             // Param: {UInt32 hSession, UInt32 userType, string Pin}       // 
00901             /* get-set hSession */
00902             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00903             _smf.CurrentSession = hSession;
00904             /* get userType */
00905             userType = (CryptoCore.Smf.CK_USER_TYPE)int.Parse(((ProtocolManager.Param)config.body.param["userType"]).vvalue);
00906             /* get Pin */
00907             Pin = ((ProtocolManager.Param)config.body.param["Pin"]).vvalue;         
00908 
00909             // Send Command - Login
00910             ret = _smf.Login(userType, Pin);
00911 
00912             // Bad Result
00913             if(ret != ErrorManager.DKMS_OK)
00914             {
00915                 _pm.XMLTXParser_Set_Error(ret);             
00916             }
00917             // Good Result
00918             else
00919             {
00921                 // Fase 3 Build the responce                    
00922                 /* 1 */
00923                 _pm.XMLTXParser_Set_Start("DKMS_Login", 1);
00924                 /* 2 */
00925                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00926                 /* 3 */
00927                 _pm.XMLTXParser_Set_End();
00928             }           
00929         }
00930 
00934         private void CS_Logout()
00935         {               
00936             UInt32                              ret = ErrorManager.DKMS_OK;         
00937             // Function arguments IN
00938             UInt32                              hSession;
00939 
00940 
00942             // Get parameter from DKMSProtocol Data Block                  //
00943             // Param: {UInt32 hSession}                                    // 
00945             /* get-set hSession */
00946             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00947             _smf.CurrentSession = hSession;
00948 
00949             // Send Command - Logout
00950             ret = _smf.Logout();
00951 
00952             // Bad Result
00953             if(ret != ErrorManager.DKMS_OK)
00954             {
00955                 _pm.XMLTXParser_Set_Error(ret);             
00956             }
00957             // Good Result
00958             else
00959             {
00961                 // Fase 3 Build the responce                    
00962                 /* 1 */
00963                 _pm.XMLTXParser_Set_Start("DKMS_Logout", 1);
00964                 /* 2 */
00965                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00966                 /* 3 */
00967                 _pm.XMLTXParser_Set_End();
00968             }           
00969         }
00970 
00974         private void CS_CreateObject()
00975         {               
00976             UInt32                              ret = ErrorManager.DKMS_OK;
00977             CryptoCore.CCConvert                converter;
00978             UInt32                              ulCount;
00979             // Function arguments IN
00980             UInt32                              hSession;
00981             CryptoCore.ATTRIBUTE_VALUE          templ;
00982             // Function arguments OUT               
00983             UInt32                              phObject;
00984 
00985 
00986             // Initialization
00987             converter = new CryptoCore.CCConvert();
00988 
00990             // Get parameter from DKMSProtocol Data Block                       //
00991             // Param: {ATTRIBUTE_VALUE templ, out UInt32 phObject}              // 
00993             /* get-set hSession */
00994             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00995             _smf.CurrentSession = hSession;
00996             /* get templ */
00997             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;         
00998             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
00999             
01000             // Bad Result
01001             if(ret != ErrorManager.DKMS_OK)
01002             {
01003                 _pm.XMLTXParser_Set_Error(ret);             
01004             }
01005             // Good Result
01006             else
01007             {
01008                 // Send Command - CreateObject
01009                 ret = _smf.omf.CreateObject(templ, out phObject);
01010 
01011                 // Bad Result
01012                 if(ret != ErrorManager.DKMS_OK)
01013                 {
01014                     _pm.XMLTXParser_Set_Error(ret);             
01015                 }
01016                 // Good Result
01017                 else
01018                 {
01020                     // Fase 3 Build the responce                    
01021                     /* 1 */
01022                     _pm.XMLTXParser_Set_Start("DKMS_CreateObject", 2);
01023                     /* 2 */
01024                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01025                     _pm.XMLTXParser_Set_ParamAtomic(1, "phObject", ProtocolManager.PARAM_TYPE.UINT32, phObject.ToString());
01026                     /* 3 */
01027                     _pm.XMLTXParser_Set_End();
01028                 }
01029             }
01030         }
01031         
01036         private void CS_FindObjectsInit()
01037         {               
01038             UInt32                              ret = ErrorManager.DKMS_OK;
01039             CryptoCore.CCConvert                converter;
01040             UInt32                              ulCount;
01041             // Function arguments IN
01042             UInt32                              hSession;
01043             CryptoCore.ATTRIBUTE_VALUE          templ;
01044 
01045             
01046             // Initialization
01047             converter = new CryptoCore.CCConvert();
01048 
01050             // Get parameter from DKMSProtocol Data Block                  //
01051             // Param: {UInt32 hSession, CryptoCore.ATTRIBUTE_VALUE templ}  // 
01053             /* get-set hSession */
01054             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01055             _smf.CurrentSession = hSession;
01056             /* get templ */ 
01057             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;         
01058             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
01059             
01060             // Bad Result
01061             if(ret != ErrorManager.DKMS_OK)
01062             {
01063                 _pm.XMLTXParser_Set_Error(ret);             
01064             }
01065             // Good Result
01066             else
01067             {
01068                 // Send Command - FindObjectsInit
01069                 ret = _smf.omf.FindObjectsInit(templ);
01070 
01071                 // Bad Result
01072                 if(ret != ErrorManager.DKMS_OK)
01073                 {
01074                     _pm.XMLTXParser_Set_Error(ret);             
01075                 }
01076                 // Good Result
01077                 else
01078                 {
01080                     // Fase 3 Build the responce                    
01081                     /* 1 */
01082                     _pm.XMLTXParser_Set_Start("DKMS_FindObjectsInit", 1);
01083                     /* 2 */
01084                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01085                     /* 3 */
01086                     _pm.XMLTXParser_Set_End();
01087                 }           
01088             }
01089         }
01090             
01095         private void CS_FindObjects()
01096         {               
01097             UInt32                              ret = ErrorManager.DKMS_OK;         
01098             // Function arguments IN
01099             UInt32                              hSession;
01100             int                                 maxObjectNumber;
01101             // Function arguments OUT               
01102             UInt32[]                            hObject;
01103 
01104 
01106             // Get parameter from DKMSProtocol Data Block                           //
01107             // Param: {UInt32 hSession, int maxObjectNumber, out UInt32[] hObject}  // 
01109             /* get-set hSession */  
01110             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01111             _smf.CurrentSession = hSession;
01112             /* get maxObjectNumber */
01113             maxObjectNumber = int.Parse(((ProtocolManager.Param)config.body.param["maxObjectNumber"]).vvalue);
01114 
01115             // Send Command - FindObjects
01116             ret = _smf.omf.FindObjects(out hObject, maxObjectNumber);
01117 
01118             // Bad Result
01119             if(ret != ErrorManager.DKMS_OK)
01120             {
01121                 _pm.XMLTXParser_Set_Error(ret);             
01122             }
01123             // Good Result
01124             else
01125             {
01127                 // Fase 3 Build the responce                    
01128                 /* 1 */
01129                 _pm.XMLTXParser_Set_Start("DKMS_FindObjects", 2);
01130                 /* 2 */
01131                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01132                 _pm.XMLTXParser_Set_StartParamArray(1, "hObject", ProtocolManager.PARAM_TYPE.UINT32, (UInt32)hObject.Length, 0);
01133                 for (int i = 0; i < hObject.Length; i++)
01134                     _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "hObject[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.UINT32, hObject[i].ToString());
01135                 _pm.XMLTXParser_Set_EndParamArray();
01136                 /* 3 */
01137                 _pm.XMLTXParser_Set_End();
01138             }           
01139         }
01140 
01144         private void CS_FindObjectsFinal()
01145         {
01146             UInt32                              ret = ErrorManager.DKMS_OK;         
01147             // Function arguments IN
01148             UInt32                              hSession;
01149 
01150 
01152             // Get parameter from DKMSProtocol Data Block                  //
01153             // Param: {UInt32 hSession}                                    // 
01155             /* get-set hSession */  
01156             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01157             _smf.CurrentSession = hSession;         
01158 
01159             // Send Command - FindObjectsFinal
01160             ret = _smf.omf.FindObjectsFinal();
01161 
01162             // Bad Result
01163             if(ret != ErrorManager.DKMS_OK)
01164             {
01165                 _pm.XMLTXParser_Set_Error(ret);             
01166             }
01167             // Good Result
01168             else
01169             {
01171                 // Fase 3 Build the responce                    
01172                 /* 1 */
01173                 _pm.XMLTXParser_Set_Start("DKMS_FindObjectsFinal", 1);
01174                 /* 2 */
01175                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01176                 /* 3 */
01177                 _pm.XMLTXParser_Set_End();
01178             }           
01179         }
01180 
01185         private void CS_CompactFindObjects()
01186         {
01187             UInt32                              ret = ErrorManager.DKMS_OK;
01188             CryptoCore.CCConvert                converter;
01189             UInt32                              ulCount;
01190             // Function arguments IN
01191             UInt32                              hSession;
01192             int                                 maxObjectNumber;            
01193             CryptoCore.ATTRIBUTE_VALUE          templ;            
01194             // Function arguments OUT               
01195             UInt32[]                            hObject;
01196 
01197 
01198             // Initialization
01199             converter = new CryptoCore.CCConvert();
01200 
01202             // Get parameter from DKMSProtocol Data Block                           //
01203             // Param: {UInt32 hSession, CryptoCore.ATTRIBUTE_VALUE templ,           //
01204             // int maxObjectNumber, out UInt32[] hObject}                           // 
01206             /* get-set hSession */
01207             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01208             _smf.CurrentSession = hSession;            
01209             /* get maxObjectNumber */
01210             maxObjectNumber = int.Parse(((ProtocolManager.Param)config.body.param["maxObjectNumber"]).vvalue);
01211              /* get templ */    
01212             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;         
01213             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
01214                     
01215             // Bad Result
01216             if(ret != ErrorManager.DKMS_OK)
01217             {
01218                 _pm.XMLTXParser_Set_Error(ret);             
01219             }
01220             // Good Result
01221             else
01222             {
01223                 // Send Command - CompactFindObjects
01224                 ret = _smf.omf.CompactFindObjects(templ, out hObject, maxObjectNumber);
01225 
01226                 // Bad Result
01227                 if (ret != ErrorManager.DKMS_OK)
01228                 {
01229                     _pm.XMLTXParser_Set_Error(ret);
01230                 }
01231                 // Good Result
01232                 else
01233                 {
01235                     // Fase 3 Build the responce                    
01236                     /* 1 */
01237                     _pm.XMLTXParser_Set_Start("DKMS_CompactFindObjects", 2);
01238                     /* 2 */
01239                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01240                     _pm.XMLTXParser_Set_StartParamArray(1, "hObject", ProtocolManager.PARAM_TYPE.UINT32, (UInt32)hObject.Length, 0);
01241                     for (int i = 0; i < hObject.Length; i++)
01242                         _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "hObject[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.UINT32, hObject[i].ToString());
01243                     _pm.XMLTXParser_Set_EndParamArray();
01244                     /* 3 */
01245                     _pm.XMLTXParser_Set_End();                        
01246                 }
01247             }
01248         }
01249 
01253         private void CS_EncryptInit()
01254         {               
01255             UInt32                              ret = ErrorManager.DKMS_OK;
01256             CryptoCore.CCConvert                converter;      
01257             // Function arguments IN
01258             UInt32                              hSession;               
01259             UInt32                              hKey;
01260             CryptoCore.Smf.MECHANISM            mech;
01261 
01262             
01263             // Initialization
01264             converter = new CryptoCore.CCConvert();
01265 
01267             // Get parameter from DKMSProtocol Data Block                  //
01268             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey}       // 
01270             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01271             _smf.CurrentSession = hSession;
01272             /* get hKey */ 
01273             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01274             /* get mech */
01275             ret = converter.ParseMechanismIn(out mech, config);
01276             
01277             // Bad Result
01278             if(ret != ErrorManager.DKMS_OK)
01279             {
01280                 _pm.XMLTXParser_Set_Error(ret);             
01281             }
01282             // Good Result
01283             else
01284             {
01285                 // Send Command - EncryptInit
01286                 ret = _smf.ef.EncryptInit(mech, hKey);
01287 
01288                 // Bad Result
01289                 if(ret != ErrorManager.DKMS_OK)
01290                 {
01291                     _pm.XMLTXParser_Set_Error(ret);                 
01292                 }
01293                 // Good Result
01294                 else
01295                 {
01297                     // Fase 3 Build the responce                    
01298                     /* 1 */
01299                     _pm.XMLTXParser_Set_Start("DKMS_EncryptInit", 1);
01300                     /* 2 */
01301                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01302                     /* 3 */
01303                     _pm.XMLTXParser_Set_End();
01304                 }
01305             }
01306         }
01307             
01311         private void CS_Encrypt()
01312         {               
01313             UInt32                              ret = ErrorManager.DKMS_OK;         
01314             // Function arguments IN
01315             UInt32                              hSession;               
01316             string                              ClearData;
01317             // Function arguments OUT               
01318             string                              EncryptedData;
01319 
01320 
01322             // Get parameter from DKMSProtocol Data Block                           //
01323             // Param: {UInt32 hSession, string ClearData, out string EncryptedData} // 
01325             /* get-set hSession */
01326             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01327             _smf.CurrentSession = hSession;
01328             /* get ClearData */
01329             ClearData = ((ProtocolManager.Param)config.body.param["ClearData"]).vvalue;
01330             
01331             // Send Command - Encrypt
01332             ret = _smf.ef.Encrypt(ClearData, out EncryptedData);
01333 
01334             // Bad Result
01335             if(ret != ErrorManager.DKMS_OK)
01336             {
01337                 _pm.XMLTXParser_Set_Error(ret);             
01338             }
01339             // Good Result
01340             else
01341             {
01343                 // Fase 3 Build the responce
01344                 /* 1 */
01345                 _pm.XMLTXParser_Set_Start("DKMS_Encrypt", 2);
01346                 /* 2 */
01347                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01348                 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedData", ProtocolManager.PARAM_TYPE.STRING, EncryptedData);
01349                 /* 3 */
01350                 _pm.XMLTXParser_Set_End();
01351             }
01352         }
01353 
01357         private void CS_CompactEncrypt()
01358         {
01359             UInt32                              ret = ErrorManager.DKMS_OK;
01360             CryptoCore.CCConvert                converter;
01361             // Function arguments IN
01362             UInt32                              hSession;
01363             UInt32                              hKey;
01364             CryptoCore.Smf.MECHANISM            mech;
01365             string                              ClearData;
01366             // Function arguments OUT               
01367             string                              EncryptedData;
01368 
01369 
01370             // Initialization
01371             converter = new CryptoCore.CCConvert();
01372 
01374             // Get parameter from DKMSProtocol Data Block                  //
01375             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey,       // 
01376             // string ClearData, out string EncryptedData}                 // 
01378             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01379             _smf.CurrentSession = hSession;
01380             /* get hKey */
01381             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01382             /* get ClearData */
01383             ClearData = ((ProtocolManager.Param)config.body.param["ClearData"]).vvalue;
01384             /* get mech */
01385             ret = converter.ParseMechanismIn(out mech, config);
01386 
01387             // Bad Result
01388             if (ret != ErrorManager.DKMS_OK)
01389             {
01390                 _pm.XMLTXParser_Set_Error(ret);
01391             }
01392             // Good Result
01393             else
01394             {
01395                 // Send Command - CompactEncrypt
01396                 ret = _smf.ef.CompactEncrypt(mech, hKey, ClearData, out EncryptedData);
01397 
01398                 // Bad Result
01399                 if (ret != ErrorManager.DKMS_OK)
01400                 {
01401                     _pm.XMLTXParser_Set_Error(ret);
01402                 }
01403                 // Good Result
01404                 else
01405                 {                    
01407                     // Fase 3 Build the responce
01408                     /* 1 */
01409                     _pm.XMLTXParser_Set_Start("DKMS_CompactEncrypt", 2);
01410                     /* 2 */
01411                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01412                     _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedData", ProtocolManager.PARAM_TYPE.STRING, EncryptedData);
01413                     /* 3 */
01414                     _pm.XMLTXParser_Set_End();                    
01415                 }
01416             }
01417         }
01418 
01423         private void CS_EncryptUpdate()
01424         {               
01425             UInt32                              ret = ErrorManager.DKMS_OK;         
01426             // Function arguments IN
01427             UInt32                              hSession;               
01428             string                              ClearPartData;
01429             // Function arguments OUT               
01430             string                              EncryptedPartData;
01431 
01432 
01434             // Get parameter from DKMSProtocol Data Block                                   //
01435             // Param: {UInt32 hSession, string ClearPartData, out string EncryptedPartData} // 
01437             /* get-set hSession */
01438             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01439             _smf.CurrentSession = hSession;
01440             /* get ClearPartData */
01441             ClearPartData = ((ProtocolManager.Param)config.body.param["ClearPartData"]).vvalue;
01442             
01443             // Send Command - EncryptUpdate
01444             ret = _smf.ef.EncryptUpdate(ClearPartData, out EncryptedPartData);
01445 
01446             // Bad Result
01447             if(ret != ErrorManager.DKMS_OK)
01448             {
01449                 _pm.XMLTXParser_Set_Error(ret);             
01450             }
01451             // Good Result
01452             else
01453             {
01455                 // Fase 3 Build the responce
01456                 /* 1 */
01457                 _pm.XMLTXParser_Set_Start("DKMS_EncryptUpdate", 2);
01458                 /* 2 */
01459                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01460                 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, EncryptedPartData);
01461                 /* 3 */
01462                 _pm.XMLTXParser_Set_End();
01463             }
01464         }
01465 
01469         private void CS_EncryptFinal()
01470         {               
01471             UInt32 ret = ErrorManager.DKMS_OK;          
01472             // Function arguments IN
01473             UInt32                              hSession;
01474             // Function arguments OUT
01475             string                              LastEncryptedPartData;
01476 
01477 
01479             // Get parameter from DKMSProtocol Data Block                  //
01480             // Param: {UInt32 hSession, out string LastEncryptedPartData}  // 
01482             /* get-set hSession */
01483             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01484             _smf.CurrentSession = hSession;
01485             
01486             // Send Command - EncryptFinal
01487             ret = _smf.ef.EncryptFinal(out LastEncryptedPartData);
01488 
01489             // Bad Result
01490             if(ret != ErrorManager.DKMS_OK)
01491             {
01492                 _pm.XMLTXParser_Set_Error(ret);             
01493             }
01494             // Good Result
01495             else
01496             {
01498                 // Fase 3 Build the responce                    
01499                 /* 1 */
01500                 _pm.XMLTXParser_Set_Start("DKMS_EncryptFinal", 2);
01501                 /* 2 */
01502                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01503                 _pm.XMLTXParser_Set_ParamAtomic(1, "LastEncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, LastEncryptedPartData);
01504                 /* 3 */
01505                 _pm.XMLTXParser_Set_End();              
01506             }
01507         }
01508             
01512         private void CS_DecryptInit()
01513         {               
01514             UInt32                              ret = ErrorManager.DKMS_OK;
01515             CryptoCore.CCConvert                converter;      
01516             // Function arguments IN
01517             UInt32                              hSession;           
01518             CryptoCore.Smf.MECHANISM            mech;
01519             UInt32                              hKey;
01520 
01521 
01522             // Initialization
01523             converter = new CryptoCore.CCConvert();
01524 
01526             // Get parameter from DKMSProtocol Data Block                  //
01527             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey}       // 
01529             /* get-set hSession */
01530             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01531             _smf.CurrentSession = hSession;
01532             /* get hKey */
01533             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01534             /* get mech */
01535             ret = converter.ParseMechanismIn(out mech, config);         
01536 
01537             // Bad Result
01538             if(ret != ErrorManager.DKMS_OK)
01539             {
01540                 _pm.XMLTXParser_Set_Error(ret);             
01541             }
01542             // Good Result
01543             else
01544             {
01545                 // Send Command - DecryptInit
01546                 ret = _smf.df.DecryptInit(mech, hKey);
01547 
01548                 // Bad Result
01549                 if(ret != ErrorManager.DKMS_OK)
01550                 {
01551                     _pm.XMLTXParser_Set_Error(ret);                 
01552                 }
01553                 // Good Result
01554                 else
01555                 {
01557                     // Fase 3 Build the responce                    
01558                     /* 1 */
01559                     _pm.XMLTXParser_Set_Start("DKMS_DecryptInit", 1);
01560                     /* 2 */
01561                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01562                     /* 3 */
01563                     _pm.XMLTXParser_Set_End();                  
01564                 }
01565             }
01566         }
01567                 
01571         private void CS_Decrypt()
01572         {               
01573             UInt32                              ret = ErrorManager.DKMS_OK;                 
01574             // Function arguments IN
01575             UInt32                              hSession;               
01576             string                              EncryptedData;
01577             // Function arguments OUT               
01578             string                              ClearData;
01579 
01580 
01582             // Get parameter from DKMSProtocol Data Block                           //
01583             // Param: {UInt32 hSession, string EncryptedData, out string ClearData} // 
01585             /* get-set hSession */
01586             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01587             _smf.CurrentSession = hSession;
01588             /* get EncryptedData */
01589             EncryptedData = ((ProtocolManager.Param)config.body.param["EncryptedData"]).vvalue;
01590             
01591             // Send Command - Decrypt
01592             ret = _smf.df.Decrypt(EncryptedData, out ClearData);
01593 
01594             // Bad Result
01595             if(ret != ErrorManager.DKMS_OK)
01596             {
01597                 _pm.XMLTXParser_Set_Error(ret);             
01598             }
01599             // Good Result
01600             else
01601             {
01603                 // Fase 3 Build the responce                    
01604                 /* 1 */
01605                 _pm.XMLTXParser_Set_Start("DKMS_Decrypt", 2);
01606                 /* 2 */
01607                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01608                 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearData", ProtocolManager.PARAM_TYPE.STRING, ClearData);
01609                 /* 3 */
01610                 _pm.XMLTXParser_Set_End();              
01611             }
01612         }
01613 
01617         private void CS_CompactDecrypt()
01618         {
01619             UInt32 ret = ErrorManager.DKMS_OK;
01620             CryptoCore.CCConvert converter;
01621             // Function arguments IN
01622             UInt32 hSession;
01623             CryptoCore.Smf.MECHANISM mech;
01624             UInt32 hKey;
01625             string EncryptedData;
01626             // Function arguments OUT               
01627             string ClearData;
01628 
01629 
01630             // Initialization
01631             converter = new CryptoCore.CCConvert();
01632 
01634             // Get parameter from DKMSProtocol Data Block                  //
01635             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey,       // 
01636             // string EncryptedData, out string ClearData}                 // 
01638             /* get-set hSession */
01639             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01640             _smf.CurrentSession = hSession;
01641             /* get hKey */
01642             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01643             /* get EncryptedData */
01644             EncryptedData = ((ProtocolManager.Param)config.body.param["EncryptedData"]).vvalue;
01645             /* get mech */
01646             ret = converter.ParseMechanismIn(out mech, config);
01647 
01648             // Bad Result
01649             if (ret != ErrorManager.DKMS_OK)
01650             {
01651                 _pm.XMLTXParser_Set_Error(ret);
01652             }
01653             // Good Result
01654             else
01655             {
01656                 // Send Command - CompactDecrypt
01657                 ret = _smf.df.CompactDecrypt(mech, hKey, EncryptedData, out ClearData);
01658 
01659                 // Bad Result
01660                 if (ret != ErrorManager.DKMS_OK)
01661                 {
01662                     _pm.XMLTXParser_Set_Error(ret);
01663                 }
01664                 // Good Result
01665                 else
01666                 {                    
01668                     // Fase 3 Build the responce                    
01669                     /* 1 */
01670                     _pm.XMLTXParser_Set_Start("DKMS_CompactDecrypt", 2);
01671                     /* 2 */
01672                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01673                     _pm.XMLTXParser_Set_ParamAtomic(1, "ClearData", ProtocolManager.PARAM_TYPE.STRING, ClearData);
01674                     /* 3 */
01675                     _pm.XMLTXParser_Set_End();                    
01676                 }
01677             }
01678         }
01679                 
01684         private void CS_DecryptUpdate()
01685         {               
01686             UInt32                              ret = ErrorManager.DKMS_OK;         
01687             // Function arguments IN
01688             UInt32                              hSession;               
01689             string                              EncryptedPartData;
01690             // Function arguments OUT               
01691             string                              ClearPartData;
01692 
01693 
01695             // Get parameter from DKMSProtocol Data Block                                   //
01696             // Param: {UInt32 hSession, string EncryptedPartData, out string ClearPartData} // 
01698             /* get-set hSession */  
01699             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01700             _smf.CurrentSession = hSession;
01701             /* get EncryptedPartData */
01702             EncryptedPartData = ((ProtocolManager.Param)config.body.param["EncryptedPartData"]).vvalue;
01703             
01704             // Send Command - DecryptUpdate
01705             ret = _smf.df.DecryptUpdate(EncryptedPartData, out ClearPartData);
01706 
01707             // Bad Result
01708             if(ret != ErrorManager.DKMS_OK)
01709             {
01710                 _pm.XMLTXParser_Set_Error(ret);             
01711             }
01712             // Good Result
01713             else
01714             {
01716                 // Fase 3 Build the responce                    
01717                 /* 1 */
01718                 _pm.XMLTXParser_Set_Start("DKMS_DecryptUpdate", 2);
01719                 /* 2 */
01720                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01721                 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearPartData", ProtocolManager.PARAM_TYPE.STRING, ClearPartData);
01722                 /* 3 */
01723                 _pm.XMLTXParser_Set_End();          
01724             }
01725         }
01726             
01730         private void CS_DecryptFinal()
01731         {               
01732             UInt32                              ret = ErrorManager.DKMS_OK;             
01733             // Function arguments IN
01734             UInt32                              hSession;
01735             // Function arguments OUT
01736             string                              LastDecryptedPartData;
01737 
01738 
01740             // Get parameter from DKMSProtocol Data Block                  //
01741             // Param: {UInt32 hSession, out string LastDecryptedPartData}  // 
01743             /* get-set hSession */  
01744             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01745             _smf.CurrentSession = hSession;
01746             
01747             // Send Command - DecryptFinal
01748             ret = _smf.df.DecryptFinal(out LastDecryptedPartData);
01749 
01750             // Bad Result
01751             if(ret != ErrorManager.DKMS_OK)
01752             {
01753                 _pm.XMLTXParser_Set_Error(ret);             
01754             }
01755             // Good Result
01756             else
01757             {
01759                 // Fase 3 Build the responce                    
01760                 /* 1 */
01761                 _pm.XMLTXParser_Set_Start("DKMS_DecryptFinal", 2);
01762                 /* 2 */
01763                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01764                 _pm.XMLTXParser_Set_ParamAtomic(1, "LastDecryptedPartData", ProtocolManager.PARAM_TYPE.STRING, LastDecryptedPartData);
01765                 /* 3 */
01766                 _pm.XMLTXParser_Set_End();      
01767             }
01768         }
01769 
01773         private void CS_GetInfo()
01774         {               
01775             UInt32                              ret = ErrorManager.DKMS_OK;                     
01776             // Function arguments OUT
01777             CryptoCore.CK_INFO                  pInfo;
01778             
01779 
01780             // Send Command - GetInfo
01781             ret = _cc.GetInfo(out pInfo);
01782 
01783             // Bad Result
01784             if(ret != ErrorManager.DKMS_OK)
01785             {
01786                 _pm.XMLTXParser_Set_Error(ret);             
01787             }
01788             // Good Result
01789             else
01790             {
01792                 // Fase 3 Build the responce                    
01793                 /* 1 */
01794                 _pm.XMLTXParser_Set_Start("DKMS_GetInfo", 2);
01795                 /* 2 */
01796                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01797                 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
01798                 _pm.XMLTXParser_Set_StartParamStruct(0, "pInfo.cryptokiVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01799                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.cryptokiVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.cryptokiVersion.major.ToString());
01800                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.cryptokiVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.cryptokiVersion.minor.ToString());
01801                 _pm.XMLTXParser_Set_EndParamStruct();
01802                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.manufacturerID", ProtocolManager.PARAM_TYPE.STRING, pInfo.manufacturerID);
01803                 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
01804                 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.libraryDescription", ProtocolManager.PARAM_TYPE.STRING, pInfo.libraryDescription);
01805                 _pm.XMLTXParser_Set_StartParamStruct(4, "pInfo.libraryVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01806                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.libraryVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.libraryVersion.major.ToString());
01807                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.libraryVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.libraryVersion.minor.ToString());
01808                 _pm.XMLTXParser_Set_EndParamStruct();
01809                 _pm.XMLTXParser_Set_EndParamStruct();
01810                 /* 3 */
01811                 _pm.XMLTXParser_Set_End();              
01812             }           
01813         }
01814             
01818         private void CS_GetTokenInfo()
01819         {               
01820             UInt32                              ret = ErrorManager.DKMS_OK;         
01821             // Function arguments IN
01822             UInt32                              slotID;
01823             // Function arguments OUT
01824             CryptoCore.Stmf.CK_TOKEN_INFO       pInfo;
01825 
01826 
01828             // Get parameter from DKMSProtocol Data Block                       //
01829             // Param: {UInt32 hSession, UInt32 slotID, out CK_TOKEN_INFO pInfo} // 
01831             slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
01832             
01833             // Send Command - GetTokenInfo                
01834             ret =  _stmf.GetTokenInfo(slotID, out pInfo);
01835 
01836             // Bad Result
01837             if(ret != ErrorManager.DKMS_OK)
01838             {
01839                 _pm.XMLTXParser_Set_Error(ret);             
01840             }
01841             // Good Result
01842             else
01843             {
01845                 // Fase 3 Build the responce                    
01846                 /* 1 */
01847                 _pm.XMLTXParser_Set_Start("DKMS_GetTokenInfo", 2);
01848                 /* 2 */
01849                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01850                 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
01851                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.label", ProtocolManager.PARAM_TYPE.STRING, pInfo.label);
01852                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.manufacturerID", ProtocolManager.PARAM_TYPE.STRING, pInfo.manufacturerID);
01853                 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.model", ProtocolManager.PARAM_TYPE.STRING, pInfo.model);
01854                 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.serialNumber", ProtocolManager.PARAM_TYPE.STRING, pInfo.serialNumber);
01855                 _pm.XMLTXParser_Set_ParamAtomic(4, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
01856                 _pm.XMLTXParser_Set_ParamAtomic(5, "pInfo.ulMaxSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxSessionCount.ToString());
01857                 _pm.XMLTXParser_Set_ParamAtomic(6, "pInfo.ulSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulSessionCount.ToString());
01858                 _pm.XMLTXParser_Set_ParamAtomic(7, "pInfo.ulMaxRwSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxRwSessionCount.ToString());
01859                 _pm.XMLTXParser_Set_ParamAtomic(8, "pInfo.ulRwSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulRwSessionCount.ToString());
01860                 _pm.XMLTXParser_Set_ParamAtomic(9, "pInfo.ulMaxPinLen", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxPinLen.ToString());
01861                 _pm.XMLTXParser_Set_ParamAtomic(10, "pInfo.ulMinPinLen", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMinPinLen.ToString());
01862                 _pm.XMLTXParser_Set_ParamAtomic(11, "pInfo.ulTotalPublicMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulTotalPublicMemory.ToString());
01863                 _pm.XMLTXParser_Set_ParamAtomic(12, "pInfo.ulFreePublicMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulFreePublicMemory.ToString());
01864                 _pm.XMLTXParser_Set_ParamAtomic(13, "pInfo.ulTotalPrivateMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulTotalPrivateMemory.ToString());
01865                 _pm.XMLTXParser_Set_ParamAtomic(14, "pInfo.ulFreePrivateMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulFreePrivateMemory.ToString());
01866                 _pm.XMLTXParser_Set_StartParamStruct(15, "pInfo.hardwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01867                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.hardwareVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.hardwareVersion.major.ToString());
01868                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.hardwareVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.hardwareVersion.minor.ToString());
01869                 _pm.XMLTXParser_Set_EndParamStruct();
01870                 _pm.XMLTXParser_Set_StartParamStruct(16, "pInfo.firmwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01871                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.firmwareVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.firmwareVersion.major.ToString());
01872                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.firmwareVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.firmwareVersion.minor.ToString());
01873                 _pm.XMLTXParser_Set_EndParamStruct();
01874                 _pm.XMLTXParser_Set_ParamAtomic(17, "pInfo.utcTime", ProtocolManager.PARAM_TYPE.STRING, pInfo.utcTime);
01875                 _pm.XMLTXParser_Set_EndParamStruct();
01876                 /* 3 */
01877                 _pm.XMLTXParser_Set_End();
01878             }           
01879         }
01880 
01885         private void CS_SeedRandom()
01886         {               
01887             UInt32                              ret = ErrorManager.DKMS_OK;         
01888             // Function arguments IN
01889             UInt32                              hSession;
01890             string                              Seed;
01891 
01892 
01894             // Get parameter from DKMSProtocol Data Block                  //
01895             // Param: {UInt32 hSession, string Seed}                       // 
01897             /* get-set hSession */  
01898             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01899             _smf.CurrentSession = hSession;
01900             /* get Seed */
01901             Seed = ((ProtocolManager.Param)config.body.param["Seed"]).vvalue;           
01902 
01903             // Send Command - SeedRandom
01904             ret = _smf.rngf.SeedRandom(Seed);
01905 
01906             // Bad Result
01907             if (ret != ErrorManager.DKMS_OK)
01908             {
01909                 _pm.XMLTXParser_Set_Error(ret);             
01910             }
01911             // Good Result
01912             else
01913             {
01915                 // Fase 3 Build the responce                    
01916                 /* 1 */
01917                 _pm.XMLTXParser_Set_Start("DKMS_SeedRandom", 1);
01918                 /* 2 */
01919                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01920                 /* 3 */
01921                 _pm.XMLTXParser_Set_End();
01922             }
01923         }
01924 
01928         private void CS_GenerateRandom()
01929         {               
01930             UInt32                              ret = ErrorManager.DKMS_OK;         
01931             // Function arguments IN
01932             UInt32                              hSession;
01933             UInt32                              ulRandomLen;
01934             // Function arguments OUT
01935             string                              RandomData;
01936 
01937 
01939             // Get parameter from DKMSProtocol Data Block                           //
01940             // Param: {UInt32 hSession, out string RandomData, UInt32 ulRandomLen}  // 
01942             /* get-set hSession */  
01943             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01944             _smf.CurrentSession = hSession;
01945             /* get ulRandomLen */
01946             ulRandomLen = UInt32.Parse(((ProtocolManager.Param)config.body.param["ulRandomLen"]).vvalue);
01947             
01948             // Send Command - GenerateRandom
01949             ret = _smf.rngf.GenerateRandom(out RandomData, ulRandomLen);
01950 
01951             // Bad Result
01952             if (ret != ErrorManager.DKMS_OK)
01953             {
01954                 _pm.XMLTXParser_Set_Error(ret);             
01955             }
01956             // Good Result
01957             else
01958             {
01960                 // Fase 3 Build the responce                    
01961                 /* 1 */
01962                 _pm.XMLTXParser_Set_Start("DKMS_GenerateRandom", 2);
01963                 /* 2 */
01964                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01965                 _pm.XMLTXParser_Set_ParamAtomic(1, "RandomData", ProtocolManager.PARAM_TYPE.STRING, RandomData);
01966                 /* 3 */
01967                 _pm.XMLTXParser_Set_End();
01968             }
01969         }
01970 
01975         private void CS_CompactGenerateRandom()
01976         {
01977             UInt32                              ret = ErrorManager.DKMS_OK;
01978             // Function arguments IN
01979             UInt32                              hSession;
01980             string                              Seed;
01981             UInt32                              ulRandomLen;
01982             // Function arguments OUT
01983             string                              RandomData;
01984 
01985 
01987             // Get parameter from DKMSProtocol Data Block                  //
01988             // Param: {UInt32 hSession, string Seed,                       // 
01989             // out string RandomData, UInt32 ulRandomLen}                  // 
01991             /* get-set hSession */
01992             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01993             _smf.CurrentSession = hSession;
01994             /* get ulRandomLen */
01995             ulRandomLen = UInt32.Parse(((ProtocolManager.Param)config.body.param["ulRandomLen"]).vvalue);
01996             /* get Seed */
01997             Seed = ((ProtocolManager.Param)config.body.param["Seed"]).vvalue;
01998 
01999             // Send Command - CompactGenerateRandom
02000             ret = _smf.rngf.CompactGenerateRandom(Seed, out RandomData, ulRandomLen);
02001 
02002             // Bad Result
02003             if (ret != ErrorManager.DKMS_OK)
02004             {
02005                 _pm.XMLTXParser_Set_Error(ret);
02006             }
02007             // Good Result
02008             else
02009             {                
02011                 // Fase 3 Build the responce                    
02012                 /* 1 */
02013                 _pm.XMLTXParser_Set_Start("DKMS_CompactGenerateRandom", 2);
02014                 /* 2 */
02015                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02016                 _pm.XMLTXParser_Set_ParamAtomic(1, "RandomData", ProtocolManager.PARAM_TYPE.STRING, RandomData);
02017                 /* 3 */
02018                 _pm.XMLTXParser_Set_End();                
02019             }
02020         }
02021 
02025         private void CS_GenerateKey()
02026         {                
02027             UInt32                              ret = ErrorManager.DKMS_OK;
02028             CryptoCore.CCConvert                converter;
02029             UInt32                              ulCount;
02030             // Function arguments IN
02031             UInt32                              hSession;
02032             CryptoCore.ATTRIBUTE_VALUE          templ;
02033             CryptoCore.Smf.MECHANISM            mech;
02034             // Function arguments OUT               
02035             UInt32                              phKey;
02036 
02037 
02038             // Initialization
02039             converter = new CryptoCore.CCConvert();
02040 
02042             // Get parameter from DKMSProtocol Data Block                                    //
02043             // Param: {UInt32 hSession, CryptoCore.ATTRIBUTE_VALUE templ, MECHANISM mech,    //
02044             // out UInt32 phKey}                                                             // 
02046             /* get-set hSession */  
02047             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02048             _smf.CurrentSession = hSession;
02049             /* get templ */ 
02050             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;         
02051             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
02052             
02053             // Bad Result
02054             if(ret != ErrorManager.DKMS_OK)
02055             {
02056                 _pm.XMLTXParser_Set_Error(ret);             
02057             }
02058             // Good Result
02059             else
02060             {           
02061                 /* get mech */
02062                 ret = converter.ParseMechanismIn(out mech, config);
02063 
02064                 // Bad Result
02065                 if (ret != ErrorManager.DKMS_OK)
02066                 {
02067                     _pm.XMLTXParser_Set_Error(ret);             
02068                 }
02069                 // Good Result
02070                 else
02071                 {
02072                     // Send Command - GenerateKey
02073                     ret = _smf.kmf.GenerateKey(templ, mech, out phKey);
02074 
02075                     // Bad Result
02076                     if (ret != ErrorManager.DKMS_OK)
02077                     {
02078                         _pm.XMLTXParser_Set_Error(ret);                 
02079                     }
02080                     // Good Result
02081                     else
02082                     {
02084                         // Fase 3 Build the responce                    
02085                         /* 1 */
02086                         _pm.XMLTXParser_Set_Start("DKMS_GenerateKey", 2);
02087                         /* 2 */
02088                         _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02089                         _pm.XMLTXParser_Set_ParamAtomic(1, "phKey", ProtocolManager.PARAM_TYPE.UINT32, phKey.ToString());
02090                         /* 3 */
02091                         _pm.XMLTXParser_Set_End();
02092                     }
02093                 }
02094             }
02095         }
02096 
02100         private void CS_DestroyObject()
02101         {                
02102             UInt32                              ret = ErrorManager.DKMS_OK;         
02103             // Function arguments IN
02104             UInt32                              hSession; 
02105             UInt32                              hObject;
02106 
02107 
02109             // Get parameter from DKMSProtocol Data Block                  //
02110             // Param: {UInt32 hSession, UInt32 hObject}                    // 
02112             /* get-set hSession */
02113             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02114             _smf.CurrentSession = hSession;
02115             /* get hObject */
02116             hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
02117 
02118             // Send Command - DestroyObject
02119             ret = _smf.omf.DestroyObject(hObject);
02120 
02121             // Bad Result
02122             if (ret != ErrorManager.DKMS_OK)
02123             {
02124                 _pm.XMLTXParser_Set_Error(ret);             
02125             }
02126             // Good Result
02127             else
02128             {
02130                 // Fase 3 Build the responce
02131                 /* 1 */
02132                 _pm.XMLTXParser_Set_Start("DKMS_DestroyObject", 1);
02133                 /* 2 */
02134                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02135                 /* 3 */
02136                 _pm.XMLTXParser_Set_End();
02137             }
02138         }
02139 
02143         private void CS_GetMechanismList()
02144         {                
02145             UInt32                              ret = ErrorManager.DKMS_OK;         
02146             // Function arguments IN                
02147             UInt32                              slotID;
02148             // Function arguments OUT               
02149             Int32[]                             MechanismList;
02150 
02151 
02153             // Get parameter from DKMSProtocol Data Block                //
02154             // Param: {UInt32 slotID, out Int32[] MechanismList}         // 
02156             /* get slotID */ 
02157             slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
02158 
02159             // Send Command - GetMechanismList                
02160             ret = _stmf.GetMechanismList(slotID, out MechanismList);
02161 
02162             // Bad Result
02163             if (ret != ErrorManager.DKMS_OK)
02164             {
02165                 _pm.XMLTXParser_Set_Error(ret);             
02166             }
02167             // Good Result
02168             else
02169             {
02171                 // Fase 3 Build the responce                    
02172                 /* 1 */
02173                 _pm.XMLTXParser_Set_Start("DKMS_GetMechanismList", 2);
02174                 /* 2 */
02175                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02176                 _pm.XMLTXParser_Set_StartParamArray(1, "MechanismList", ProtocolManager.PARAM_TYPE.INT32, (UInt32)MechanismList.Length, 0);
02177                 for (int i = 0; i < MechanismList.Length; i++)
02178                     _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "MechanismList[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.INT32, MechanismList[i].ToString());
02179                 _pm.XMLTXParser_Set_EndParamArray();
02180                 /* 3 */
02181                 _pm.XMLTXParser_Set_End();
02182             }
02183         }
02184 
02188         private void CS_GetAttributeValue()
02189         {                
02190             UInt32                              ret = ErrorManager.DKMS_OK;
02191             CryptoCore.CCConvert                converter;
02192             UInt32                              ulCount;
02193             // function arguments in
02194             UInt32                              hSession;
02195             UInt32                              hObject;                            
02196             CryptoCore.CK_ATTRIBUTE_TYPE[]      atype;
02197             // function arguments out
02198             CryptoCore.ATTRIBUTE_VALUE          templ;
02199 
02200 
02201             // Initialization
02202             converter = new CryptoCore.CCConvert();
02203 
02205             // Get parameter from DKMSProtocol Data Block                                       //
02206             // Param: {UInt32 hSession, CK_ATTRIBUTE_TYPE[] atype, out ATTRIBUTE_VALUE templ,   //
02207             // UInt32 hObject}                                                                  // 
02209             /* get-set hSession */  
02210             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02211             _smf.CurrentSession = hSession;
02212             /* get att_type */
02213             ulCount = ((ProtocolManager.Param)config.body.param["atype"]).XDim;
02214             atype = new CryptoCore.CK_ATTRIBUTE_TYPE[ulCount];
02215             for (int i = 0; i < ulCount; i++)
02216                 atype[i] = (CryptoCore.CK_ATTRIBUTE_TYPE)int.Parse(((ProtocolManager.Param)config.body.param["atype[" + i.ToString() + "]"]).vvalue);
02217             /* get hObject */
02218             hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
02219                         
02220             // Send Command - GetAttributeValue         
02221             ret = _smf.omf.GetAttributeValue(atype, out templ, hObject);
02222 
02223             // Bad Result
02224             if (ret != ErrorManager.DKMS_OK)
02225             {
02226                 _pm.XMLTXParser_Set_Error(ret);         
02227             }
02228             // Good Result
02229             else
02230             {
02232                 // Fase 3 Build the responce
02233                 /* 1 */
02234                 _pm.XMLTXParser_Set_Start("DKMS_GetAttributeValue", 2);
02235                 /* 2 */
02236                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02237                 // parsing CSM templ            
02238                 ret = converter.ParseAttributeOut(templ, ref _pm, converter.AttributeCount(templ), 1, "templ"); 
02239                 if (ret != ErrorManager.DKMS_OK)
02240                     throw new Exception();                      
02241                 /* 3 */
02242                 _pm.XMLTXParser_Set_End();
02243             }
02244         }
02245 
02249         private void CS_DigestInit()
02250         {               
02251             UInt32                              ret = ErrorManager.DKMS_OK;
02252             CryptoCore.CCConvert                converter;      
02253             // Function arguments IN
02254             UInt32                              hSession;           
02255             CryptoCore.Smf.MECHANISM            mech;
02256 
02257 
02258             // Initialization
02259             converter = new CryptoCore.CCConvert();
02260 
02262             // Get parameter from DKMSProtocol Data Block                  //
02263             // Param: {UInt32 hSession, MECHANISM mech}                    // 
02265             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02266             _smf.CurrentSession = hSession;         
02267             /* get mech */
02268             ret = converter.ParseMechanismIn(out mech, config);
02269             
02270             // Bad Result
02271             if(ret != ErrorManager.DKMS_OK)
02272             {
02273                 _pm.XMLTXParser_Set_Error(ret);             
02274             }
02275             // Good Result
02276             else
02277             {
02278                 // Send Command - DigestInit
02279                 ret = _smf.mdf.DigestInit(mech);
02280 
02281                 // Bad Result
02282                 if(ret != ErrorManager.DKMS_OK)
02283                 {
02284                     _pm.XMLTXParser_Set_Error(ret);                 
02285                 }
02286                 // Good Result
02287                 else
02288                 {
02290                     // Fase 3 Build the responce                    
02291                     /* 1 */
02292                     _pm.XMLTXParser_Set_Start("DKMS_DigestInit", 1);
02293                     /* 2 */
02294                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02295                     /* 3 */
02296                     _pm.XMLTXParser_Set_End();
02297                 }
02298             }
02299         }
02300 
02304         private void CS_Digest()
02305         {               
02306             UInt32                              ret = ErrorManager.DKMS_OK;         
02307             // Function arguments IN
02308             UInt32                              hSession;               
02309             string                              Data;
02310             // Function arguments OUT               
02311             string                              Digest;
02312 
02313 
02315             // Get parameter from DKMSProtocol Data Block                           //
02316             // Param: {UInt32 hSession, string Data, out string Digest}             // 
02318             /* get-set hSession */
02319             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02320             _smf.CurrentSession = hSession;
02321             /* get Data */
02322             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02323             
02324             // Send Command - Digest
02325             ret = _smf.mdf.Digest(Data, out Digest);
02326 
02327             // Bad Result
02328             if(ret != ErrorManager.DKMS_OK)
02329             {
02330                 _pm.XMLTXParser_Set_Error(ret);             
02331             }
02332             // Good Result
02333             else
02334             {
02336                 // Fase 3 Build the responce
02337                 /* 1 */
02338                 _pm.XMLTXParser_Set_Start("DKMS_Digest", 2);
02339                 /* 2 */
02340                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02341                 _pm.XMLTXParser_Set_ParamAtomic(1, "Digest", ProtocolManager.PARAM_TYPE.STRING, Digest);
02342                 /* 3 */
02343                 _pm.XMLTXParser_Set_End();
02344             }
02345         }
02346 
02350         private void CS_CompactDigest()
02351         {
02352             UInt32                              ret = ErrorManager.DKMS_OK;
02353             CryptoCore.CCConvert                converter;
02354             // Function arguments IN
02355             UInt32                              hSession;
02356             CryptoCore.Smf.MECHANISM            mech;
02357             string                              Data;
02358             // Function arguments OUT               
02359             string                              Digest;
02360 
02361 
02362             // Initialization
02363             converter = new CryptoCore.CCConvert();
02364 
02366             // Get parameter from DKMSProtocol Data Block                  //
02367             // Param: {UInt32 hSession, MECHANISM mech,                    // 
02368             // string Data, out string Digest}                             // 
02370             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02371             _smf.CurrentSession = hSession;
02372             /* get Data */
02373             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02374             /* get mech */
02375             ret = converter.ParseMechanismIn(out mech, config);            
02376 
02377             // Bad Result
02378             if (ret != ErrorManager.DKMS_OK)
02379             {
02380                 _pm.XMLTXParser_Set_Error(ret);
02381             }
02382             // Good Result
02383             else
02384             {
02385                 // Send Command - CompactDigest
02386                 ret = _smf.mdf.CompactDigest(mech, Data, out Digest);
02387 
02388                 // Bad Result
02389                 if (ret != ErrorManager.DKMS_OK)
02390                 {
02391                     _pm.XMLTXParser_Set_Error(ret);
02392                 }
02393                 // Good Result
02394                 else
02395                 {                   
02397                     // Fase 3 Build the responce
02398                     /* 1 */
02399                     _pm.XMLTXParser_Set_Start("DKMS_CompactDigest", 2);
02400                     /* 2 */
02401                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02402                     _pm.XMLTXParser_Set_ParamAtomic(1, "Digest", ProtocolManager.PARAM_TYPE.STRING, Digest);
02403                     /* 3 */
02404                     _pm.XMLTXParser_Set_End();                    
02405                 }
02406             }
02407         }
02408 
02413         private void CS_DigestUpdate()
02414         {               
02415             UInt32                              ret = ErrorManager.DKMS_OK;         
02416             // Function arguments IN
02417             UInt32                              hSession;               
02418             string                              PartData;           
02419 
02420 
02422             // Get parameter from DKMSProtocol Data Block                                   //
02423             // Param: {UInt32 hSession, string PartData}                                    // 
02425             /* get-set hSession */
02426             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02427             _smf.CurrentSession = hSession;
02428             /* get PartData */
02429             PartData = ((ProtocolManager.Param)config.body.param["PartData"]).vvalue;
02430             
02431             // Send Command - DigestUpdate
02432             ret = _smf.mdf.DigestUpdate(PartData);
02433 
02434             // Bad Result
02435             if(ret != ErrorManager.DKMS_OK)
02436             {
02437                 _pm.XMLTXParser_Set_Error(ret);             
02438             }
02439             // Good Result
02440             else
02441             {
02443                 // Fase 3 Build the responce
02444                 /* 1 */
02445                 _pm.XMLTXParser_Set_Start("DKMS_DigestUpdate", 1);
02446                 /* 2 */
02447                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
02448                 /* 3 */
02449                 _pm.XMLTXParser_Set_End();
02450             }
02451         }
02452         
02457         private void CS_DigestKey()
02458         {               
02459             UInt32                              ret = ErrorManager.DKMS_OK;                 
02460             // Function arguments IN
02461             UInt32                              hSession;               
02462             UInt32                              hKey;           
02463 
02464 
02466             // Get parameter from DKMSProtocol Data Block                  //
02467             // Param: {UInt32 hSession, UInt32 hKey}                       // 
02469             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02470             _smf.CurrentSession = hSession;
02471             /* get hKey */ 
02472             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02473                         
02474             // Send Command - DigestKey
02475             ret = _smf.mdf.DigestKey(hKey);
02476 
02477             // Bad Result
02478             if(ret != ErrorManager.DKMS_OK)
02479             {
02480                 _pm.XMLTXParser_Set_Error(ret);                 
02481             }
02482             // Good Result
02483             else
02484             {
02486                 // Fase 3 Build the responce                    
02487                 /* 1 */
02488                 _pm.XMLTXParser_Set_Start("DKMS_DigestKey", 1);
02489                 /* 2 */
02490                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02491                 /* 3 */
02492                 _pm.XMLTXParser_Set_End();
02493             }           
02494         }
02495 
02500         private void CS_DigestFinal()
02501         {               
02502             UInt32                              ret = ErrorManager.DKMS_OK;         
02503             // Function arguments IN
02504             UInt32                              hSession;
02505             // Function arguments OUT
02506             string                              Digest;
02507 
02508 
02510             // Get parameter from DKMSProtocol Data Block                  //
02511             // Param: {UInt32 hSession, out string Digest}                 // 
02513             /* get-set hSession */
02514             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02515             _smf.CurrentSession = hSession;
02516             
02517             // Send Command - DigestFinal
02518             ret = _smf.mdf.DigestFinal(out Digest);
02519 
02520             // Bad Result
02521             if(ret != ErrorManager.DKMS_OK)
02522             {
02523                 _pm.XMLTXParser_Set_Error(ret);             
02524             }
02525             // Good Result
02526             else
02527             {
02529                 // Fase 3 Build the responce                    
02530                 /* 1 */
02531                 _pm.XMLTXParser_Set_Start("DKMS_DigestFinal", 2);
02532                 /* 2 */
02533                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02534                 _pm.XMLTXParser_Set_ParamAtomic(1, "Digest", ProtocolManager.PARAM_TYPE.STRING, Digest);
02535                 /* 3 */
02536                 _pm.XMLTXParser_Set_End();              
02537             }
02538         }
02539 
02544         private void CS_SignInit()
02545         {               
02546             UInt32                              ret = ErrorManager.DKMS_OK;
02547             CryptoCore.CCConvert                converter;      
02548             // Function arguments IN
02549             UInt32                              hSession;           
02550             CryptoCore.Smf.MECHANISM            mech;
02551             UInt32                              hKey;
02552 
02553             
02554             // Initialization
02555             converter = new CryptoCore.CCConvert();
02556 
02558             // Get parameter from DKMSProtocol Data Block                  //
02559             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey}       // 
02561             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02562             _smf.CurrentSession = hSession;
02563             /* get hKey */
02564             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02565             /* get mech */
02566             ret = converter.ParseMechanismIn(out mech, config);
02567                         
02568             // Bad Result
02569             if(ret != ErrorManager.DKMS_OK)
02570             {
02571                 _pm.XMLTXParser_Set_Error(ret);             
02572             }
02573             // Good Result
02574             else
02575             {
02576                 // Send Command - SignInit
02577                 ret = _smf.smacf.SignInit(mech, hKey);
02578 
02579                 // Bad Result
02580                 if(ret != ErrorManager.DKMS_OK)
02581                 {
02582                     _pm.XMLTXParser_Set_Error(ret);                 
02583                 }
02584                 // Good Result
02585                 else
02586                 {
02588                     // Fase 3 Build the responce                    
02589                     /* 1 */
02590                     _pm.XMLTXParser_Set_Start("DKMS_SignInit", 1);
02591                     /* 2 */
02592                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02593                     /* 3 */
02594                     _pm.XMLTXParser_Set_End();
02595                 }
02596             }
02597         }
02598 
02603         private void CS_Sign()
02604         {               
02605             UInt32                              ret = ErrorManager.DKMS_OK;         
02606             // Function arguments IN
02607             UInt32                              hSession;               
02608             string                              Data;
02609             // Function arguments OUT               
02610             string                              Signature;
02611 
02612 
02614             // Get parameter from DKMSProtocol Data Block                           //
02615             // Param: {UInt32 hSession, string Data, out string Signature}          // 
02617             /* get-set hSession */
02618             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02619             _smf.CurrentSession = hSession;
02620             /* get Data */
02621             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02622             
02623             // Send Command - Sign
02624             ret = _smf.smacf.Sign(Data, out Signature);
02625 
02626             // Bad Result
02627             if(ret != ErrorManager.DKMS_OK)
02628             {
02629                 _pm.XMLTXParser_Set_Error(ret);             
02630             }
02631             // Good Result
02632             else
02633             {
02635                 // Fase 3 Build the responce
02636                 /* 1 */
02637                 _pm.XMLTXParser_Set_Start("DKMS_Sign", 2);
02638                 /* 2 */
02639                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02640                 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02641                 /* 3 */
02642                 _pm.XMLTXParser_Set_End();
02643             }
02644         }
02645 
02650         private void CS_CompactSign()
02651         {
02652             UInt32                              ret = ErrorManager.DKMS_OK;
02653             CryptoCore.CCConvert                converter;
02654             // Function arguments IN
02655             UInt32                              hSession;
02656             CryptoCore.Smf.MECHANISM            mech;
02657             UInt32                              hKey;
02658             string                              Data;
02659             // Function arguments OUT               
02660             string                              Signature;
02661 
02662 
02663             // Initialization
02664             converter = new CryptoCore.CCConvert();
02665 
02667             // Get parameter from DKMSProtocol Data Block                  //
02668             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey,       //  
02669             // string Data, out string Signature}                          // 
02671             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02672             _smf.CurrentSession = hSession;
02673             /* get Data */
02674             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02675             /* get hKey */
02676             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02677             /* get mech */
02678             ret = converter.ParseMechanismIn(out mech, config);
02679             
02680             // Bad Result
02681             if (ret != ErrorManager.DKMS_OK)
02682             {
02683                 _pm.XMLTXParser_Set_Error(ret);
02684             }
02685             // Good Result
02686             else
02687             {
02688                 // Send Command - CompactSign
02689                 ret = _smf.smacf.CompactSign(mech, hKey, Data, out Signature);
02690 
02691                 // Bad Result
02692                 if (ret != ErrorManager.DKMS_OK)
02693                 {
02694                     _pm.XMLTXParser_Set_Error(ret);
02695                 }
02696                 // Good Result
02697                 else
02698                 {                    
02700                     // Fase 3 Build the responce
02701                     /* 1 */
02702                     _pm.XMLTXParser_Set_Start("DKMS_CompactSign", 2);
02703                     /* 2 */
02704                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02705                     _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02706                     /* 3 */
02707                     _pm.XMLTXParser_Set_End();                 
02708                 }
02709             }
02710         }
02711 
02716         private void CS_SignUpdate()
02717         {               
02718             UInt32                              ret = ErrorManager.DKMS_OK;         
02719             // Function arguments IN
02720             UInt32                              hSession;               
02721             string                              PartData;           
02722 
02723 
02725             // Get parameter from DKMSProtocol Data Block                                   //
02726             // Param: {UInt32 hSession, string PartData}                                    // 
02728             /* get-set hSession */
02729             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02730             _smf.CurrentSession = hSession;
02731             /* get PartData */
02732             PartData = ((ProtocolManager.Param)config.body.param["PartData"]).vvalue;
02733             
02734             // Send Command - SignUpdate
02735             ret = _smf.smacf.SignUpdate(PartData);
02736 
02737             // Bad Result
02738             if(ret != ErrorManager.DKMS_OK)
02739             {
02740                 _pm.XMLTXParser_Set_Error(ret);             
02741             }
02742             // Good Result
02743             else
02744             {
02746                 // Fase 3 Build the responce
02747                 /* 1 */
02748                 _pm.XMLTXParser_Set_Start("DKMS_SignUpdate", 1);
02749                 /* 2 */
02750                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
02751                 /* 3 */
02752                 _pm.XMLTXParser_Set_End();
02753             }
02754         }
02755 
02760         private void CS_SignFinal()
02761         {               
02762             UInt32                              ret = ErrorManager.DKMS_OK;         
02763             // Function arguments IN
02764             UInt32                              hSession;
02765             // Function arguments OUT
02766             string                              Signature;
02767 
02768 
02770             // Get parameter from DKMSProtocol Data Block                  //
02771             // Param: {UInt32 hSession, out string Signature}              // 
02773             /* get-set hSession */
02774             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02775             _smf.CurrentSession = hSession;
02776             
02777             // Send Command - SignFinal
02778             ret = _smf.smacf.SignFinal(out Signature);
02779 
02780             // Bad Result
02781             if(ret != ErrorManager.DKMS_OK)
02782             {
02783                 _pm.XMLTXParser_Set_Error(ret);             
02784             }
02785             // Good Result
02786             else
02787             {
02789                 // Fase 3 Build the responce                    
02790                 /* 1 */
02791                 _pm.XMLTXParser_Set_Start("DKMS_SignFinal", 2);
02792                 /* 2 */
02793                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02794                 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02795                 /* 3 */
02796                 _pm.XMLTXParser_Set_End();              
02797             }
02798         }
02799 
02804         private void CS_SignRecoverInit()
02805         {               
02806             UInt32                              ret = ErrorManager.DKMS_OK;
02807             CryptoCore.CCConvert                converter;      
02808             // Function arguments IN
02809             UInt32                              hSession;           
02810             CryptoCore.Smf.MECHANISM            mech;
02811             UInt32                              hKey;
02812 
02813 
02814             // Initialization
02815             converter = new CryptoCore.CCConvert();
02816 
02818             // Get parameter from DKMSProtocol Data Block                  //
02819             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey}       // 
02821             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02822             _smf.CurrentSession = hSession;
02823             /* get hKey */
02824             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02825             /* get mech */
02826             ret = converter.ParseMechanismIn(out mech, config);         
02827             
02828             // Bad Result
02829             if(ret != ErrorManager.DKMS_OK)
02830             {
02831                 _pm.XMLTXParser_Set_Error(ret);             
02832             }
02833             // Good Result
02834             else
02835             {
02836                 // Send Command - SignRecoverInit
02837                 ret = _smf.smacf.SignRecoverInit(mech, hKey);
02838 
02839                 // Bad Result
02840                 if(ret != ErrorManager.DKMS_OK)
02841                 {
02842                     _pm.XMLTXParser_Set_Error(ret);                 
02843                 }
02844                 // Good Result
02845                 else
02846                 {
02848                     // Fase 3 Build the responce                    
02849                     /* 1 */
02850                     _pm.XMLTXParser_Set_Start("DKMS_SignRecoverInit", 1);
02851                     /* 2 */
02852                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02853                     /* 3 */
02854                     _pm.XMLTXParser_Set_End();
02855                 }
02856             }
02857         }
02858 
02863         private void CS_SignRecover()
02864         {               
02865             UInt32                              ret = ErrorManager.DKMS_OK;         
02866             // Function arguments IN
02867             UInt32                              hSession;
02868             string                              Data;
02869             // Function arguments OUT
02870             string                              Signature;
02871 
02872 
02874             // Get parameter from DKMSProtocol Data Block                  //
02875             // Param: {UInt32 hSession, string Data, out string Signature} // 
02877             /* get-set hSession */
02878             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);         
02879             _smf.CurrentSession = hSession;
02880             /* get Data */
02881             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02882             
02883             // Send Command - SignRecover
02884             ret = _smf.smacf.SignRecover(Data, out Signature);
02885 
02886             // Bad Result
02887             if(ret != ErrorManager.DKMS_OK)
02888             {
02889                 _pm.XMLTXParser_Set_Error(ret);             
02890             }
02891             // Good Result
02892             else
02893             {
02895                 // Fase 3 Build the responce                    
02896                 /* 1 */
02897                 _pm.XMLTXParser_Set_Start("DKMS_SignRecover", 2);
02898                 /* 2 */
02899                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02900                 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02901                 /* 3 */
02902                 _pm.XMLTXParser_Set_End();              
02903             }
02904         }
02905 
02910         private void CS_CompactSignRecover()
02911         {
02912             UInt32                              ret = ErrorManager.DKMS_OK;
02913             CryptoCore.CCConvert                converter;
02914             // Function arguments IN
02915             UInt32                              hSession;
02916             CryptoCore.Smf.MECHANISM            mech;
02917             UInt32                              hKey;
02918             string                              Data;
02919             // Function arguments OUT
02920             string                              Signature;
02921 
02922 
02923             // Initialization
02924             converter = new CryptoCore.CCConvert();
02925 
02927             // Get parameter from DKMSProtocol Data Block                  //
02928             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey,       // 
02929             // string Data, out string Signature}                          // 
02931             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02932             _smf.CurrentSession = hSession;
02933             /* get Data */
02934             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02935             /* get hKey */
02936             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02937             /* get mech */
02938             ret = converter.ParseMechanismIn(out mech, config);            
02939 
02940             // Bad Result
02941             if (ret != ErrorManager.DKMS_OK)
02942             {
02943                 _pm.XMLTXParser_Set_Error(ret);
02944             }
02945             // Good Result
02946             else
02947             {
02948                 // Send Command - CompactSignRecover
02949                 ret = _smf.smacf.CompactSignRecover(mech, hKey, Data, out Signature);
02950 
02951                 // Bad Result
02952                 if (ret != ErrorManager.DKMS_OK)
02953                 {
02954                     _pm.XMLTXParser_Set_Error(ret);
02955                 }
02956                 // Good Result
02957                 else
02958                 {                    
02960                     // Fase 3 Build the responce                    
02961                     /* 1 */
02962                     _pm.XMLTXParser_Set_Start("DKMS_CompactSignRecover", 2);
02963                     /* 2 */
02964                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02965                     _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02966                     /* 3 */
02967                     _pm.XMLTXParser_Set_End();                   
02968                 }
02969             }
02970         }
02971 
02976         private void CS_VerifyInit()
02977         {               
02978             UInt32                              ret = ErrorManager.DKMS_OK;
02979             CryptoCore.CCConvert                converter;      
02980             // Function arguments IN
02981             UInt32                              hSession;           
02982             CryptoCore.Smf.MECHANISM            mech;
02983             UInt32                              hKey;
02984 
02985 
02986             // Initialization
02987             converter = new CryptoCore.CCConvert();
02988 
02990             // Get parameter from DKMSProtocol Data Block                  //
02991             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey}       // 
02993             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02994             _smf.CurrentSession = hSession;
02995             /* get hKey */
02996             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02997             /* get mech */
02998             ret = converter.ParseMechanismIn(out mech, config);         
02999             
03000             // Bad Result
03001             if(ret != ErrorManager.DKMS_OK)
03002             {
03003                 _pm.XMLTXParser_Set_Error(ret);             
03004             }
03005             // Good Result
03006             else
03007             {
03008                 // Send Command - VerifyInit
03009                 ret = _smf.fvsm.VerifyInit(mech, hKey);
03010 
03011                 // Bad Result
03012                 if(ret != ErrorManager.DKMS_OK)
03013                 {
03014                     _pm.XMLTXParser_Set_Error(ret);                 
03015                 }
03016                 // Good Result
03017                 else
03018                 {
03020                     // Fase 3 Build the responce                    
03021                     /* 1 */
03022                     _pm.XMLTXParser_Set_Start("DKMS_VerifyInit", 1);
03023                     /* 2 */
03024                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03025                     /* 3 */
03026                     _pm.XMLTXParser_Set_End();
03027                 }
03028             }
03029         }
03030 
03035         private void CS_Verify()
03036         {               
03037             UInt32                              ret = ErrorManager.DKMS_OK;         
03038             // Function arguments IN
03039             UInt32                              hSession;               
03040             string                              Data;           
03041             string                              Signature;
03042 
03043 
03045             // Get parameter from DKMSProtocol Data Block                           //
03046             // Param: {UInt32 hSession, string Data, string Signature}              // 
03048             /* get-set hSession */
03049             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03050             _smf.CurrentSession = hSession;
03051             /* get Data */
03052             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
03053             /* get Signature */
03054             Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03055             
03056             // Send Command - Verify
03057             ret = _smf.fvsm.Verify(Data, Signature);
03058 
03059             // Bad Result
03060             if(ret != ErrorManager.DKMS_OK)
03061             {
03062                 _pm.XMLTXParser_Set_Error(ret);             
03063             }
03064             // Good Result
03065             else
03066             {
03068                 // Fase 3 Build the responce
03069                 /* 1 */
03070                 _pm.XMLTXParser_Set_Start("DKMS_Verify", 1);
03071                 /* 2 */
03072                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
03073                 /* 3 */
03074                 _pm.XMLTXParser_Set_End();
03075             }
03076         }
03077 
03082         private void CS_CompactVerify()
03083         {
03084             UInt32                              ret = ErrorManager.DKMS_OK;
03085             CryptoCore.CCConvert converter;
03086             // Function arguments IN
03087             UInt32 hSession;
03088             CryptoCore.Smf.MECHANISM mech;
03089             UInt32 hKey;
03090             string Data;
03091             string Signature;
03092 
03093 
03094             // Initialization
03095             converter = new CryptoCore.CCConvert();
03096 
03098             // Get parameter from DKMSProtocol Data Block                  //
03099             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey,       //
03100             // string Data, string Signature}                              // 
03102             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03103             _smf.CurrentSession = hSession;
03104             /* get Data */
03105             Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
03106             /* get Signature */
03107             Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03108             /* get hKey */
03109             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03110             /* get mech */
03111             ret = converter.ParseMechanismIn(out mech, config);            
03112 
03113             // Bad Result
03114             if (ret != ErrorManager.DKMS_OK)
03115             {
03116                 _pm.XMLTXParser_Set_Error(ret);
03117             }
03118             // Good Result
03119             else
03120             {
03121                 // Send Command - CompactVerify
03122                 ret = _smf.fvsm.CompactVerify(mech, hKey, Data, Signature);
03123 
03124                 // Bad Result
03125                 if (ret != ErrorManager.DKMS_OK)
03126                 {
03127                     _pm.XMLTXParser_Set_Error(ret);
03128                 }
03129                 // Good Result
03130                 else
03131                 {                    
03133                     // Fase 3 Build the responce
03134                     /* 1 */
03135                     _pm.XMLTXParser_Set_Start("DKMS_CompactVerify", 1);
03136                     /* 2 */
03137                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03138                     /* 3 */
03139                     _pm.XMLTXParser_Set_End();                   
03140                 }
03141             }
03142         }
03143 
03148         private void CS_VerifyUpdate()
03149         {               
03150             UInt32                              ret = ErrorManager.DKMS_OK;         
03151             // Function arguments IN
03152             UInt32                              hSession;               
03153             string                              PartData;           
03154 
03155 
03157             // Get parameter from DKMSProtocol Data Block                                   //
03158             // Param: {UInt32 hSession, string PartData}                                    // 
03160             /* get-set hSession */
03161             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03162             _smf.CurrentSession = hSession;
03163             /* get PartData */
03164             PartData = ((ProtocolManager.Param)config.body.param["PartData"]).vvalue;
03165             
03166             // Send Command - VerifyUpdate
03167             ret = _smf.fvsm.VerifyUpdate(PartData);
03168 
03169             // Bad Result
03170             if(ret != ErrorManager.DKMS_OK)
03171             {
03172                 _pm.XMLTXParser_Set_Error(ret);             
03173             }
03174             // Good Result
03175             else
03176             {
03178                 // Fase 3 Build the responce
03179                 /* 1 */
03180                 _pm.XMLTXParser_Set_Start("DKMS_VerifyUpdate", 1);
03181                 /* 2 */
03182                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
03183                 /* 3 */
03184                 _pm.XMLTXParser_Set_End();
03185             }
03186         }
03187 
03192         private void CS_VerifyFinal()
03193         {               
03194             UInt32                              ret = ErrorManager.DKMS_OK;         
03195             // Function arguments IN
03196             UInt32                              hSession;           
03197             string                              Signature;
03198 
03199 
03201             // Get parameter from DKMSProtocol Data Block                  //
03202             // Param: {UInt32 hSession, string Signature}                  // 
03204             /* get-set hSession */
03205             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03206             _smf.CurrentSession = hSession;
03207             /* get Signature */
03208             Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03209             
03210             // Send Command - VerifyFinal
03211             ret = _smf.fvsm.VerifyFinal(Signature);
03212 
03213             // Bad Result
03214             if(ret != ErrorManager.DKMS_OK)
03215             {
03216                 _pm.XMLTXParser_Set_Error(ret);             
03217             }
03218             // Good Result
03219             else
03220             {
03222                 // Fase 3 Build the responce                    
03223                 /* 1 */
03224                 _pm.XMLTXParser_Set_Start("DKMS_VerifyFinal", 1);
03225                 /* 2 */
03226                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
03227                 /* 3 */
03228                 _pm.XMLTXParser_Set_End();              
03229             }
03230         }
03231 
03236         private void CS_VerifyRecoverInit()
03237         {               
03238             UInt32                              ret = ErrorManager.DKMS_OK;
03239             CryptoCore.CCConvert                converter;      
03240             // Function arguments IN
03241             UInt32                              hSession;           
03242             CryptoCore.Smf.MECHANISM            mech;
03243             UInt32                              hKey;
03244 
03245 
03246             // Initialization
03247             converter = new CryptoCore.CCConvert();
03248 
03250             // Get parameter from DKMSProtocol Data Block                  //
03251             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey}       // 
03253             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03254             _smf.CurrentSession = hSession;
03255             /* get hKey */
03256             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03257             /* get mech */
03258             ret = converter.ParseMechanismIn(out mech, config);         
03259             
03260             // Bad Result
03261             if(ret != ErrorManager.DKMS_OK)
03262             {
03263                 _pm.XMLTXParser_Set_Error(ret);             
03264             }
03265             // Good Result
03266             else
03267             {
03268                 // Send Command - VerifyRecoverInit
03269                 ret = _smf.fvsm.VerifyRecoverInit(mech, hKey);
03270 
03271                 // Bad Result
03272                 if(ret != ErrorManager.DKMS_OK)
03273                 {
03274                     _pm.XMLTXParser_Set_Error(ret);                 
03275                 }
03276                 // Good Result
03277                 else
03278                 {
03280                     // Fase 3 Build the responce                    
03281                     /* 1 */
03282                     _pm.XMLTXParser_Set_Start("DKMS_VerifyRecoverInit", 1);
03283                     /* 2 */
03284                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03285                     /* 3 */
03286                     _pm.XMLTXParser_Set_End();
03287                 }
03288             }
03289         }
03290 
03295         private void CS_VerifyRecover()
03296         {               
03297             UInt32                              ret = ErrorManager.DKMS_OK;         
03298             // Function arguments IN
03299             UInt32                              hSession;
03300             string                              Signature;
03301             // Function arguments OUT
03302             string                              Data;           
03303 
03304 
03306             // Get parameter from DKMSProtocol Data Block                  //
03307             // Param: {UInt32 hSession, out string Data, string Signature} // 
03309             /* get-set hSession */
03310             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);         
03311             _smf.CurrentSession = hSession;
03312             /* get Signature */
03313             Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03314             
03315             // Send Command - VerifyRecover
03316             ret = _smf.fvsm.VerifyRecover(out Data, Signature);
03317 
03318             // Bad Result
03319             if(ret != ErrorManager.DKMS_OK)
03320             {
03321                 _pm.XMLTXParser_Set_Error(ret);             
03322             }
03323             // Good Result
03324             else
03325             {
03327                 // Fase 3 Build the responce                    
03328                 /* 1 */
03329                 _pm.XMLTXParser_Set_Start("DKMS_VerifyRecover", 2);
03330                 /* 2 */
03331                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03332                 _pm.XMLTXParser_Set_ParamAtomic(1, "Data", ProtocolManager.PARAM_TYPE.STRING, Data);
03333                 /* 3 */
03334                 _pm.XMLTXParser_Set_End();              
03335             }
03336         }
03337 
03342         private void CS_CompactVerifyRecover()
03343         {
03344             UInt32                              ret = ErrorManager.DKMS_OK;
03345             CryptoCore.CCConvert                converter;
03346             // Function arguments IN
03347             UInt32                              hSession;
03348             CryptoCore.Smf.MECHANISM            mech;
03349             UInt32                              hKey;
03350             string                              Signature;
03351             // Function arguments OUT
03352             string                              Data;
03353 
03354 
03355             // Initialization
03356             converter = new CryptoCore.CCConvert();
03357 
03359             // Get parameter from DKMSProtocol Data Block                  //
03360             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hKey,       //
03361             // out string Data, string Signature}                          // 
03363             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03364             _smf.CurrentSession = hSession;
03365             /* get Signature */
03366             Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03367             /* get hKey */
03368             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03369             /* get mech */
03370             ret = converter.ParseMechanismIn(out mech, config);            
03371 
03372             // Bad Result
03373             if (ret != ErrorManager.DKMS_OK)
03374             {
03375                 _pm.XMLTXParser_Set_Error(ret);
03376             }
03377             // Good Result
03378             else
03379             {
03380                 // Send Command - CompactVerifyRecover
03381                 ret = _smf.fvsm.CompactVerifyRecover(mech, hKey, out Data, Signature);
03382 
03383                 // Bad Result
03384                 if (ret != ErrorManager.DKMS_OK)
03385                 {
03386                     _pm.XMLTXParser_Set_Error(ret);
03387                 }
03388                 // Good Result
03389                 else
03390                 {                    
03392                     // Fase 3 Build the responce                    
03393                     /* 1 */
03394                     _pm.XMLTXParser_Set_Start("DKMS_CompactVerifyRecover", 2);
03395                     /* 2 */
03396                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03397                     _pm.XMLTXParser_Set_ParamAtomic(1, "Data", ProtocolManager.PARAM_TYPE.STRING, Data);
03398                     /* 3 */
03399                     _pm.XMLTXParser_Set_End();                    
03400                 }
03401             }
03402         }
03403 
03408         private void CS_DigestEncryptUpdate()
03409         {               
03410             UInt32                              ret = ErrorManager.DKMS_OK;         
03411             // Function arguments IN
03412             UInt32                              hSession;               
03413             string                              ClearPartData;
03414             // Function arguments OUT               
03415             string                              EncryptedPartData;
03416 
03417 
03419             // Get parameter from DKMSProtocol Data Block                                   //
03420             // Param: {UInt32 hSession, string ClearPartData, out string EncryptedPartData} // 
03422             /* get-set hSession */
03423             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03424             _smf.CurrentSession = hSession;
03425             /* get ClearPartData */
03426             ClearPartData = ((ProtocolManager.Param)config.body.param["ClearPartData"]).vvalue;
03427             
03428             // Send Command - DigestEncryptUpdate
03429             ret = _smf.dfcf.DigestEncryptUpdate(ClearPartData, out EncryptedPartData);
03430 
03431             // Bad Result
03432             if(ret != ErrorManager.DKMS_OK)
03433             {
03434                 _pm.XMLTXParser_Set_Error(ret);             
03435             }
03436             // Good Result
03437             else
03438             {
03440                 // Fase 3 Build the responce
03441                 /* 1 */
03442                 _pm.XMLTXParser_Set_Start("DKMS_DigestEncryptUpdate", 2);
03443                 /* 2 */
03444                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03445                 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, EncryptedPartData);
03446                 /* 3 */
03447                 _pm.XMLTXParser_Set_End();
03448             }
03449         }
03450 
03455         private void CS_DecryptDigestUpdate()
03456         {               
03457             UInt32                              ret = ErrorManager.DKMS_OK;         
03458             // Function arguments IN
03459             UInt32                              hSession;               
03460             string                              EncryptedPartData;
03461             // Function arguments OUT               
03462             string                              ClearPartData;
03463 
03464 
03466             // Get parameter from DKMSProtocol Data Block                                   //
03467             // Param: {UInt32 hSession, string EncryptedPartData, out string ClearPartData} // 
03469             /* get-set hSession */
03470             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03471             _smf.CurrentSession = hSession;
03472             /* get EncryptedPartData */
03473             EncryptedPartData = ((ProtocolManager.Param)config.body.param["EncryptedPartData"]).vvalue;
03474             
03475             // Send Command - DecryptDigestUpdate
03476             ret = _smf.dfcf.DecryptDigestUpdate(EncryptedPartData, out ClearPartData);
03477 
03478             // Bad Result
03479             if(ret != ErrorManager.DKMS_OK)
03480             {
03481                 _pm.XMLTXParser_Set_Error(ret);             
03482             }
03483             // Good Result
03484             else
03485             {
03487                 // Fase 3 Build the responce
03488                 /* 1 */
03489                 _pm.XMLTXParser_Set_Start("DKMS_DecryptDigestUpdate", 2);
03490                 /* 2 */
03491                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03492                 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearPartData", ProtocolManager.PARAM_TYPE.STRING, ClearPartData);
03493                 /* 3 */
03494                 _pm.XMLTXParser_Set_End();
03495             }
03496         }
03497 
03502         private void CS_SignEncryptUpdate()
03503         {               
03504             UInt32                              ret = ErrorManager.DKMS_OK;         
03505             // Function arguments IN
03506             UInt32                              hSession;               
03507             string                              ClearPartData;
03508             // Function arguments OUT               
03509             string                              EncryptedPartData;
03510 
03511 
03513             // Get parameter from DKMSProtocol Data Block                                   //
03514             // Param: {UInt32 hSession, string ClearPartData, out string EncryptedPartData} // 
03516             /* get-set hSession */
03517             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03518             _smf.CurrentSession = hSession;
03519             /* get ClearPartData */
03520             ClearPartData = ((ProtocolManager.Param)config.body.param["ClearPartData"]).vvalue;
03521             
03522             // Send Command - SignEncryptUpdate
03523             ret = _smf.dfcf.SignEncryptUpdate(ClearPartData, out EncryptedPartData);
03524 
03525             // Bad Result
03526             if(ret != ErrorManager.DKMS_OK)
03527             {
03528                 _pm.XMLTXParser_Set_Error(ret);             
03529             }
03530             // Good Result
03531             else
03532             {
03534                 // Fase 3 Build the responce
03535                 /* 1 */
03536                 _pm.XMLTXParser_Set_Start("DKMS_SignEncryptUpdate", 2);
03537                 /* 2 */
03538                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03539                 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, EncryptedPartData);
03540                 /* 3 */
03541                 _pm.XMLTXParser_Set_End();
03542             }
03543         }
03544 
03549         private void CS_DecryptVerifyUpdate()
03550         {               
03551             UInt32                              ret = ErrorManager.DKMS_OK;         
03552             // Function arguments IN
03553             UInt32                              hSession;               
03554             string                              EncryptedPartData;
03555             // Function arguments OUT               
03556             string                              ClearPartData;
03557 
03558 
03560             // Get parameter from DKMSProtocol Data Block                                   //
03561             // Param: {UInt32 hSession, string EncryptedPartData, out string ClearPartData} // 
03563             /* get-set hSession */
03564             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03565             _smf.CurrentSession = hSession;
03566             /* get EncryptedPartData */
03567             EncryptedPartData = ((ProtocolManager.Param)config.body.param["EncryptedPartData"]).vvalue;
03568             
03569             // Send Command - DecryptVerifyUpdate
03570             ret = _smf.dfcf.DecryptVerifyUpdate(EncryptedPartData, out ClearPartData);
03571 
03572             // Bad Result
03573             if(ret != ErrorManager.DKMS_OK)
03574             {
03575                 _pm.XMLTXParser_Set_Error(ret);             
03576             }
03577             // Good Result
03578             else
03579             {
03581                 // Fase 3 Build the responce
03582                 /* 1 */
03583                 _pm.XMLTXParser_Set_Start("DKMS_DecryptVerifyUpdate", 2);
03584                 /* 2 */
03585                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03586                 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearPartData", ProtocolManager.PARAM_TYPE.STRING, ClearPartData);
03587                 /* 3 */
03588                 _pm.XMLTXParser_Set_End();
03589             }
03590         }
03591 
03596         private void CS_GenerateKeyPair()
03597         {                
03598             UInt32                              ret = ErrorManager.DKMS_OK;
03599             CryptoCore.CCConvert                converter;
03600             UInt32                              ulPublicKeyAttributeCount;
03601             UInt32                              ulPrivateKeyAttributeCount;
03602             // Function arguments IN
03603             UInt32                              hSession;
03604             CryptoCore.ATTRIBUTE_VALUE          templpb;
03605             CryptoCore.ATTRIBUTE_VALUE          templpv;
03606             CryptoCore.Smf.MECHANISM            mech;
03607             // Function arguments OUT               
03608             UInt32                              phpbKey;
03609             UInt32                              phpvKey;
03610 
03611 
03612             // Initialization
03613             converter = new CryptoCore.CCConvert();
03614 
03616             // Get parameter from DKMSProtocol Data Block                                    //
03617             // Param: {UInt32 hSession, MECHANISM mech, CryptoCore.ATTRIBUTE_VALUE templpb,  //
03618             // CryptoCore.ATTRIBUTE_VALUE templpv,  out UInt32 phpbKey, out UInt32 phpvKey}  // 
03620             /* get-set hSession */  
03621             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03622             _smf.CurrentSession = hSession;
03623             /* get templpb */ 
03624             ulPublicKeyAttributeCount = ((ProtocolManager.Param)config.body.param["templpb"]).XDim;
03625             ret = converter.ParseAttributeIn(config, "templpb", ulPublicKeyAttributeCount, out templpb);
03626             
03627             // Bad Result
03628             if(ret != ErrorManager.DKMS_OK)
03629             {
03630                 _pm.XMLTXParser_Set_Error(ret);             
03631             }
03632             // Good Result
03633             else
03634             {
03635                 /* get templpv */ 
03636                 ulPrivateKeyAttributeCount = ((ProtocolManager.Param)config.body.param["templpv"]).XDim;
03637                 ret = converter.ParseAttributeIn(config, "templpv", ulPrivateKeyAttributeCount, out templpv);
03638                 
03639                 // Bad Result
03640                 if(ret != ErrorManager.DKMS_OK)
03641                 {
03642                     _pm.XMLTXParser_Set_Error(ret);             
03643                 }
03644                 // Good Result
03645                 else
03646                 {                               
03647                     /* get mech */
03648                     ret = converter.ParseMechanismIn(out mech, config);
03649 
03650                     // Bad Result
03651                     if (ret != ErrorManager.DKMS_OK)
03652                     {
03653                         _pm.XMLTXParser_Set_Error(ret);             
03654                     }
03655                     // Good Result
03656                     else
03657                     {
03658                         // Send Command - GenerateKeyPair
03659                         ret = _smf.kmf.GenerateKeyPair(mech, templpb, templpv, out phpbKey, out phpvKey);
03660 
03661                         // Bad Result
03662                         if (ret != ErrorManager.DKMS_OK)
03663                         {
03664                             _pm.XMLTXParser_Set_Error(ret);                 
03665                         }
03666                         // Good Result
03667                         else
03668                         {
03670                             // Fase 3 Build the responce                    
03671                             /* 1 */
03672                             _pm.XMLTXParser_Set_Start("DKMS_GenerateKeyPair", 3);
03673                             /* 2 */
03674                             _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03675                             _pm.XMLTXParser_Set_ParamAtomic(1, "phpbKey", ProtocolManager.PARAM_TYPE.UINT32, phpbKey.ToString());
03676                             _pm.XMLTXParser_Set_ParamAtomic(2, "phpvKey", ProtocolManager.PARAM_TYPE.UINT32, phpvKey.ToString());
03677                             /* 3 */
03678                             _pm.XMLTXParser_Set_End();
03679                         }
03680                     }
03681                 }
03682             }
03683         }
03684 
03688         private void CS_WrapKey()
03689         {               
03690             UInt32                              ret = ErrorManager.DKMS_OK;
03691             CryptoCore.CCConvert                converter;      
03692             // Function arguments IN
03693             UInt32                              hSession;
03694             UInt32                              hWrappingKey;   
03695             UInt32                              hKey;
03696             CryptoCore.Smf.MECHANISM            mech;
03697             // Function arguments OUT
03698             string                              WrappedKey;
03699 
03700 
03701             // Initialization
03702             converter = new CryptoCore.CCConvert();
03703 
03705             // Get parameter from DKMSProtocol Data Block                                   //
03706             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hWrappingKey, UInt32 hKey,   //
03707             // out string WrappedKey}                                                       // 
03709             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03710             _smf.CurrentSession = hSession;
03711             /* get hWrappingKey */ 
03712             hWrappingKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hWrappingKey"]).vvalue);
03713             /* get hKey */ 
03714             hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03715             /* get mech */
03716             ret = converter.ParseMechanismIn(out mech, config);
03717             
03718             // Bad Result
03719             if(ret != ErrorManager.DKMS_OK)
03720             {
03721                 _pm.XMLTXParser_Set_Error(ret);             
03722             }
03723             // Good Result
03724             else
03725             {
03726                 // Send Command - WrapKey
03727                 ret = _smf.kmf.WrapKey(mech, hWrappingKey, hKey, out WrappedKey);
03728 
03729                 // Bad Result
03730                 if(ret != ErrorManager.DKMS_OK)
03731                 {
03732                     _pm.XMLTXParser_Set_Error(ret);                 
03733                 }
03734                 // Good Result
03735                 else
03736                 {
03738                     // Fase 3 Build the responce                    
03739                     /* 1 */
03740                     _pm.XMLTXParser_Set_Start("DKMS_WrapKey", 2);
03741                     /* 2 */
03742                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03743                     _pm.XMLTXParser_Set_ParamAtomic(1, "WrappedKey", ProtocolManager.PARAM_TYPE.STRING, WrappedKey);
03744                     /* 3 */
03745                     _pm.XMLTXParser_Set_End();
03746                 }
03747             }
03748         }
03749 
03754         private void CS_UnwrapKey()
03755         {               
03756             UInt32                              ret = ErrorManager.DKMS_OK;
03757             CryptoCore.CCConvert                converter;
03758             UInt32                              ulCount;
03759             // Function arguments IN
03760             UInt32                              hSession;
03761             UInt32                              hUnwrappingKey;
03762             string                              WrappedKey;
03763             CryptoCore.ATTRIBUTE_VALUE          templ;          
03764             CryptoCore.Smf.MECHANISM            mech;
03765             // Function arguments OUT
03766             UInt32                              phKey;
03767 
03768 
03769             // Initialization
03770             converter = new CryptoCore.CCConvert();
03771 
03773             // Get parameter from DKMSProtocol Data Block                               //
03774             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hUnwrappingKey,          // 
03775             // string WrappedKey, CryptoCore.ATTRIBUTE_VALUE templ, out UInt32 phKey}   // 
03777             /* get-set hSession */
03778             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03779             _smf.CurrentSession = hSession;
03780             /* get hUnwrappingKey */ 
03781             hUnwrappingKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hUnwrappingKey"]).vvalue);
03782             /* get WrappedKey */ 
03783             WrappedKey = ((ProtocolManager.Param)config.body.param["WrappedKey"]).vvalue;
03784             /* get templ */ 
03785             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;         
03786             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
03787             
03788             // Bad Result
03789             if(ret != ErrorManager.DKMS_OK)
03790             {
03791                 _pm.XMLTXParser_Set_Error(ret);             
03792             }
03793             // Good Result
03794             else
03795             {       
03796                 /* get mech */
03797                 ret = converter.ParseMechanismIn(out mech, config);
03798             
03799                 // Bad Result
03800                 if(ret != ErrorManager.DKMS_OK)
03801                 {
03802                     _pm.XMLTXParser_Set_Error(ret);             
03803                 }
03804                 // Good Result
03805                 else
03806                 {           
03807                     // Send Command - UnwrapKey
03808                     ret = _smf.kmf.UnwrapKey(mech, hUnwrappingKey, WrappedKey, templ, out phKey);
03809 
03810                     // Bad Result
03811                     if(ret != ErrorManager.DKMS_OK)
03812                     {
03813                         _pm.XMLTXParser_Set_Error(ret);             
03814                     }
03815                     // Good Result
03816                     else
03817                     {
03819                         // Fase 3 Build the responce                    
03820                         /* 1 */
03821                         _pm.XMLTXParser_Set_Start("DKMS_UnwrapKey", 2);
03822                         /* 2 */
03823                         _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03824                         _pm.XMLTXParser_Set_ParamAtomic(1, "phKey", ProtocolManager.PARAM_TYPE.UINT32, phKey.ToString());
03825                         /* 3 */
03826                         _pm.XMLTXParser_Set_End();
03827                     }
03828                 }
03829             }
03830         }
03831 
03835         private void CS_DeriveKey()
03836         {               
03837             UInt32                              ret = ErrorManager.DKMS_OK;
03838             CryptoCore.CCConvert                converter;
03839             UInt32                              ulCount;
03840             // Function arguments IN
03841             UInt32                              hSession;
03842             UInt32                              hBaseKey;           
03843             CryptoCore.ATTRIBUTE_VALUE          templ;          
03844             CryptoCore.Smf.MECHANISM            mech;
03845             // Function arguments OUT
03846             UInt32                              phKey;
03847 
03848 
03849             // Initialization
03850             converter = new CryptoCore.CCConvert();
03851 
03853             // Get parameter from DKMSProtocol Data Block                       //
03854             // Param: {UInt32 hSession, MECHANISM mech, UInt32 hBaseKey,        //
03855             // CryptoCore.ATTRIBUTE_VALUE templ, out UInt32 phKey}              // 
03857             /* get-set hSession */
03858             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03859             _smf.CurrentSession = hSession;
03860             /* get hBaseKey */ 
03861             hBaseKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hBaseKey"]).vvalue);         
03862             /* get templ */
03863             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;         
03864             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
03865             
03866             // Bad Result
03867             if(ret != ErrorManager.DKMS_OK)
03868             {
03869                 _pm.XMLTXParser_Set_Error(ret);             
03870             }
03871             // Good Result
03872             else
03873             {
03874                 /* get mech */
03875                 ret = converter.ParseMechanismIn(out mech, config);
03876             
03877                 // Bad Result
03878                 if(ret != ErrorManager.DKMS_OK)
03879                 {
03880                     _pm.XMLTXParser_Set_Error(ret);             
03881                 }
03882                 // Good Result
03883                 else
03884                 {           
03885                     // Send Command - DeriveKey
03886                     ret = _smf.kmf.DeriveKey(mech, hBaseKey, templ, out phKey);
03887 
03888                     // Bad Result
03889                     if(ret != ErrorManager.DKMS_OK)
03890                     {
03891                         _pm.XMLTXParser_Set_Error(ret);             
03892                     }
03893                     // Good Result
03894                     else
03895                     {
03897                         // Fase 3 Build the responce                    
03898                         /* 1 */
03899                         _pm.XMLTXParser_Set_Start("DKMS_DeriveKey", 2);
03900                         /* 2 */
03901                         _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03902                         _pm.XMLTXParser_Set_ParamAtomic(1, "phKey", ProtocolManager.PARAM_TYPE.UINT32, phKey.ToString());
03903                         /* 3 */
03904                         _pm.XMLTXParser_Set_End();
03905                     }
03906                 }
03907             }
03908         }
03909 
03913         private void CS_SetAttributeValue()
03914         {                
03915             UInt32                              ret = ErrorManager.DKMS_OK;
03916             CryptoCore.CCConvert                converter;
03917             UInt32                              ulCount;
03918             // function arguments in
03919             UInt32                              hSession;
03920             UInt32                              hObject;
03921             CryptoCore.ATTRIBUTE_VALUE          templ;    
03922             
03923             
03924             // Initialization
03925             converter = new CryptoCore.CCConvert();
03926 
03928             // Get parameter from DKMSProtocol Data Block                      //
03929             // Param: {UInt32 hSession, UInt32 hObject, ATTRIBUTE_VALUE templ} // 
03931             /* get-set hSession */  
03932             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03933             _smf.CurrentSession = hSession;
03934             /* get hObject */
03935             hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
03936             /* get templ */ 
03937             ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
03938             ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
03939             
03940             // Bad Result
03941             if (ret != ErrorManager.DKMS_OK)
03942             {
03943                 _pm.XMLTXParser_Set_Error(ret);         
03944             }
03945             // Good Result          
03946             else
03947             {
03948                 // Send Command - SetAttributeValue
03949                 ret = _smf.omf.SetAttributeValue(hObject, templ);
03950 
03951                 // Bad Result
03952                 if (ret != ErrorManager.DKMS_OK)
03953                 {
03954                     _pm.XMLTXParser_Set_Error(ret);         
03955                 }
03956                 // Good Result
03957                 else
03958                 {
03960                     // Fase 3 Build the responce
03961                     /* 1 */
03962                     _pm.XMLTXParser_Set_Start("DKMS_SetAttributeValue", 1);
03963                     /* 2 */
03964                     _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
03965                     /* 3 */
03966                     _pm.XMLTXParser_Set_End();
03967                 }
03968             }
03969         }
03970 
03974         private void CS_GetObjectSize()
03975         {               
03976             UInt32                              ret = ErrorManager.DKMS_OK;         
03977             // Function arguments IN
03978             UInt32                              hSession;
03979             UInt32                              hObject;
03980             // Function arguments OUT
03981             UInt32                              pulSize;
03982 
03983 
03985             // Get parameter from DKMSProtocol Data Block                   //
03986             // Param: {UInt32 hSession, UInt32 hObject, out UInt32 pulSize} // 
03988             /* get hSession */
03989             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03990             _smf.CurrentSession = hSession;
03991             /* get hObject */
03992             hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
03993 
03994             // Send Command - GetObjectSize         
03995             ret = _smf.omf.GetObjectSize(hObject, out pulSize);
03996 
03997             // Bad Result
03998             if(ret != ErrorManager.DKMS_OK)
03999             {
04000                 _pm.XMLTXParser_Set_Error(ret);             
04001             }
04002             // Good Result
04003             else
04004             {
04006                 // Fase 3 Build the responce                    
04007                 /* 1 */
04008                 _pm.XMLTXParser_Set_Start("DKMS_GetObjectSize", 2);
04009                 /* 2 */
04010                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04011                 _pm.XMLTXParser_Set_ParamAtomic(1, "pulSize", ProtocolManager.PARAM_TYPE.UINT32, pulSize.ToString());
04012                 /* 3 */
04013                 _pm.XMLTXParser_Set_End();              
04014             }           
04015         }
04016 
04020         private void CS_SetPIN()
04021         {               
04022             UInt32                              ret = ErrorManager.DKMS_OK;         
04023             // Function arguments IN
04024             UInt32                              hSession;
04025             string                              OldPin;
04026             string                              NewPin;
04027             
04028 
04030             // Get parameter from DKMSProtocol Data Block                  //
04031             // Param: {UInt32 hSession, string OldPin, string NewPin}      // 
04033             /* get-set hSession */
04034             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
04035             _smf.CurrentSession = hSession;
04036             /* get OldPin */
04037             OldPin = ((ProtocolManager.Param)config.body.param["OldPin"]).vvalue;
04038             /* get NewPin */
04039             NewPin = ((ProtocolManager.Param)config.body.param["NewPin"]).vvalue;
04040             
04041             // Send Command - SetPIN
04042             ret = _smf.SetPIN(OldPin, NewPin);
04043 
04044             // Bad Result
04045             if(ret != ErrorManager.DKMS_OK)
04046             {
04047                 _pm.XMLTXParser_Set_Error(ret);             
04048             }
04049             // Good Result
04050             else
04051             {
04053                 // Fase 3 Build the responce                    
04054                 /* 1 */
04055                 _pm.XMLTXParser_Set_Start("DKMS_SetPIN", 1);
04056                 /* 2 */
04057                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
04058                 /* 3 */
04059                 _pm.XMLTXParser_Set_End();              
04060             }           
04061         }
04062 
04066         private void CS_InitPIN()
04067         {               
04068             UInt32                              ret = ErrorManager.DKMS_OK;         
04069             // Function arguments IN
04070             UInt32                              hSession;
04071             string                              Pin;        
04072             
04073 
04075             // Get parameter from DKMSProtocol Data Block                  //
04076             // Param: {UInt32 hSession, string Pin}                        // 
04078             /* get-set hSession */
04079             hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
04080             _smf.CurrentSession = hSession;
04081             /* get Pin */
04082             Pin = ((ProtocolManager.Param)config.body.param["Pin"]).vvalue;
04083                         
04084             // Send Command - InitPIN
04085             ret = _smf.InitPIN(Pin);
04086 
04087             // Bad Result
04088             if(ret != ErrorManager.DKMS_OK)
04089             {
04090                 _pm.XMLTXParser_Set_Error(ret);             
04091             }
04092             // Good Result
04093             else
04094             {
04096                 // Fase 3 Build the responce                    
04097                 /* 1 */
04098                 _pm.XMLTXParser_Set_Start("DKMS_InitPIN", 1);
04099                 /* 2 */
04100                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
04101                 /* 3 */
04102                 _pm.XMLTXParser_Set_End();              
04103             }           
04104         }
04105 
04109         private void CS_InitToken()
04110         {               
04111             UInt32                              ret = ErrorManager.DKMS_OK;         
04112             // Function arguments IN
04113             UInt32                              slotID;
04114             string                              Pin;
04115             string                              Label;
04116             
04117 
04119             // Get parameter from DKMSProtocol Data Block                  //
04120             // Param: {UInt32 slotID, string Pin, string Label}            // 
04122             /* get slotID */
04123             slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);         
04124             /* get Pin */
04125             Pin = ((ProtocolManager.Param)config.body.param["Pin"]).vvalue;
04126             /* get Label */
04127             Label = ((ProtocolManager.Param)config.body.param["Label"]).vvalue;
04128             Label = Label.Substring(0, Label.Length - 1);
04129                         
04130             // Send Command - InitToken
04131             ret = _stmf.InitToken(slotID, Pin, Label);
04132 
04133             // Bad Result
04134             if(ret != ErrorManager.DKMS_OK)
04135             {
04136                 _pm.XMLTXParser_Set_Error(ret);             
04137             }
04138             // Good Result
04139             else
04140             {
04142                 // Fase 3 Build the responce                    
04143                 /* 1 */
04144                 _pm.XMLTXParser_Set_Start("DKMS_InitToken", 1);
04145                 /* 2 */
04146                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());               
04147                 /* 3 */
04148                 _pm.XMLTXParser_Set_End();              
04149             }           
04150         }
04151 
04155         private void CS_GetMechanismInfo()
04156         {               
04157             UInt32                              ret = ErrorManager.DKMS_OK;         
04158             // Function arguments IN
04159             UInt32                              slotID;
04160             CryptoCore.Smf.CK_MECHANISM_TYPE    type;
04161             // Function arguments OUT
04162             CryptoCore.Stmf.CK_MECHANISM_INFO   pInfo;
04163             
04164 
04166             // Get parameter from DKMSProtocol Data Block                  //
04167             // Param: {UInt32 slotID, Smf.CK_MECHANISM_TYPE type,          //   
04168             // out CK_MECHANISM_INFO pInfo}                                // 
04170             /* get slotID */
04171             slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);         
04172             /* get type */
04173             type = (CryptoCore.Smf.CK_MECHANISM_TYPE)int.Parse(((ProtocolManager.Param)config.body.param["type"]).vvalue);
04174             
04176             // Initialization                             //
04178             /* initialize pInfo */
04179             pInfo = new CryptoCore.Stmf.CK_MECHANISM_INFO();
04180 
04181             // Send Command - GetMechanismInfo
04182             ret = _stmf.GetMechanismInfo(slotID, type, out pInfo);
04183 
04184             // Bad Result
04185             if(ret != ErrorManager.DKMS_OK)
04186             {
04187                 _pm.XMLTXParser_Set_Error(ret);             
04188             }
04189             // Good Result
04190             else
04191             {
04193                 // Fase 3 Build the responce                    
04194                 /* 1 */
04195                 _pm.XMLTXParser_Set_Start("DKMS_GetMechanismInfo", 2);
04196                 /* 2 */
04197                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04198                 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
04199                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.flags", ProtocolManager.PARAM_TYPE.INT32, pInfo.flags.ToString());
04200                 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.ulMaxKeySize", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxKeySize.ToString());
04201                 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.ulMinKeySize", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMinKeySize.ToString());
04202                 _pm.XMLTXParser_Set_EndParamStruct();
04203                 /* 3 */
04204                 _pm.XMLTXParser_Set_End();              
04205             }           
04206         }
04207 
04211         private void CS_GetSlotInfo()
04212         {               
04213             UInt32                              ret = ErrorManager.DKMS_OK;         
04214             // Function arguments IN
04215             UInt32                              slotID;         
04216             // Function arguments OUT
04217             CryptoCore.Stmf.CK_SLOT_INFO        pInfo;
04218             
04219 
04221             // Get parameter from DKMSProtocol Data Block                  //
04222             // Param: {UInt32 slotID, out CK_SLOT_INFO pInfo}              //               
04224             /* get slotID */
04225             slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);                     
04226             
04228             // Initialization                             //
04230             /* initialize pInfo */
04231             pInfo = new CryptoCore.Stmf.CK_SLOT_INFO();
04232 
04233             // Send Command - GetSlotInfo
04234             ret = _stmf.GetSlotInfo(slotID, out pInfo);
04235 
04236             // Bad Result
04237             if(ret != ErrorManager.DKMS_OK)
04238             {
04239                 _pm.XMLTXParser_Set_Error(ret);             
04240             }
04241             // Good Result
04242             else
04243             {
04245                 // Fase 3 Build the responce                    
04246                 /* 1 */
04247                 _pm.XMLTXParser_Set_Start("DKMS_GetSlotInfo", 2);
04248                 /* 2 */
04249                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04250                 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
04251                 _pm.XMLTXParser_Set_StartParamStruct(0, "pInfo.firmwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
04252                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.firmwareVersion.major", ProtocolManager.PARAM_TYPE.UINT32, pInfo.firmwareVersion.major.ToString());
04253                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.firmwareVersion.minor", ProtocolManager.PARAM_TYPE.UINT32, pInfo.firmwareVersion.minor.ToString());
04254                 _pm.XMLTXParser_Set_EndParamStruct();
04255                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
04256                 _pm.XMLTXParser_Set_StartParamStruct(2, "pInfo.hardwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
04257                 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.hardwareVersion.major", ProtocolManager.PARAM_TYPE.UINT32, pInfo.hardwareVersion.major.ToString());
04258                 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.hardwareVersion.minor", ProtocolManager.PARAM_TYPE.UINT32, pInfo.hardwareVersion.minor.ToString());
04259                 _pm.XMLTXParser_Set_EndParamStruct();               
04260                 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.manufacturerID", ProtocolManager.PARAM_TYPE.STRING, pInfo.manufacturerID);
04261                 _pm.XMLTXParser_Set_ParamAtomic(4, "pInfo.slotDescription", ProtocolManager.PARAM_TYPE.STRING, pInfo.slotDescription);
04262                 _pm.XMLTXParser_Set_EndParamStruct();
04263                 /* 3 */
04264                 _pm.XMLTXParser_Set_End();              
04265             }           
04266         }
04267 
04271         private void CS_GetSlotList()
04272         {               
04273             UInt32                              ret = ErrorManager.DKMS_OK;         
04274             // Function arguments IN
04275             bool                                tokenPresent;           
04276             // Function arguments OUT
04277             UInt32[]                            SlotList;
04278             
04279 
04281             // Get parameter from DKMSProtocol Data Block                  //
04282             // Param: {bool tokenPresent, out UInt32[] SlotList}           //               
04284             /* get tokenPresent */
04285             if (((ProtocolManager.Param)config.body.param["tokenPresent"]).vvalue != true.ToString())
04286                 tokenPresent = false;
04287             else
04288                 tokenPresent = true;            
04289 
04290             // Send Command - GetSlotList
04291             ret = _stmf.GetSlotList(tokenPresent, out SlotList);
04292 
04293             // Bad Result
04294             if(ret != ErrorManager.DKMS_OK)
04295             {
04296                 _pm.XMLTXParser_Set_Error(ret);             
04297             }
04298             // Good Result
04299             else
04300             {
04302                 // Fase 3 Build the responce                    
04303                 /* 1 */
04304                 _pm.XMLTXParser_Set_Start("DKMS_GetSlotList", 2);
04305                 /* 2 */
04306                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04307                 _pm.XMLTXParser_Set_StartParamArray(1, "SlotList", ProtocolManager.PARAM_TYPE.UINT32, (UInt32)SlotList.Length, 0);              
04308                 for(int i = 0; i < SlotList.Length; i++)
04309                     _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "SlotList[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.UINT32, SlotList[i].ToString());                
04310                 _pm.XMLTXParser_Set_EndParamArray();
04311                 /* 3 */
04312                 _pm.XMLTXParser_Set_End();              
04313             }           
04314         }
04315         
04320         private void CS_TestDeviceComunication()
04321         {               
04322             UInt32                              ret = ErrorManager.DKMS_OK;         
04323             // Function arguments IN
04324             string                              deviceName;
04325 
04326 
04328             // Get parameter from DKMSProtocol Data Block                  //
04329             // Param: {string deviceName}                                  // 
04331             /* get deviceName */ 
04332             deviceName = ((ProtocolManager.Param)config.body.param["deviceName"]).vvalue;
04333             
04335             // Fase 3 Build the responce
04336             if(deviceName != "CryptoService")
04337             {
04338                 ret = ErrorManager.DKMS_DEVICE_NOT_FOUND;               
04339             }                           
04340             /* 1 */
04341             _pm.XMLTXParser_Set_Start("DKMS_TestDeviceComunication", 1);
04342             /* 2 */
04343             _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04344             /* 3 */
04345             _pm.XMLTXParser_Set_End();
04346         }
04347 
04351         private void CS_SetPolicy()
04352         {
04353             UInt32                              ret = ErrorManager.DKMS_OK;
04354             // Function arguments IN
04355             UInt32                              count;
04356 
04357             lock (typeof(Dispatcher))
04358             {
04360                 // Get parameter from DKMSProtocol Data Block                  //
04361                 // Param: {string[] PMethods}                                  // 
04363                 /* get count */
04364                 count = ((ProtocolManager.Param)config.body.param["PMethods"]).XDim;
04365 
04366                 // load methods in the container
04367                 string delimStr = "|";
04368                 char[] delimiter = delimStr.ToCharArray();
04369 
04370                 _c.adminsgc.SyncAGContainer.Clear();
04371                 _c.controllersgc.SyncCGContainer.Clear();
04372                 _c.custodiansgc.SyncCGContainer.Clear();
04373                 _c.insertersgc.SyncIGContainer.Clear();
04374                 _c.operatorsgc.SyncOGContainer.Clear();
04375                 _c.swadminsgc.SyncSGContainer.Clear();
04376                 _c.swdevelopersgc.SyncSGContainer.Clear();
04377                 _c.techniciansgc.SyncTGContainer.Clear();
04378                 _c.adminsgc.SyncAGContainer.Add("SetPolicy", string.Empty);
04379                 _c.adminsgc.SyncAGContainer.Add("TestDeviceComunication", string.Empty);
04380                 _c.swadminsgc.SyncSGContainer.Add("SetPolicy", string.Empty);
04381                 _c.swadminsgc.SyncSGContainer.Add("TestDeviceComunication", string.Empty);
04382                 _c.swadminsgc.SyncSGContainer.Add("CloseSession", string.Empty);
04383 
04384                 try
04385                 {
04386                     for (int i = 0; i < (int)count; i++)
04387                     {
04388                         string[] policies = ((ProtocolManager.Param)config.body.param["PMethods[" + i.ToString() + "]"]).vvalue.Split(delimiter);
04389                         switch (policies[1])
04390                         {
04391                             case "dkms_swadmins":
04392                                 if (!_c.swadminsgc.SyncSGContainer.ContainsKey(policies[0]))
04393                                     _c.swadminsgc.SyncSGContainer.Add(policies[0], string.Empty);
04394                                 break;
04395                             case "dkms_admins":
04396                                 if (!_c.adminsgc.SyncAGContainer.ContainsKey(policies[0]))
04397                                     _c.adminsgc.SyncAGContainer.Add(policies[0], string.Empty);
04398                                 break;
04399                             case "dkms_controllers":
04400                                 if (!_c.controllersgc.SyncCGContainer.ContainsKey(policies[0]))
04401                                     _c.controllersgc.SyncCGContainer.Add(policies[0], string.Empty);
04402                                 break;
04403                             case "dkms_custodians":
04404                                 if (!_c.custodiansgc.SyncCGContainer.ContainsKey(policies[0]))
04405                                     _c.custodiansgc.SyncCGContainer.Add(policies[0], string.Empty);
04406                                 break;
04407                             case "dkms_inserters":
04408                                 if (!_c.insertersgc.SyncIGContainer.ContainsKey(policies[0]))
04409                                     _c.insertersgc.SyncIGContainer.Add(policies[0], string.Empty);
04410                                 break;
04411                             case "dkms_swdevelopers":
04412                                 if (!_c.swdevelopersgc.SyncSGContainer.ContainsKey(policies[0]))
04413                                     _c.swdevelopersgc.SyncSGContainer.Add(policies[0], string.Empty);
04414                                 break;
04415                             case "dkms_technicians":
04416                                 if (!_c.techniciansgc.SyncTGContainer.ContainsKey(policies[0]))
04417                                     _c.techniciansgc.SyncTGContainer.Add(policies[0], string.Empty);
04418                                 break;
04419                             case "dkms_operators":
04420                                 if (!_c.operatorsgc.SyncOGContainer.ContainsKey(policies[0]))
04421                                     _c.operatorsgc.SyncOGContainer.Add(policies[0], string.Empty);
04422                                 break;
04423                         }
04424                     }
04425                 }
04426                 catch
04427                 {
04428                     ret = ErrorManager.DKMS_GENERAL_ERROR;
04429                 }
04430                 finally
04431                 {
04432                     if (ret != ErrorManager.DKMS_OK)
04433                     {
04434                         _c.adminsgc.SyncAGContainer.Clear();
04435                         _c.controllersgc.SyncCGContainer.Clear();
04436                         _c.custodiansgc.SyncCGContainer.Clear();
04437                         _c.insertersgc.SyncIGContainer.Clear();
04438                         _c.operatorsgc.SyncOGContainer.Clear();
04439                         _c.swadminsgc.SyncSGContainer.Clear();
04440                         _c.swdevelopersgc.SyncSGContainer.Clear();
04441                         _c.techniciansgc.SyncTGContainer.Clear();
04442                         _c.adminsgc.SyncAGContainer.Add("SetPolicy", string.Empty);
04443                         _c.adminsgc.SyncAGContainer.Add("TestDeviceComunication", string.Empty);
04444                         _c.swadminsgc.SyncSGContainer.Add("SetPolicy", string.Empty);
04445                         _c.swadminsgc.SyncSGContainer.Add("TestDeviceComunication", string.Empty);
04446                         _c.swadminsgc.SyncSGContainer.Add("CloseSession", string.Empty);
04447                     }
04448                 }
04449 
04451                 // Fase 3 Build the responce                
04452                 /* 1 */
04453                 _pm.XMLTXParser_Set_Start("DKMS_SetPolicy", 1);
04454                 /* 2 */
04455                 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04456                 /* 3 */
04457                 _pm.XMLTXParser_Set_End();
04458             }
04459         }
04460 
04461         #endregion
04462 
04463         #region Dispatcher class fields                         
04464         
04466         private CryptoCore.Stmf         _stmf;
04467 
04469         private CryptoCore.Smf          _smf;
04470 
04472         private Containers              _c;        
04473 
04475         private CryptoCore              _cc;
04476 
04478         private ProtocolManager         _pm;
04479 
04481         private ProtocolManager.Config  config;
04482 
04483         #endregion
04484     }   
04485 }

Generated on Tue Jan 10 12:04:19 2006 for DKMS by  doxygen 1.4.6-NO