connection_engine::connection_engine(class handler &h, const connection_options& opts) {
connection_ = proton::connection(take_ownership(pn_connection()).get());
pn_ptr<pn_transport_t> transport = take_ownership(pn_transport());
pn_ptr<pn_collector_t> collector = take_ownership(pn_collector());
if (!connection_ || !transport || !collector)
throw proton::error("engine create");
int err = pn_transport_bind(transport.get(), connection_.pn_object());
if (err)
throw error(msg() << "transport bind:" << pn_code(err));
pn_connection_collect(connection_.pn_object(), collector.get());
ctx_ = &connection_engine_context::get(connection_); // Creates context
ctx_->engine_handler = &h;
ctx_->transport = transport.release();
ctx_->collector = collector.release();
opts.apply(connection_);
// Provide defaults for connection_id and link_prefix if not set.
std::string cid = connection_.container_id();
if (cid.empty()) {
cid = make_id();
pn_connection_set_container(connection_.pn_object(), cid.c_str());
}
id_generator &link_gen = connection_context::get(connection_).link_gen;
if (link_gen.prefix().empty()) {
link_gen.prefix(make_id()+"/");
}
}
inline x509v3_context x509v3_context::create()
{
pointer _ptr = new X509V3_CTX();
error::throw_error_if_not(_ptr);
return take_ownership(_ptr);
}
inline store store::create()
{
pointer _ptr = X509_STORE_new();
throw_error_if_not(_ptr);
return take_ownership(_ptr);
}
inline certificate_request certificate_request::create()
{
pointer _ptr = X509_REQ_new();
error::throw_error_if_not(_ptr);
return take_ownership(_ptr);
}
inline extension extension::create()
{
pointer _ptr = X509_EXTENSION_new();
error::throw_error_if_not(_ptr);
return take_ownership(_ptr);
}
inline name_entry name_entry::create()
{
pointer _ptr = X509_NAME_ENTRY_new();
error::throw_error_if_not(_ptr);
return take_ownership(_ptr);
}
bignum bignum::from_dec(const std::string& str)
{
BIGNUM* bn = NULL;
error::throw_error_if_not(BN_dec2bn(&bn, str.c_str()) != 0);
return take_ownership(bn);
}
// Fill LVector with the basis functions corresponding to each real DOF
void LVector::fillBasis(double x, double y, double sigma)
{
take_ownership();
// fill with psi_pq(z), where psi now defined to have 1/sigma^2 in
// front.
std::complex<double> z(x,-y);
double rsq = norm(z);
double tq = std::exp(-0.5*rsq) / (2*M_PI*sigma*sigma);
double tqm1=tq;
double tqm2;
// Ascend m=0 first
(*_v)[PQIndex(0,0).rIndex()]=tq;
if (_order>=2) {
tq = (rsq-1.)*tqm1;
(*_v)[PQIndex(1,1).rIndex()] = tq;
}
PQIndex pq(2,2);
for (int p=2; 2*p<=_order; ++p, pq.incN()) {
tqm2 = tqm1;
tqm1 = tq;
tq = ((rsq-2.*p+1.)*tqm1 - (p-1.)*tqm2)/p;
(*_v)[pq.rIndex()] = tq;
}
// Ascend all positive m's
std::complex<double> zm = 2* (*_v)[PQIndex(0,0).rIndex()] * z;
for (int m=1; m<=_order; m++) {
pq.setPQ(m,0);
double *r = &(*_v)[pq.rIndex()];
*r = zm.real();
*(r+1) = zm.imag();
tq = 1.;
tqm1 = 0.;
for (pq.incN(); !pq.pastOrder(_order); pq.incN()) {
tqm2 = tqm1;
tqm1 = tq;
int p=pq.getP();
int q=pq.getQ();
tq = ( (rsq-(p+q-1.))*tqm1 - sqrtn(p-1)*sqrtn(q-1)*tqm2) / (sqrtn(p)*sqrtn(q));
double *r = &(*_v)[pq.rIndex()];
*r = tq*zm.real();
*(r+1) = tq*zm.imag();
}
zm *= z/sqrtn(m+1);
}
}
LTransform& LTransform::operator*=(const LTransform rhs)
{
take_ownership();
if (_orderIn != rhs.getOrderOut())
FormatAndThrow<>()
<< "Order mismatch between LTransform [" << _orderIn
<< "] and LTransform [" << rhs.getOrderOut()
<< "]";
(*_m) *= (*rhs._m);
_orderIn = rhs._orderOut;
return *this;
}
rsa_key rsa_key::generate_private_key(int num, unsigned long exponent, generate_callback_type callback, void* callback_arg, bool must_take_ownership)
{
// Exponent must be odd
assert(exponent | 1);
RSA* ptr = RSA_generate_key(num, exponent, callback, callback_arg);
if (must_take_ownership)
{
return take_ownership(ptr);
}
else
{
return ptr;
}
}
void LVector::rotate(const Angle& theta)
{
take_ownership();
double s, c;
theta.sincos(s,c);
std::complex<double> z(c, -s);
std::complex<double> imz(1., 0.);
for (int m=1; m<=_order; m++) {
imz *= z;
for (PQIndex pq(m,0); !pq.pastOrder(_order); pq.incN()) {
int r = pq.rIndex();
std::complex<double> newb = std::complex<double>((*_v)[r], (*_v)[r+1]) * imz;
(*_v)[r] = newb.real();
(*_v)[r+1] = newb.imag();
}
}
}
dh_key dh_key::generate_parameters(int prime_len, int generator, generate_callback_type callback, void* callback_arg)
{
return take_ownership(DH_generate_parameters(prime_len, generator, callback, callback_arg));
}
inline dsa_key dsa_key::from_certificate_public_key(file _file, pem_passphrase_callback_type callback, void* callback_arg)
{
return take_ownership(PEM_read_DSA_PUBKEY(_file.raw(), NULL, callback, callback_arg));
}
inline dsa_key dsa_key::from_parameters(file _file, pem_passphrase_callback_type callback, void* callback_arg)
{
return take_ownership(PEM_read_DSAparams(_file.raw(), NULL, callback, callback_arg));
}
inline dsa_key dsa_key::from_private_key(file _file, pem_passphrase_callback_type callback, void* callback_arg)
{
return take_ownership(PEM_read_DSAPrivateKey(_file.raw(), NULL, callback, callback_arg));
}
inline dsa_key dsa_key::from_certificate_public_key(bio::bio_ptr bio, pem_passphrase_callback_type callback, void* callback_arg)
{
return take_ownership(PEM_read_bio_DSA_PUBKEY(bio.raw(), NULL, callback, callback_arg));
}
inline dsa_key dsa_key::from_parameters(bio::bio_ptr bio, pem_passphrase_callback_type callback, void* callback_arg)
{
return take_ownership(PEM_read_bio_DSAparams(bio.raw(), NULL, callback, callback_arg));
}
int main() {
auto p = take_ownership(func());
auto q = take_ownership(func2());
}
inline certificate_request certificate_request::from_certificate_request(file _file, pem_passphrase_callback_type callback, void* callback_arg)
{
return take_ownership(PEM_read_X509_REQ(_file.raw(), NULL, callback, callback_arg));
}
inline name_entry name_entry::clone() const
{
return take_ownership(X509_NAME_ENTRY_dup(ptr().get()));
}
inline name_entry name_entry::from_object(asn1::object _object, int _type, const void* _data, size_t data_len)
{
return take_ownership(X509_NAME_ENTRY_create_by_OBJ(NULL, _object.raw(), _type, static_cast<unsigned char*>(const_cast<void*>(_data)), static_cast<int>(data_len)));
}
inline certificate_request certificate_request::from_der(const void* buf, size_t buf_len)
{
const unsigned char* pbuf = static_cast<const unsigned char*>(buf);
return take_ownership(d2i_X509_REQ(NULL, &pbuf, static_cast<long>(buf_len)));
}
bignum bignum::from_integer(asn1::integer i)
{
return take_ownership(ASN1_INTEGER_to_BN(i.raw(), NULL));
}
inline utctime utctime::create()
{
return take_ownership(ASN1_UTCTIME_new());
}
inline string string::create()
{
return take_ownership(ASN1_STRING_new());
}
inline dsa_key dsa_key::create()
{
return take_ownership(DSA_new());
}
inline name_entry name_entry::from_der(const void* buf, size_t buf_len)
{
const unsigned char* pbuf = static_cast<const unsigned char*>(buf);
return take_ownership(d2i_X509_NAME_ENTRY(NULL, &pbuf, static_cast<long>(buf_len)));
}
inline dh_key dh_key::create()
{
return take_ownership(DH_new());
}
inline object object::create()
{
return take_ownership(ASN1_OBJECT_new());
}
inline name_entry name_entry::from_nid(int _nid, int _type, const void* _data, size_t data_len)
{
return take_ownership(X509_NAME_ENTRY_create_by_NID(NULL, _nid, _type, static_cast<unsigned char*>(const_cast<void*>(_data)), static_cast<int>(data_len)));
}
