javamanager/javacaptain/extensionplugins/javacertstore/src/javacertstore.cpp
branchRCL_3
changeset 83 26b2b12093af
parent 25 9ac0a0a7da70
equal deleted inserted replaced
77:7cee158cb8cd 83:26b2b12093af
   194         if ((state == 0 ||
   194         if ((state == 0 ||
   195                 (queryEnabled && iCertsMetadata[i]->state == STATE_ENABLED)
   195                 (queryEnabled && iCertsMetadata[i]->state == STATE_ENABLED)
   196                 || (queryDisabled && iCertsMetadata[i]->state == STATE_DISABLED)
   196                 || (queryDisabled && iCertsMetadata[i]->state == STATE_DISABLED)
   197                 || (queryDeleted && iCertsMetadata[i]->state == STATE_DELETED))
   197                 || (queryDeleted && iCertsMetadata[i]->state == STATE_DELETED))
   198                 && (hash.compare("") == 0
   198                 && (hash.compare("") == 0
   199                     || iCertsMetadata[i]->hash.compare(hash) == 0))
   199                     || iCertsMetadata[i]->hash.compare(hash) == 0 
       
   200                     || iCertsMetadata[i]->pkey.find(hash) == 0))
   200         {
   201         {
   201             // what we return back depends on what was queried
   202             // what we return back depends on what was queried
   202             switch (query)
   203             switch (query)
   203             {
   204             {
   204             case JAVA_CERT_STORE_QUERY_ID_PROTECTION_DOMAIN:
   205             case JAVA_CERT_STORE_QUERY_ID_PROTECTION_DOMAIN:
   209                 // return content, ID (which is the actual hash)
   210                 // return content, ID (which is the actual hash)
   210                 // and the encoded info about the state
   211                 // and the encoded info about the state
   211                 if (replyWithContent(replyMsg, *iCertsMetadata[i]))
   212                 if (replyWithContent(replyMsg, *iCertsMetadata[i]))
   212                 {
   213                 {
   213                     // add also the ID and the state
   214                     // add also the ID and the state
   214                     replyMsg << iCertsMetadata[i]->hash;
   215                     if (iCertsMetadata[i]->pkey.size() > 0)
       
   216                     {
       
   217                         replyMsg << iCertsMetadata[i]->pkey;
       
   218                     }
       
   219                     else
       
   220                     {
       
   221                         replyMsg << iCertsMetadata[i]->hash;
       
   222                     }
   215                     replyMsg << encodeState(iCertsMetadata[i]->disposable,
   223                     replyMsg << encodeState(iCertsMetadata[i]->disposable,
   216                                             iCertsMetadata[i]->disablable,
   224                                             iCertsMetadata[i]->disablable,
   217                                             iCertsMetadata[i]->state);
   225                                             iCertsMetadata[i]->state);
   218                 }
   226                 }
   219                 break;
   227                 break;
   364             const int READ_DOMAIN_NAME = 2;
   372             const int READ_DOMAIN_NAME = 2;
   365             const int READ_DOMAIN_CATEGORY = 3;
   373             const int READ_DOMAIN_CATEGORY = 3;
   366             const int READ_HASH = 4;
   374             const int READ_HASH = 4;
   367             const int READ_REMOVABLE = 5;
   375             const int READ_REMOVABLE = 5;
   368             const int READ_DISABLABLE = 6;
   376             const int READ_DISABLABLE = 6;
       
   377             const int READ_PKEY = 7;
   369 
   378 
   370             // domain_name_info
   379             // domain_name_info
   371             int domain_name_index = 0;
   380             int domain_name_index = 0;
   372             char domain_name[50];
   381             char domain_name[50];
   373 
   382 
   380             char hash[50];
   389             char hash[50];
   381 
   390 
   382             // removable&disablable
   391             // removable&disablable
   383             bool removable = false;
   392             bool removable = false;
   384             bool disablable = false;
   393             bool disablable = false;
       
   394 
       
   395             // pkey info
       
   396             int pkey_index = 0;
       
   397             char pkey[50];
   385 
   398 
   386             // start&end separators for the metadata's keys
   399             // start&end separators for the metadata's keys
   387             bool key_ss = true;
   400             bool key_ss = true;
   388             bool key_es = false;
   401             bool key_es = false;
   389             int retval;
   402             int retval;
   413                         op = READ_REMOVABLE;
   426                         op = READ_REMOVABLE;
   414                         key_ss = false;
   427                         key_ss = false;
   415                         break;
   428                         break;
   416                     case 'd':
   429                     case 'd':
   417                         op = READ_DISABLABLE;
   430                         op = READ_DISABLABLE;
       
   431                         key_ss = false;
       
   432                         break;
       
   433                     case 'p':
       
   434                         op = READ_PKEY;
   418                         key_ss = false;
   435                         key_ss = false;
   419                         break;
   436                         break;
   420                     }
   437                     }
   421                 }
   438                 }
   422                 else
   439                 else
   460                             if ((char)retval == '1')
   477                             if ((char)retval == '1')
   461                             {
   478                             {
   462                                 disablable = true;
   479                                 disablable = true;
   463                             }
   480                             }
   464                             break;
   481                             break;
       
   482                         case READ_PKEY:
       
   483                             pkey[pkey_index] = (char)retval;
       
   484                             pkey_index++;
       
   485                             pkey[pkey_index] = '\0';
       
   486                             break;
   465                         }
   487                         }
   466                     }
   488                     }
   467                 }
   489                 }
   468             }
   490             }
   469             if (domain_name_index > 0
   491             if (domain_name_index > 0
   470                     && domain_category_index > 0
   492                     && domain_category_index > 0
   471                     && hash_index > 0)
   493                     && hash_index > 0)
   472             {
   494             {
       
   495                 if (pkey_index > 0)
       
   496                 {
       
   497                     metadata->pkey = string(pkey, pkey_index);
       
   498                     transform(metadata->pkey.begin(), metadata->pkey.end(), metadata->pkey.begin(), (int(*)(int)) tolower);
       
   499                 }
   473                 metadata->prot_domain_name = string(domain_name, domain_name_index);
   500                 metadata->prot_domain_name = string(domain_name, domain_name_index);
   474                 metadata->prot_domain_category = string(domain_category, domain_category_index);
   501                 metadata->prot_domain_category = string(domain_category, domain_category_index);
   475                 metadata->hash = string(hash, hash_index);
   502                 metadata->hash = string(hash, hash_index);
   476                 transform(metadata->hash.begin(), metadata->hash.end(), metadata->hash.begin(), (int(*)(int)) tolower);
   503                 transform(metadata->hash.begin(), metadata->hash.end(), metadata->hash.begin(), (int(*)(int)) tolower);
   477                 metadata->disposable = removable;
   504                 metadata->disposable = removable;
   550 void JavaCertStore::manageCert(const std::string& cert_id, int state)
   577 void JavaCertStore::manageCert(const std::string& cert_id, int state)
   551 {
   578 {
   552     // go through the certidicates and find the right one
   579     // go through the certidicates and find the right one
   553     for (int i=0; i<no_certs; i++)
   580     for (int i=0; i<no_certs; i++)
   554     {
   581     {
   555         if (cert_id.compare(iCertsMetadata[i]->hash) == 0)
   582         if (cert_id.compare(iCertsMetadata[i]->hash) == 0 || 
       
   583             iCertsMetadata[i]->pkey.find(cert_id) == 0)
   556         {
   584         {
   557             switch (state)
   585             switch (state)
   558             {
   586             {
   559             case STATE_DELETED:
   587             case STATE_DELETED:
   560                 // check if it can be deleted, before deleting it
   588                 // check if it can be deleted, before deleting it
   782     vector<CERT_METADATA *>::iterator startIterator;
   810     vector<CERT_METADATA *>::iterator startIterator;
   783     startIterator = iCertsMetadata.begin();
   811     startIterator = iCertsMetadata.begin();
   784     bool found = false;
   812     bool found = false;
   785     for (int i=0; i<no_certs; i++)
   813     for (int i=0; i<no_certs; i++)
   786     {
   814     {
   787         if (iCertsMetadata[i]->hash.compare(metadata->hash) == 0)
   815         if (iCertsMetadata[i]->hash.compare(metadata->hash) == 0 
       
   816             && iCertsMetadata[i]->pkey.find(metadata->pkey) == 0)
   788         {
   817         {
   789             if (overwrite)
   818             if (overwrite)
   790             {
   819             {
   791                 delete iCertsMetadata[i];
   820                 delete iCertsMetadata[i];
   792                 iCertsMetadata.erase(startIterator + i);
   821                 iCertsMetadata.erase(startIterator + i);