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))); }