#include "account.h"#ifdef HAVE_UNISTD_H#include <unistd.h>#endifusing namespace std;CORBA::ORB_var orb;CORBA::Object_var securitymanager;SecurityLevel2::SecurityManager_var secman;intmain (int argc, char *argv[]) {  CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "mico-local-orb");  // Get SecurityManager  // The SecurityManager contains among others the Credentials  securitymanager = orb->resolve_initial_references ("SecurityManager");  secman = SecurityLevel2::SecurityManager::_narrow(securitymanager);  assert (!CORBA::is_nil (secman));  ////////////////////////////////////////////////////////////////////////////////////////////  //Mechanisms output  //to display all supported mechanisms availiable for orb	  Security::MechandOptionsList* p_mech_list = secman -> supported_mechanisms();  Security::MechandOptions mech_opt;    cout << "Mechanisms" << endl;  for (CORBA::ULong i=0; i < p_mech_list -> length(); i++) {    mech_opt = (*p_mech_list)[i];    cout << (char *)mech_opt.mechanism_type << endl;  }	    //setting of method (it is const)   Security::AuthenticationMethod our_method = (Security::AuthenticationMethod)SecurityLevel2::KeyCertCAPass;    //loading data for our method    Security::SSLKeyCertCAPass *method_struct;  method_struct = new Security::SSLKeyCertCAPass;  CORBA::Any* any_struct = secman -> get_method_data(our_method);  *any_struct >>= *method_struct;  method_struct -> key = "ClientKey.pem";  method_struct -> cert = "ClientCert.pem";  method_struct -> CAfile = "";  method_struct -> CAdir = "";  method_struct -> pass = "";    CORBA::Any* out_any_struct;  out_any_struct = new CORBA::Any;  *out_any_struct <<= *method_struct;	  cout << "///////////////////////////////////////////////////////////////////////////\n";    ////////////////////////////////////////////////////////////////////////////////////////    //authentiction process - Security Manager authenticates itself	by principal authenticator  //and sets own_credentials (it occurs within authenticate(...) method)	    SecurityLevel2::PrincipalAuthenticator_ptr pa = secman -> principal_authenticator();  //const char* mechanism = "";   const char* security_name = "ssl";   Security::AttributeList privileges;   SecurityLevel2::Credentials_ptr creds;   CORBA::Any* continuation_data;   CORBA::Any* auth_specific_data;    try    {      pa -> authenticate( our_method, "", security_name, *out_any_struct,privileges, creds,continuation_data,auth_specific_data);	    }  catch (...)    {      cout << "authentication failed" <<endl;      delete out_any_struct;      return 0;    }      delete out_any_struct;///////////////////////////////////////////////////////////////////////////////////////// //getting of own credentials (first from own credentials list)	    SecurityLevel2::Credentials_ptr own_cred;  own_cred = (*(secman -> own_credentials()))[0];	  //we can request own credentials attributes   Security::ExtensibleFamily fam1;  fam1.family_definer = 0;  fam1.family = 1;  Security::AttributeType at1;  at1.attribute_family = fam1;  at1.attribute_type = Security::AccessId;  Security::AttributeTypeList atl1;    atl1.length(1);  atl1[0]=at1;		  //getting  the attributes from the Credentials  Security::AttributeList_var al1 = own_cred->get_attributes(atl1);  //output	  cout << "Own credentials"        << (*al1).length() << " attributes\n";    for (CORBA::ULong ctr = 0; ctr < (*al1).length(); ctr++) {    cout        << "family = "			<< (*al1)[ctr].attribute_type.attribute_family.family << " "      << "type = "      << (*al1)[ctr].attribute_type.attribute_type << " "      <<  &(*al1)[ctr].value[0] << " "      << &(*al1)[ctr].defining_authority[0]      << endl;  }  cout << "///////////////////////////////////////////////////////////////////////////\n";  /////////////////////////////////////////////////////////////////////////////////////////   // Connect to the Bank  /*   * IOR is in Bank.ref in the local directory   */    char pwd[256], uri[300];  sprintf (uri, "file://%s/Bank.ref", getcwd(pwd, 256));  /*   * Connect to the Bank   */  CORBA::Object_var obj = orb->string_to_object (uri);  Bank_var bank = Bank::_narrow (obj);  assert (!CORBA::is_nil (bank));  // Get the Credentials  // The Credentials contains the security attributes of the server, but not  // directly. Normally they are just a reference to a object specific to   // the security mechanism.  /////////////////////////////////////////////////////////////////////////////////////////   //getting target credentials  //Get and print attributes of server  Security::ExtensibleFamily fam2;  fam2.family_definer = 0;  fam2.family = 1;  Security::AttributeType at;  at.attribute_family = fam2;  at.attribute_type = Security::AccessId;  Security::AttributeTypeList atl;  atl.length(2);  atl[0]=at;  Security::AttributeType at2;  fam2.family = 11;  at2.attribute_family = fam2;  at2.attribute_type = Security::PeerAddress;  atl[1]=at2;  SecurityLevel2::TargetCredentials_var tc = secman->get_target_credentials(bank);  SecurityLevel2::CredentialsList* init_creds = tc -> initiating_credentials();  SecurityLevel2::Credentials_var cred = (*init_creds)[0];	  // get the attributes from the initiating_credentials of tc  Security::AttributeList_var al = cred -> get_attributes(atl);  // and print them  cout << "Initiating credentials "        << (*al).length() << " attributes\n";    for (CORBA::ULong ctr = 0; ctr < (*al).length(); ctr++) {    cout        << "family = "			<< (*al)[ctr].attribute_type.attribute_family.family << " "      << "type = "      << (*al)[ctr].attribute_type.attribute_type << " "      <<  &(*al)[ctr].value[0] << " "      << &(*al)[ctr].defining_authority[0]      << endl;  }  cout << "///////////////////////////////////////////////////////////////////////////\n";  Security::AssociationOptions opt_used = tc -> association_options_used();  cout << "Association_options_used (target credentials)\n" ;      if (Security::NoDelegation == (opt_used & Security::NoDelegation))    cout << "NoDelegaion\n";  if (Security::SimpleDelegation == (opt_used & Security::SimpleDelegation))    cout << "SimpleDelegation\n";  if (Security::CompositeDelegation == (opt_used & Security::CompositeDelegation))    cout << "CompositeDelegation\n";  if (Security::NoProtection == (opt_used & Security::NoProtection))    cout << "NoProtection\n";  if (Security::Integrity == (opt_used & Security::Integrity))    cout << "Integrity\n";  if (Security::Confidentiality == (opt_used & Security::Confidentiality))    cout << "Confidentiality\n";  if (Security::DetectReplay == (opt_used & Security::DetectReplay))    cout << "DetectReplay\n";  if (Security::DetectMisordering == (opt_used & Security::DetectMisordering))    cout << "DetectMisordering\n";  if (Security::EstablishTrustInTarget == (opt_used & Security::EstablishTrustInTarget))    cout << "EstablishTrustInTarget\n";  if (Security::EstablishTrustInClient == (opt_used & Security::EstablishTrustInClient))    cout << "EstablishTrustInClient\n";	  cout << "///////////////////////////////////////////////////////////////////////////\n";  /////////////////////////////////////////////////////////////////////////////////////////   //PolicyCurrent output  cout << "PolicyCurrent" << endl;  CORBA::Object_var policy_current_obj = orb->resolve_initial_references ("PolicyCurrent");  SecurityLevel2::PolicyCurrent_var policy_current = SecurityLevel2::PolicyCurrent::_narrow(policy_current_obj);  assert (!CORBA::is_nil (policy_current));    CORBA::PolicyTypeSeq policy_types;  policy_types.length(0);   CORBA::PolicyList_var  policies = policy_current -> get_policy_overrides(policy_types);    for (CORBA::ULong i=0; i < policies -> length(); i++) {    CORBA::Policy_ptr policy = (*policies)[i];    CORBA::PolicyType type = policy -> policy_type();    if (type == Security::SecMechanismPolicy) {	cout << "MechanismPolicy" << endl;	SecurityLevel2::MechanismPolicy_ptr mp  = SecurityLevel2::MechanismPolicy::_narrow(policy);	Security::MechanismTypeList* mech = mp -> mechanisms();	for (CORBA::ULong i=0; i < mech -> length(); i++) 	    cout << (char *)((*mech)[i]) << endl;	continue;      }     if (type == Security::SecInvocationCredentialsPolicy){	cout << "InvocationCredentialsPolicy" << endl;	SecurityLevel2::InvocationCredentialsPolicy_ptr icp  = SecurityLevel2::InvocationCredentialsPolicy::_narrow(policy);	SecurityLevel2::CredentialsList* cred =  icp -> creds();	int len = cred -> length();	for (int i = 0; i < len; i++) {	  SecurityLevel2::Credentials_ptr own_cred;	  own_cred = (*cred)[i];	  	  Security::ExtensibleFamily fam1;	  fam1.family_definer = 0;	  fam1.family = 1;	  Security::AttributeType at1;	  at1.attribute_family = fam1;	  at1.attribute_type = Security::AccessId;	  Security::AttributeTypeList atl1;	  atl1.length(1);	  atl1[0]=at1;	  Security::AttributeList_var al1 = own_cred->get_attributes(atl1);	  cout << "Own " 	       << (*al1).length() << " attributes\n";	  	  for (CORBA::ULong ctr = 0; ctr < (*al1).length(); ctr++) {	    cout  	      << (*al1)[ctr].attribute_type.attribute_family.family << " "	      << (*al1)[ctr].attribute_type.attribute_type << " "	      <<  &(*al1)[ctr].value[0] << " "	      << &(*al1)[ctr].defining_authority[0]	      << endl;	  }	}	continue;      }	if (type == Security::SecQOPPolicy) {		  cout << "QOPPolicy" << endl;	  continue;      }     if (type == Security::SecDelegationDirectivePolicy) {	cout << "DelegationDirectivePolicy" << endl;	continue;      }     if (type == Security::SecEstablishTrustPolicy) {      SecurityLevel2::EstablishTrustPolicy_ptr etp  = SecurityLevel2::EstablishTrustPolicy::_narrow(policy);      if (etp -> trust().trust_in_client)	  cout << "EstablishTrustPolicy - trust in client" << endl;      else 	  cout << "EstablishTrustPolicy - trust in target" << endl;      continue;    }     cout << "Invalid type!!" << endl;  }	  cout << "///////////////////////////////////////////////////////////////////////////\n";  policy_current -> set_policy_overrides(policies,CORBA::SET_OVERRIDE);    //  // Open an account  //  Account_var account = bank->create ();  if (CORBA::is_nil (account)) {    cout << "oops: account is nil" << endl;    exit (1);  }  //  // Deposit and withdraw some money  //  // SecurityPolicies on IOR are not supported yet.  //  CORBA::Policy_var ior_policy = account->_get_policy(Security::SecTargetInvocationAccess);  cout << "deposit - 700\n";  account->deposit (700);  cout << "withdraw - 450\n";  account->withdraw (450);  cout << "Balance is " << account->balance () << "." << endl;  return 0;}