/*
* Get the session key from a pubkey enc packet and return it in DEK,
* which should have been allocated in secure memory by the caller.
*/
gpg_error_t
get_session_key (PKT_pubkey_enc * k, DEK * dek)
{
PKT_public_key *sk = NULL;
int rc;
rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
if (rc)
goto leave;
if ((k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets)
{
sk = xmalloc_clear (sizeof *sk);
sk->pubkey_algo = k->pubkey_algo; /* We want a pubkey with this algo. */
if (!(rc = get_seckey (sk, k->keyid)))
rc = get_it (k, dek, sk, k->keyid);
}
else if (opt.skip_hidden_recipients)
rc = gpg_error (GPG_ERR_NO_SECKEY);
else /* Anonymous receiver: Try all available secret keys. */
{
void *enum_context = NULL;
u32 keyid[2];
for (;;)
{
if (sk)
free_public_key (sk);
sk = xmalloc_clear (sizeof *sk);
rc = enum_secret_keys (&enum_context, sk);
if (rc)
{
rc = G10ERR_NO_SECKEY;
break;
}
if (sk->pubkey_algo != k->pubkey_algo)
continue;
if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
continue;
keyid_from_pk (sk, keyid);
log_info (_("anonymous recipient; trying secret key %s ...\n"),
keystr (keyid));
rc = get_it (k, dek, sk, keyid);
if (!rc)
{
log_info (_("okay, we are the anonymous recipient.\n"));
break;
}
else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
break; /* Don't try any more secret keys. */
}
enum_secret_keys (&enum_context, NULL); /* free context */
}
leave:
if (sk)
free_public_key (sk);
return rc;
}
/****************
* Get the session key from a pubkey enc paket and return
* it in DEK, which should have been allocated in secure memory.
*/
int
get_session_key( PKT_pubkey_enc *k, DEK *dek )
{
PKT_secret_key *sk = NULL;
int rc;
rc = check_pubkey_algo( k->pubkey_algo );
if( rc )
goto leave;
if( (k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets ) {
sk = m_alloc_clear( sizeof *sk );
sk->pubkey_algo = k->pubkey_algo; /* we want a pubkey with this algo*/
if( !(rc = get_seckey( sk, k->keyid )) )
rc = get_it( k, dek, sk, k->keyid );
}
else { /* anonymous receiver: Try all available secret keys */
void *enum_context = NULL;
u32 keyid[2];
for(;;) {
if( sk )
free_secret_key( sk );
sk = m_alloc_clear( sizeof *sk );
rc=enum_secret_keys( &enum_context, sk, 1);
if( rc ) {
rc = G10ERR_NO_SECKEY;
break;
}
if( sk->pubkey_algo != k->pubkey_algo )
continue;
keyid_from_sk( sk, keyid );
log_info(_("anonymous receiver; trying secret key %08lX ...\n"),
(ulong)keyid[1] );
rc = check_secret_key( sk, 1 ); /* ask only once */
if( !rc )
rc = get_it( k, dek, sk, keyid );
if( !rc ) {
log_info(_("okay, we are the anonymous recipient.\n") );
break;
}
}
enum_secret_keys( &enum_context, NULL, 0 ); /* free context */
}
leave:
if( sk )
free_secret_key( sk );
return rc;
}
/****************
* Get the session key from a pubkey enc packet and return
* it in DEK, which should have been allocated in secure memory.
*/
int
get_session_key( PKT_pubkey_enc *k, DEK *dek )
{
PKT_secret_key *sk = NULL;
int rc;
rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
if( rc )
goto leave;
if( (k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets ) {
sk = xmalloc_clear( sizeof *sk );
sk->pubkey_algo = k->pubkey_algo; /* we want a pubkey with this algo*/
if( !(rc = get_seckey( sk, k->keyid )) )
rc = get_it( k, dek, sk, k->keyid );
}
else { /* anonymous receiver: Try all available secret keys */
void *enum_context = NULL;
u32 keyid[2];
char *p;
for(;;) {
if( sk )
free_secret_key( sk );
sk = xmalloc_clear( sizeof *sk );
rc=enum_secret_keys( &enum_context, sk, 1, 0);
if( rc ) {
rc = G10ERR_NO_SECKEY;
break;
}
if( sk->pubkey_algo != k->pubkey_algo )
continue;
keyid_from_sk( sk, keyid );
log_info(_("anonymous recipient; trying secret key %s ...\n"),
keystr(keyid));
if(!opt.try_all_secrets && !is_status_enabled())
{
p=get_last_passphrase();
set_next_passphrase(p);
xfree(p);
}
rc = check_secret_key( sk, opt.try_all_secrets?1:-1 ); /* ask
only
once */
if( !rc )
{
rc = get_it( k, dek, sk, keyid );
/* Successfully checked the secret key (either it was
a card, had no passphrase, or had the right
passphrase) but couldn't decrypt the session key,
so thus that key is not the anonymous recipient.
Move the next passphrase into last for the next
round. We only do this if the secret key was
successfully checked as in the normal case,
check_secret_key handles this for us via
passphrase_to_dek */
if(rc)
next_to_last_passphrase();
}
if( !rc )
{
log_info(_("okay, we are the anonymous recipient.\n") );
break;
}
}
enum_secret_keys( &enum_context, NULL, 0, 0 ); /* free context */
}
leave:
if( sk )
free_secret_key( sk );
return rc;
}
void init_Spatial_Pooler(py::module& m)
{
py::class_<SpatialPooler> py_SpatialPooler(m, "SpatialPooler");
py_SpatialPooler.def(
py::init<vector<UInt>
, vector<UInt>
, UInt
, Real
, bool
, Real
, UInt
, UInt
, Real
, Real
, Real
, Real
, UInt
, Real
, Int
, UInt
, bool>()
, py::arg("inputDimensions") = vector<UInt>({ 32, 32 })
, py::arg("columnDimensions") = vector<UInt>({ 64, 64 })
, py::arg("potentialRadius") = 16
, py::arg("potentialPct") = 0.5
, py::arg("globalInhibition") = false
, py::arg("localAreaDensity") = -1.0
, py::arg("numActiveColumnsPerInhArea") = 10
, py::arg("stimulusThreshold") = 0
, py::arg("synPermInactiveDec") = 0.01
, py::arg("synPermActiveInc") = 0.1
, py::arg("synPermConnected") = 0.1
, py::arg("minPctOverlapDutyCycle") = 0.001
, py::arg("dutyCyclePeriod") = 1000
, py::arg("boostStrength") = 0.0
, py::arg("seed") = -1
, py::arg("spVerbosity") = 0
, py::arg("wrapAround") = true
);
py_SpatialPooler.def("initialize", &SpatialPooler::initialize
, py::arg("inputDimensions") = vector<UInt>({ 32, 32 })
, py::arg("columnDimensions") = vector<UInt>({ 64, 64 })
, py::arg("potentialRadius") = 16
, py::arg("potentialPct") = 0.5
, py::arg("globalInhibition") = false
, py::arg("localAreaDensity") = -1.0
, py::arg("numActiveColumnsPerInhArea") = 10
, py::arg("stimulusThreshold") = 0
, py::arg("synPermInactiveDec") = 0.01
, py::arg("synPermActiveInc") = 0.1
, py::arg("synPermConnected") = 0.1
, py::arg("minPctOverlapDutyCycle") = 0.001
, py::arg("dutyCyclePeriod") = 1000
, py::arg("boostStrength") = 0.0
, py::arg("seed") = -1
, py::arg("spVerbosity") = 0
, py::arg("wrapAround") = true);
py_SpatialPooler.def("getColumnDimensions", &SpatialPooler::getColumnDimensions);
py_SpatialPooler.def("getInputDimensions", &SpatialPooler::getInputDimensions);
py_SpatialPooler.def("getNumColumns", &SpatialPooler::getNumColumns);
py_SpatialPooler.def("getNumInputs", &SpatialPooler::getNumInputs);
py_SpatialPooler.def("getPotentialRadius", &SpatialPooler::getPotentialRadius);
py_SpatialPooler.def("setPotentialRadius", &SpatialPooler::setPotentialRadius);
py_SpatialPooler.def("getPotentialPct", &SpatialPooler::getPotentialPct);
py_SpatialPooler.def("setPotentialPct", &SpatialPooler::setPotentialPct);
py_SpatialPooler.def("getGlobalInhibition", &SpatialPooler::getGlobalInhibition);
py_SpatialPooler.def("setGlobalInhibition", &SpatialPooler::setGlobalInhibition);
py_SpatialPooler.def("getNumActiveColumnsPerInhArea", &SpatialPooler::getNumActiveColumnsPerInhArea);
py_SpatialPooler.def("setNumActiveColumnsPerInhArea", &SpatialPooler::setNumActiveColumnsPerInhArea);
py_SpatialPooler.def("getLocalAreaDensity", &SpatialPooler::getLocalAreaDensity);
py_SpatialPooler.def("setLocalAreaDensity", &SpatialPooler::setLocalAreaDensity);
py_SpatialPooler.def("getStimulusThreshold", &SpatialPooler::getStimulusThreshold);
py_SpatialPooler.def("setStimulusThreshold", &SpatialPooler::setStimulusThreshold);
py_SpatialPooler.def("getInhibitionRadius", &SpatialPooler::getInhibitionRadius);
py_SpatialPooler.def("setInhibitionRadius", &SpatialPooler::setInhibitionRadius);
py_SpatialPooler.def("getDutyCyclePeriod", &SpatialPooler::getDutyCyclePeriod);
py_SpatialPooler.def("setDutyCyclePeriod", &SpatialPooler::setDutyCyclePeriod);
py_SpatialPooler.def("getBoostStrength", &SpatialPooler::getBoostStrength);
py_SpatialPooler.def("setBoostStrength", &SpatialPooler::setBoostStrength);
py_SpatialPooler.def("getIterationNum", &SpatialPooler::getIterationNum);
py_SpatialPooler.def("setIterationNum", &SpatialPooler::setIterationNum);
py_SpatialPooler.def("getIterationLearnNum", &SpatialPooler::getIterationLearnNum);
py_SpatialPooler.def("setIterationLearnNum", &SpatialPooler::setIterationLearnNum);
py_SpatialPooler.def("getSpVerbosity", &SpatialPooler::getSpVerbosity);
py_SpatialPooler.def("setSpVerbosity", &SpatialPooler::setSpVerbosity);
py_SpatialPooler.def("getWrapAround", &SpatialPooler::getWrapAround);
py_SpatialPooler.def("setWrapAround", &SpatialPooler::setWrapAround);
py_SpatialPooler.def("getUpdatePeriod", &SpatialPooler::getUpdatePeriod);
py_SpatialPooler.def("setUpdatePeriod", &SpatialPooler::setUpdatePeriod);
py_SpatialPooler.def("getSynPermActiveInc", &SpatialPooler::getSynPermActiveInc);
py_SpatialPooler.def("setSynPermActiveInc", &SpatialPooler::setSynPermActiveInc);
py_SpatialPooler.def("getSynPermInactiveDec", &SpatialPooler::getSynPermInactiveDec);
py_SpatialPooler.def("setSynPermInactiveDec", &SpatialPooler::setSynPermInactiveDec);
py_SpatialPooler.def("getSynPermBelowStimulusInc", &SpatialPooler::getSynPermBelowStimulusInc);
py_SpatialPooler.def("setSynPermBelowStimulusInc", &SpatialPooler::setSynPermBelowStimulusInc);
py_SpatialPooler.def("getSynPermConnected", &SpatialPooler::getSynPermConnected);
py_SpatialPooler.def("getSynPermMax", &SpatialPooler::getSynPermMax);
py_SpatialPooler.def("getMinPctOverlapDutyCycles", &SpatialPooler::getMinPctOverlapDutyCycles);
py_SpatialPooler.def("setMinPctOverlapDutyCycles", &SpatialPooler::setMinPctOverlapDutyCycles);
// loadFromString
py_SpatialPooler.def("loadFromString", [](SpatialPooler& self, const std::string& inString)
{
std::istringstream inStream(inString);
self.load(inStream);
});
// writeToString
py_SpatialPooler.def("writeToString", [](const SpatialPooler& self)
{
std::ostringstream os;
os.flags(ios::scientific);
os.precision(numeric_limits<double>::digits10 + 1);
self.save(os);
return os.str();
});
// compute
py_SpatialPooler.def("compute", [](SpatialPooler& self, py::array& x, bool learn, py::array& y)
{
if (py::isinstance<py::array_t<std::uint32_t>>(x) == false)
{
throw runtime_error("Incompatible format. Expect uint32");
}
if (py::isinstance<py::array_t<std::uint32_t>>(y) == false)
{
throw runtime_error("Incompatible format. Expect uint32");
}
self.compute(get_it<UInt>(x), learn, get_it<UInt>(y));
});
// stripUnlearnedColumns
py_SpatialPooler.def("stripUnlearnedColumns", [](SpatialPooler& self, py::array_t<UInt>& x)
{
self.stripUnlearnedColumns(get_it(x));
});
// setBoostFactors
py_SpatialPooler.def("setBoostFactors", [](SpatialPooler& self, py::array_t<Real>& x)
{
self.setBoostFactors(get_it(x));
});
// getBoostFactors
py_SpatialPooler.def("getBoostFactors", [](const SpatialPooler& self, py::array_t<Real>& x)
{
self.getBoostFactors(get_it(x));
});
// setOverlapDutyCycles
py_SpatialPooler.def("setOverlapDutyCycles", [](SpatialPooler& self, py::array_t<Real>& x)
{
self.setOverlapDutyCycles(get_it(x));
});
// getOverlapDutyCycles
py_SpatialPooler.def("getOverlapDutyCycles", [](const SpatialPooler& self, py::array_t<Real>& x)
{
self.getOverlapDutyCycles(get_it(x));
});
// setActiveDutyCycles
py_SpatialPooler.def("setActiveDutyCycles", [](SpatialPooler& self, py::array_t<Real>& x)
{
self.setActiveDutyCycles(get_it(x));
});
// getActiveDutyCycles
py_SpatialPooler.def("getActiveDutyCycles", [](const SpatialPooler& self, py::array_t<Real>& x)
{
self.getActiveDutyCycles(get_it(x));
});
// setMinOverlapDutyCycles
py_SpatialPooler.def("setMinOverlapDutyCycles", [](SpatialPooler& self, py::array_t<Real>& x)
{
self.setMinOverlapDutyCycles(get_it(x));
});
// getMinOverlapDutyCycles
py_SpatialPooler.def("getMinOverlapDutyCycles", [](const SpatialPooler& self, py::array_t<Real>& x)
{
self.getMinOverlapDutyCycles(get_it(x));
});
// setPotential
py_SpatialPooler.def("setPotential", [](SpatialPooler& self, UInt column, py::array_t<UInt>& x)
{
self.setPotential(column, get_it(x));
});
// getPotential
py_SpatialPooler.def("getPotential", [](const SpatialPooler& self, UInt column, py::array_t<UInt>& x)
{
self.getPotential(column, get_it(x));
});
// setPermanence
py_SpatialPooler.def("setPermanence", [](SpatialPooler& self, UInt column, py::array_t<Real>& x)
{
self.setPermanence(column, get_it(x));
});
// getPermanence
py_SpatialPooler.def("getPermanence", [](const SpatialPooler& self, UInt column, py::array_t<Real>& x)
{
self.getPermanence(column, get_it(x));
});
// getConnectedSynapses
py_SpatialPooler.def("getConnectedSynapses", [](const SpatialPooler& self, UInt column, py::array_t<UInt>& x)
{
self.getConnectedSynapses(column, get_it(x));
});
// getConnectedCounts
py_SpatialPooler.def("getConnectedCounts", [](const SpatialPooler& self, py::array_t<UInt>& x)
{
self.getConnectedCounts(get_it(x));
});
// getOverlaps
py_SpatialPooler.def("getOverlaps", [](SpatialPooler& self)
{
auto overlaps = self.getOverlaps();
return py::array_t<UInt>( overlaps.size(), overlaps.data());
});
// getBoostedOverlaps
py_SpatialPooler.def("getBoostedOverlaps", [](SpatialPooler& self)
{
auto overlaps = self.getBoostedOverlaps();
return py::array_t<Real>( overlaps.size(), overlaps.data());
});
////////////////////
// inhibitColumns
auto inhibitColumns_func = [](SpatialPooler& self, py::array_t<Real>& overlaps)
{
std::vector<nupic::Real> overlapsVector(get_it(overlaps), get_end(overlaps));
std::vector<nupic::UInt> activeColumnsVector;
self.inhibitColumns_(overlapsVector, activeColumnsVector);
return py::array_t<UInt>( activeColumnsVector.size(), activeColumnsVector.data());
};
py_SpatialPooler.def("_inhibitColumns", inhibitColumns_func);
py_SpatialPooler.def("inhibitColumns_", inhibitColumns_func);
//////////////////////
// getIterationLearnNum
py_SpatialPooler.def("getIterationLearnNum", &SpatialPooler::getIterationLearnNum);
// pickle
py_SpatialPooler.def(py::pickle(
[](const SpatialPooler& sp)
{
std::stringstream ss;
sp.save(ss);
return ss.str();
},
[](std::string& s)
{
std::istringstream ss(s);
SpatialPooler sp;
sp.load(ss);
return sp;
}));
}
void show_sockopts(QSP_ARG_DECL Port *mpp)
{
char valbuf[VBUFSIZ];
socklen_t vbsiz=VBUFSIZ;
int *ival=(int *)valbuf;
sprintf(msg_str,"Options for socket \"%s\":",mpp->mp_name);
prt_msg(msg_str);
get_it( SO_DEBUG )
sprintf(msg_str,"\tDEBUG\t%d",*ival);
prt_msg(msg_str);
get_it( SO_REUSEADDR )
sprintf(msg_str,"\tREUSEADDR\t%d",*ival);
prt_msg(msg_str);
get_it( SO_KEEPALIVE )
sprintf(msg_str,"\tKEEPALIVE\t%d",*ival);
prt_msg(msg_str);
get_it( SO_DONTROUTE )
sprintf(msg_str,"\tDONTROUTE\t%d",*ival);
prt_msg(msg_str);
get_it( SO_LINGER )
sprintf(msg_str,"\tLINGER\t%d",*ival);
prt_msg(msg_str);
#ifdef SO_BROADCAST
get_it( SO_BROADCAST )
sprintf(msg_str,"\tBROADCAST\t%d",*ival);
prt_msg(msg_str);
#endif
#ifdef SO_OOBINLINE
get_it( SO_OOBINLINE )
sprintf(msg_str,"\tOOBINLINE\t%d",*ival);
prt_msg(msg_str);
#endif
#ifdef SO_SNDBUF
get_it( SO_SNDBUF )
sprintf(msg_str,"\tSNDBUF\t%d",*ival);
prt_msg(msg_str);
#endif
#ifdef SO_RCVBUF
get_it( SO_RCVBUF )
sprintf(msg_str,"\tRCVBUF\t%d",*ival);
prt_msg(msg_str);
#endif
#ifdef SO_TYPE
get_it( SO_TYPE )
sprintf(msg_str,"\tTYPE\t%d",*ival);
prt_msg(msg_str);
#endif
#ifdef SO_ERROR
get_it( SO_ERROR )
sprintf(msg_str,"\tERROR\t%d",*ival);
prt_msg(msg_str);
#endif
}
card::card(std::istream & in):value_(get_it(in)){
std::clog << "Card instance created from " << value_ << " supplied from input.\n";
}
// removes the operation from workload1
int removeOp(int op)
{
//cout << "Removing " << op << ", index=" << indices[op] << ", sector=" << sector[op] << ", ti=" << ti[op] << endl;
// for calculating the max_ti
int max_val = -1;
int max_index = -1;
// make sure we are removing from workload1
if ( indices[op] < 0 )
{
cout << "ERROR: Trying to remove from workload2. (" << op << "," << sector[op] << "," << ti[op] << ")" << endl;
exit(-1);
}
//-----------------------------------------------------------------------
//------------------- Variables -----------------------------------------
//-----------------------------------------------------------------------
// mark the op as now being in workload 2
int index = indices[op];
int op_sector = sector[op];
indices[op] = -1;
il--;
// for checking if a previous operation was for the same sector
int prev_op = -1;
int next_op = -1;
//-----------------------------------------------------------------------
//------------- Find operations before op that have next op with same sector
//------------------- after the removed op and adjust TI
//------------- Find the prev op has the same sector
//-----------------------------------------------------------------------
// Loop over the operations before this op
for (int i=0; i<op; i++)
{
if ( isWL1(i) )
{
// if any previous operation has IT after this, decrease it's TI by 1
if ( get_it(i) > index )
ti[i]--;
// check if a previous operation references the same sector
if ( sector[i] == op_sector )
{
prev_op = i;
//cout << "Found one! " << sector[op] << " in " << op << " and " << prev_op << endl;
}
// for calculating max
if ( ti[i] > max_val )
{
max_val = ti[i];
max_index = i;
}
}
}
//-----------------------------------------------------------------------
//----------- Decrement the indices after op removal --------------------
//----------- Find the next operation with the same sector --------------
//-----------------------------------------------------------------------
// Loop over the operations after op
for (int i=op; i<l; i++)
{
if ( isWL1(i) )
{
// we removed an item from workload1 and so every index after it is changed
indices[i]--;
// for calculating max
if ( ti[i] > max_val )
{
max_val = ti[i];
max_index = i;
}
}
// check if a future op is the same sector
if ( sector[i] == op_sector && next_op < 0 )
{
next_op = i;
//cout << "Found one! " << sector[op] << " in " << op << " and " << prev_op << endl;
}
}
//-----------------------------------------------------------------------
//-------------- Working with previous operation and next operation -----
//-----------------------------------------------------------------------
// If the op removed was the TI of a previous workload, fix it
if ( prev_op > 0 )
{
// mark it as needing to produce a del operation. Will have to be double checked during writing
indices[op] = -1 - prev_op;
/*
// Find the next op that has the same sector on it
for (int i=op+1; i<l; i++)
{
if ( isWL1(i) )
{
if ( sector[i] == sector[prev_op] )
{
found = true;
ti[prev_op] = indices[i] - indices[prev_op];
}
}
}
// Not found. Point to the end of the workload
if (found == false)
{
ti[prev_op] = il-indices[prev_op];
}*/
}
if ( next_op > 0 )
{
if ( isWL1(next_op) )
{
flag[next_op] = WORKLOAD2_DELOP;
cout << "Setting up a Del Op for workload2" << endl;
}
}
return max_index;
}
/*
* Get the session key from a pubkey enc packet and return it in DEK,
* which should have been allocated in secure memory by the caller.
*/
gpg_error_t
get_session_key (ctrl_t ctrl, PKT_pubkey_enc * k, DEK * dek)
{
PKT_public_key *sk = NULL;
int rc;
if (DBG_CLOCK)
log_clock ("get_session_key enter");
rc = openpgp_pk_test_algo2 (k->pubkey_algo, PUBKEY_USAGE_ENC);
if (rc)
goto leave;
if ((k->keyid[0] || k->keyid[1]) && !opt.try_all_secrets)
{
sk = xmalloc_clear (sizeof *sk);
sk->pubkey_algo = k->pubkey_algo; /* We want a pubkey with this algo. */
if (!(rc = get_seckey (ctrl, sk, k->keyid)))
{
/* Check compliance. */
if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_DECRYPTION,
sk->pubkey_algo,
sk->pkey, nbits_from_pk (sk), NULL))
{
log_info (_("key %s is not suitable for decryption"
" in %s mode\n"),
keystr_from_pk (sk),
gnupg_compliance_option_string (opt.compliance));
rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
}
else
rc = get_it (ctrl, k, dek, sk, k->keyid);
}
}
else if (opt.skip_hidden_recipients)
rc = gpg_error (GPG_ERR_NO_SECKEY);
else /* Anonymous receiver: Try all available secret keys. */
{
void *enum_context = NULL;
u32 keyid[2];
for (;;)
{
free_public_key (sk);
sk = xmalloc_clear (sizeof *sk);
rc = enum_secret_keys (ctrl, &enum_context, sk);
if (rc)
{
rc = GPG_ERR_NO_SECKEY;
break;
}
if (sk->pubkey_algo != k->pubkey_algo)
continue;
if (!(sk->pubkey_usage & PUBKEY_USAGE_ENC))
continue;
keyid_from_pk (sk, keyid);
if (!opt.quiet)
log_info (_("anonymous recipient; trying secret key %s ...\n"),
keystr (keyid));
/* Check compliance. */
if (! gnupg_pk_is_allowed (opt.compliance, PK_USE_DECRYPTION,
sk->pubkey_algo,
sk->pkey, nbits_from_pk (sk), NULL))
{
log_info (_("key %s is not suitable for decryption"
" in %s mode\n"),
keystr_from_pk (sk),
gnupg_compliance_option_string (opt.compliance));
continue;
}
rc = get_it (ctrl, k, dek, sk, keyid);
if (!rc)
{
if (!opt.quiet)
log_info (_("okay, we are the anonymous recipient.\n"));
break;
}
else if (gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
break; /* Don't try any more secret keys. */
}
enum_secret_keys (ctrl, &enum_context, NULL); /* free context */
}
leave:
free_public_key (sk);
if (DBG_CLOCK)
log_clock ("get_session_key leave");
return rc;
}
