Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.519 )
Net-LDAP-Gateway
view release on metacpan or search on metacpan
RETVAL
SV *
ldap_peek_message(buffer)
SV *buffer
PPCODE:
{
int n = 0;
STRLEN bytes, request_len, src_len;
const char *start, *src, *max;
sv_utf8_downgrade(buffer, 0);
XSRETURN(n);
}
void
ldap_shift_message(SV *buffer)
PPCODE:
{
STRLEN src_len, message_len;
const char *start = SvPV(buffer, src_len);
const char *src = start;
const char *max = start + src_len;
ldap_pack_message_ref(msgid, op, data, controls = 0)
U32 msgid
U32 op
HV *data
SV *controls
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
ldap_pack_message_ref(dest, op, data, controls);
end_ldap_message(dest);
ldap_pack_compare_response_ref = LDAP_OP_COMPARE_RESPONSE
ldap_pack_abandon_request_ref = LDAP_OP_ABANDON_REQUEST
ldap_pack_extended_request_ref = LDAP_OP_EXTENDED_REQUEST
ldap_pack_extended_response_ref = LDAP_OP_EXTENDED_RESPONSE
ldap_pack_intermediate_response_ref = LDAP_OP_INTERMEDIATE_RESPONSE
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
ldap_pack_message_ref(dest, ix, data, controls);
end_ldap_message(dest);
U32 version
SV *dn
U32 method
SV *arg1
SV *arg2
PPCODE:
{
SV *dest = new_message_sv();
if (version > 3)
croak("bad LDAP protocol version %u", (unsigned int)version);
start_ldap_message(dest, msgid);
}
void
ldap_pack_unbind_request(msgid)
U32 msgid
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_unbind_request_args(dest);
end_ldap_message(dest);
U32 size_limit
U32 time_limit
U32 types_only
AV_opt *filter
SV *attributes
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_search_request_args(dest,
base_dn, scope, deref,
void
ldap_pack_search_entry_response(msgid, dn, ...)
U32 msgid
SV *dn
PPCODE:
{
SV *dest = new_message_sv();
if (items & 1)
croak("Usage: Net::LDAP::Gateway::search_entry_response("
"$msgid, $dn, attr => \\@values, attr => \\@values, ...)");
}
void
ldap_pack_search_reference_response(msgid, ...)
U32 msgid
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_search_reference_response_args(dest, &(ST(1)), items - 1);
end_ldap_message(dest);
void
ldap_pack_modify_request(msgid, dn, ...)
U32 msgid
SV *dn
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_modify_request_args(dest, dn, &(ST(2)), items - 2);
end_ldap_message(dest);
void
ldap_pack_add_request(msgid, dn, ...)
U32 msgid
SV *dn
PPCODE:
{
SV *dest = new_message_sv();
if (items & 1)
croak("Usage: Net::LDAP::Gateway::add_request("
"$msgid, $dn, attr => \\@values, attr => \\@values, ...)");
void
ldap_pack_delete_request(msgid, dn)
U32 msgid
SV *dn
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_delete_request_args(dest, dn);
end_ldap_message(dest);
U32 msgid
SV *dn
SV *new_rdn
I32 delete_old_rdn
SV *new_superior
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_modify_dn_request_args(dest, dn, new_rdn, delete_old_rdn, new_superior);
end_ldap_message(dest);
ldap_pack_compare_request(msgid, dn, attribute, value)
U32 msgid
SV *dn
SV *attribute
SV *value
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_compare_request_args(dest, dn, attribute, value);
end_ldap_message(dest);
void
ldap_pack_abandon_request(msgid, target_msgid)
U32 msgid
U32 target_msgid
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_abandon_request_args(dest, target_msgid);
end_ldap_message(dest);
void
_ldap_pack_extended_request(msgid, oid, value = 0)
U32 msgid
SV *oid
SV *value
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_extended_request_args(dest, oid, value);
end_ldap_message(dest);
SV *matched_dn
SV *message
SV *referrals
SV *name
SV *value
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_extended_response_args(dest, result, matched_dn, message,
referrals, name, value);
void
ldap_pack_intermediate_response(msgid, oid = 0, value = 0)
U32 msgid
SV *oid
SV *value
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_intermediate_response_args(dest, oid, value);
end_ldap_message(dest);
ldap_pack_modify_response = LDAP_OP_MODIFY_RESPONSE
ldap_pack_add_response = LDAP_OP_ADD_RESPONSE
ldap_pack_delete_response = LDAP_OP_DELETE_RESPONSE
ldap_pack_modify_dn_response = LDAP_OP_MODIFY_DN_RESPONSE
ldap_pack_compare_response = LDAP_OP_COMPARE_RESPONSE
PPCODE:
{
SV *dest = new_message_sv();
start_ldap_message(dest, msgid);
pack_result_response_args(dest, ix, result, matched_dn, message, referrals);
end_ldap_message(dest);
Net-LDAPapi
view release on metacpan or search on metacpan
void
ldap_explode_dn(dn,notypes)
char * dn
int notypes
PPCODE:
{
char ** LDAPGETVAL;
int i;
if ((LDAPGETVAL = ldap_explode_dn(dn,notypes)) != NULL)
void
ldap_explode_rdn(dn,notypes)
char * dn
int notypes
PPCODE:
{
char ** LDAPGETVAL;
int i;
if ((LDAPGETVAL = ldap_explode_rdn(dn,notypes)) != NULL)
void
ldap_get_values_len(ld,entry,target)
LDAP * ld
LDAPMessage * entry
char * target
PPCODE:
{
struct berval ** LDAPGETVAL;
int i;
if ((LDAPGETVAL = ldap_get_values_len(ld,entry,target)) != NULL)
Net-LDAPxs
view release on metacpan or search on metacpan
RETVAL
void
_unbind(ld)
LDAP* ld
PPCODE:
ldap_unbind_ext(ld, NULL, NULL);
void
_search(ld, opt)
LDAP *ld
int msgid;
HV* search_result;
HV* stash;
SV* blessed_result;
PPCODE:
if ((svp = hv_fetch(opt, "base", 4, FALSE)) && SvPOK(*svp)) {
base = (char *)SvPV_nolen(*svp);
}else{
croak("_search(base): not a string");
}
Net-LDNS
view release on metacpan or search on metacpan
src/LDNS.xs view on Meta::CPAN
PROTOTYPES: ENABLE
SV *
to_idn(...)
PPCODE:
{
#ifdef WE_CAN_HAZ_IDN
int i;
for( i = 0; i<items; i++ )
{
src/LDNS.xs view on Meta::CPAN
RETVAL
SV *
load_zonefile(filename)
char *filename;
PPCODE:
{
ldns_zone *zone;
ldns_status s;
ldns_rr *soa;
ldns_rr_list *rrs;
src/LDNS.xs view on Meta::CPAN
SV *
name2addr(obj,name)
Net::LDNS obj;
const char *name;
PPCODE:
{
ldns_rr_list *addrs;
ldns_rdf *dname;
size_t n, i;
I32 context;
src/LDNS.xs view on Meta::CPAN
SV *
addr2name(obj,addr_in)
Net::LDNS obj;
const char *addr_in;
PPCODE:
{
ldns_rr_list *names;
ldns_rdf *addr_rdf;
size_t n, i;
I32 context;
src/LDNS.xs view on Meta::CPAN
RETVAL
SV *
packet_answer(obj)
Net::LDNS::Packet obj;
PPCODE:
{
size_t i,n;
ldns_rr_list *rrs;
I32 context = GIMME_V;
src/LDNS.xs view on Meta::CPAN
}
SV *
packet_authority(obj)
Net::LDNS::Packet obj;
PPCODE:
{
size_t i,n;
ldns_rr_list *rrs;
I32 context = GIMME_V;
src/LDNS.xs view on Meta::CPAN
}
SV *
packet_additional(obj)
Net::LDNS::Packet obj;
PPCODE:
{
size_t i,n;
ldns_rr_list *rrs;
I32 context = GIMME_V;
src/LDNS.xs view on Meta::CPAN
}
SV *
packet_question(obj)
Net::LDNS::Packet obj;
PPCODE:
{
size_t i,n;
ldns_rr_list *rrs;
I32 context = GIMME_V;
src/LDNS.xs view on Meta::CPAN
SV *
rr_new_from_string(class,str)
char *class;
char *str;
PPCODE:
ldns_status s;
ldns_rr *rr;
char rrclass[40];
char *rrtype;
SV* rr_sv;
src/LDNS.xs view on Meta::CPAN
RETVAL
SV *
rr_nsec3_salt(obj)
Net::LDNS::RR::NSEC3 obj;
PPCODE:
if(ldns_nsec3_salt_length(obj) > 0)
{
ldns_rdf *buf = ldns_nsec3_salt(obj);
ST(0) = sv_2mortal(newSVpvn((char *)ldns_rdf_data(buf), ldns_rdf_size(buf)));
ldns_rdf_deep_free(buf);
src/LDNS.xs view on Meta::CPAN
RETVAL
SV *
rr_nsec3param_salt(obj)
Net::LDNS::RR::NSEC3PARAM obj;
PPCODE:
ldns_rdf *rdf = ldns_rr_rdf(obj,3);
if(ldns_rdf_size(rdf) > 0)
{
mPUSHs(newSVpvn((char *)ldns_rdf_data(rdf), ldns_rdf_size(rdf)));
}
Net-LibAsyncNS
view release on metacpan or search on metacpan
lib/Net/LibAsyncNS.xs view on Meta::CPAN
int err;
struct addrinfo *res;
struct addrinfo *res_iter;
int n_res;
PPCODE:
err = asyncns_getaddrinfo_done(self, q->query, &res);
XPUSHs(gai_err_to_SV(err));
if(err) {
lib/Net/LibAsyncNS.xs view on Meta::CPAN
PREINIT:
int err;
char host[1024];
char serv[256];
PPCODE:
err = asyncns_getnameinfo_done(self, q->query, host, sizeof(host), serv, sizeof(serv));
XPUSHs(gai_err_to_SV(err));
if(err) {
lib/Net/LibAsyncNS.xs view on Meta::CPAN
INIT:
int len;
unsigned char *answer;
PPCODE:
len = asyncns_res_done(self, q->query, &answer);
if(len < 0) {
if(-len != EAGAIN)
SvREFCNT_dec(q->sv);
Net-LibNFS
view release on metacpan or search on metacpan
# ----------------------------------------------------------------------
# Static functions
void
find_local_servers ()
PPCODE:
struct nfs_server_list *servers = nfs_find_local_servers();
if (!servers) {
XSRETURN_EMPTY;
}
free_nfs_srvr_list(srvlist);
void
mount_getexports (SV* server_sv, SV* timeout_sv=&PL_sv_undef)
PPCODE:
const char* server = exs_SvPVbyte_nolen(server_sv);
struct exportnode* nodes;
if (SvOK(timeout_sv)) {
SvREFCNT_dec(nfs_dh->perl_nfs);
void
read (SV* self_sv)
PPCODE:
_FORBID_VOID_CONTEXT;
nlnfs_dh_s* nfs_dh = exs_structref_ptr(self_sv);
SV* nfs_sv = nfs_dh->perl_nfs;
SvREFCNT_dec(nfs_fh->perl_nfs);
void
close (SV* self_sv)
PPCODE:
nlnfs_fh_s* nfs_fh = exs_structref_ptr(self_sv);
SV* nfs_sv = nfs_fh->perl_nfs;
nlnfs_s* perl_nfs = exs_structref_ptr(nfs_sv);
Net-LibNIDS
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Net-MDNS-Client
view release on metacpan or search on metacpan
INIT:
mdnsda r;
struct in_addr in;
char * t;
PPCODE:
r = mdnsc_get_a_result(query_type, query_string);
if ( GIMME_V == G_VOID )
{ XSRETURN_UNDEF;}
if (r)
{
Net-MDNS-Server
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
type = constant(aTHX_ s, len);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
switch (type) {
case PERL_constant_NOTFOUND:
Net-MRT
view release on metacpan or search on metacpan
void
mrt_read_next(f)
PerlIO * f;
PROTOTYPE: *
PPCODE:
# Definitions
Off_t msgpos = PerlIO_tell(f); // Store message position & check for proper handle
int sz;
MRT_MESSAGE mh;
char sbuff[SBUFF] = {};
void
mrt_get_next(f)
PerlIO * f;
PROTOTYPE: *
PPCODE:
# Definitions
Off_t msgpos = PerlIO_tell(f); // Store message position & check for proper handle
int sz;
MRT_MESSAGE mh;
char sbuff[SBUFF] = {};
Net-NATS-Streaming-PB
view release on metacpan or search on metacpan
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSVpv("subject",0)));
PUSHs(sv_2mortal(newSVpv("sequence",0)));
subject(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::Ack * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::Ack") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__Ack *, tmp);
} else {
SV * svTHIS;
PREINIT:
SV * sv;
ostringstream ost;
PPCODE:
::Net::NATS::Streaming::PB::Ack * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::Ack") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__Ack *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv("clientID",0)));
clientID(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::CloseRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::CloseRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__CloseRequest *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv("error",0)));
error(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::CloseResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::CloseResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__CloseResponse *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSVpv("clientID",0)));
PUSHs(sv_2mortal(newSVpv("heartbeatInbox",0)));
clientID(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectRequest *, tmp);
} else {
heartbeatInbox(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectRequest *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 7);
PUSHs(sv_2mortal(newSVpv("pubPrefix",0)));
PUSHs(sv_2mortal(newSVpv("subRequests",0)));
PUSHs(sv_2mortal(newSVpv("unsubRequests",0)));
pubPrefix(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
subRequests(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
unsubRequests(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
closeRequests(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
error(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
subCloseRequests(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
publicKey(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::ConnectResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::ConnectResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__ConnectResponse *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 7);
PUSHs(sv_2mortal(newSVpv("sequence",0)));
PUSHs(sv_2mortal(newSVpv("subject",0)));
PUSHs(sv_2mortal(newSVpv("reply",0)));
SV * svTHIS;
PREINIT:
SV * sv;
ostringstream ost;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
subject(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
reply(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
data(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
SV * svTHIS;
PREINIT:
SV * sv;
ostringstream ost;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
redelivered(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
CRC32(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::MsgProto * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::MsgProto") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__MsgProto *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSVpv("guid",0)));
PUSHs(sv_2mortal(newSVpv("error",0)));
guid(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubAck * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubAck") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubAck *, tmp);
} else {
error(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubAck * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubAck") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubAck *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 6);
PUSHs(sv_2mortal(newSVpv("clientID",0)));
PUSHs(sv_2mortal(newSVpv("guid",0)));
PUSHs(sv_2mortal(newSVpv("subject",0)));
clientID(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubMsg * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubMsg") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubMsg *, tmp);
} else {
guid(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubMsg * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubMsg") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubMsg *, tmp);
} else {
subject(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubMsg * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubMsg") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubMsg *, tmp);
} else {
reply(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubMsg * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubMsg") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubMsg *, tmp);
} else {
data(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubMsg * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubMsg") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubMsg *, tmp);
} else {
sha256(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::PubMsg * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::PubMsg") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__PubMsg *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 10);
PUSHs(sv_2mortal(newSVpv("clientID",0)));
PUSHs(sv_2mortal(newSVpv("subject",0)));
PUSHs(sv_2mortal(newSVpv("qGroup",0)));
clientID(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
subject(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
qGroup(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
inbox(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
maxInFlight(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
ackWaitInSecs(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
durableName(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
startPosition(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
SV * svTHIS;
PREINIT:
SV * sv;
ostringstream ost;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
SV * svTHIS;
PREINIT:
SV * sv;
ostringstream ost;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionRequest *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSVpv("ackInbox",0)));
PUSHs(sv_2mortal(newSVpv("error",0)));
ackInbox(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionResponse *, tmp);
} else {
error(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::SubscriptionResponse * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::SubscriptionResponse") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__SubscriptionResponse *, tmp);
} else {
void
fields(svTHIS)
SV * svTHIS
PPCODE:
(void)svTHIS;
EXTEND(SP, 4);
PUSHs(sv_2mortal(newSVpv("clientID",0)));
PUSHs(sv_2mortal(newSVpv("subject",0)));
PUSHs(sv_2mortal(newSVpv("inbox",0)));
clientID(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::UnsubscribeRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::UnsubscribeRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__UnsubscribeRequest *, tmp);
} else {
subject(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::UnsubscribeRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::UnsubscribeRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__UnsubscribeRequest *, tmp);
} else {
inbox(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::UnsubscribeRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::UnsubscribeRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__UnsubscribeRequest *, tmp);
} else {
durableName(svTHIS)
SV * svTHIS;
PREINIT:
SV * sv;
PPCODE:
::Net::NATS::Streaming::PB::UnsubscribeRequest * THIS;
if ( sv_derived_from(svTHIS, "Net::NATS::Streaming::PB::UnsubscribeRequest") ) {
IV tmp = SvIV((SV *)SvRV(svTHIS));
THIS = INT2PTR(__Net__NATS__Streaming__PB__UnsubscribeRequest *, tmp);
} else {
Net-NIS-Netgroup
view release on metacpan or search on metacpan
Netgroup.xs view on Meta::CPAN
SV *
getdomainname()
PREINIT:
int len = 512;
char buf[512];
PPCODE:
int ret = getdomainname(buf, len);
if (ret == -1) {
XPUSHs(&PL_sv_undef);
} else {
XPUSHs(sv_2mortal(newSVpv(buf, 0)));
Netgroup.xs view on Meta::CPAN
IV *
setdomainname(name)
const char *name
PREINIT:
int len = strlen(name) + 1;
PPCODE:
int ret = setdomainname(name, len);
if (ret == -1) {
XPUSHs(&PL_sv_undef);
} else {
XPUSHs(sv_2mortal(newSViv(1)));
Netgroup.xs view on Meta::CPAN
char *user;
char *domain;
int ret;
PPCODE:
ret = 0;
if (!SvOK(sv_netgroup)) { netgroup = NULL; } else { netgroup = SvPV_nolen(sv_netgroup); }
if (!SvOK(sv_host)) { host = NULL; } else { host = SvPV_nolen(sv_host); }
if (!SvOK(sv_user)) { user = NULL; } else { user = SvPV_nolen(sv_user); }
Netgroup.xs view on Meta::CPAN
HV *el;
char *buf;
int bufsize = 256;
int len;
PPCODE:
if (stringify) {
buf = malloc(bufsize);
if (!buf) {
Perl_croak(aTHX_ "Could not allocate memory");
Net-NIS
view release on metacpan or search on metacpan
yp_unbind(domain)
char * domain
void
yp_get_default_domain()
PPCODE:
{
char *domain;
yp_status = yp_get_default_domain(&domain);
void
yp_match(domain, map, key)
char * domain
char * map
SV * key
PPCODE:
{
char *inkey;
STRLEN inkeylen;
char *outval;
int outvallen = 0;
void
yp_first(domain, map)
char * domain
char * map
PPCODE:
{
char *outkey;
int outkeylen;
char *outval;
int outvallen;
void
yp_next(domain, map, key)
char * domain
char * map
SV * key
PPCODE:
{
char *inkey;
STRLEN inkeylen;
char *outkey;
int outkeylen;
void
yp_all(domain, map)
char * domain
char * map
PPCODE:
{
struct ypall_callback callback;
struct callbackdata data;
data.results = newRV((SV *) newHV());
void
yp_order(domain, map)
char * domain
char * map
PPCODE:
{
unsigned long order;
yp_status = yp_order(domain, map, &order);
YP_RETURN(newSViv(order));
void
yp_master(domain, map)
char * domain
char * map
PPCODE:
{
char *name;
yp_status = yp_master(domain, map, &name);
YP_RETURN(newSVpv(name, strlen(name)));
char * domain
PREINIT:
int ret;
struct ypmaplist *ypmap = NULL;
AV *retval;
PPCODE:
{
ret = yp_maplist( domain, &ypmap );
if (ret == YPERR_SUCCESS) {
struct ypmaplist *y, *old;
#else /* Linux */
void
yp_maplist(domain)
char * domain
PPCODE:
{
warn("Net::NIS::yp_maplist() -- not implemented on this OS");
XSRETURN_EMPTY;
}
Net-NISplusTied
view release on metacpan or search on metacpan
NISplusTied.xs view on Meta::CPAN
void
nismatch (query, table)
char* query
char* table
PPCODE:
nis_result *en, *tb;
nis_object *noTable, *noEntry;
int i, j;
HV *hash; AV *array;
NISplusTied.xs view on Meta::CPAN
void
nismodify (query, table, values)
char* query
char* table
SV* values
PPCODE:
nis_result *en, *tb, *rc;
nis_object *noTable, *noEntry;
SV *i, *j; SV** iSV;
NISplusTied.xs view on Meta::CPAN
# /*****************************************************************/
void
nisremove (q)
char* q
PPCODE:
nis_result *rc;
rc = nis_remove_entry (q, NULL, REM_MULTIPLE || EXPAND_NAME);
Net-Nmsg
view release on metacpan or search on metacpan
const char *ch
PREINIT:
char **alias = NULL;
int num_aliases;
int i;
PPCODE:
num_aliases = nmsg_chalias_lookup(ch, &alias);
if (num_aliases > 0) {
for (i = 0; i < num_aliases; i++)
mXPUSHs(newSVpv(alias[i], 0));
}
void
find_all_devs()
PREINIT:
char err[PCAP_ERRBUF_SIZE];
PPCODE:
pcap_if_t *devs, *d;
if (pcap_findalldevs(&devs, err) == -1)
croak("%s", err);
char now[32];
struct timespec ts;
struct tm *tm;
time_t t;
char *tstr;
PPCODE:
nmsg_timespec_get(&ts);
t = (time_t) ts.tv_sec;
tm = gmtime(&t);
strftime(now, sizeof(now), "%Y%m%d.%H%M.%s", tm);
nmsg_asprintf(&tstr, "%s.%09ld", now, ts.tv_nsec);
void
get_selectable_fd(THIS)
Net::Nmsg::XS::pcap THIS
PREINIT:
int res;
PPCODE:
res = pcap_get_selectable_fd(THIS);
if (res != -1)
mXPUSHi(res);
int
nmsg_input_set_blocking_io(THIS, flag)
Net::Nmsg::XS::input THIS
bool flag
PREINIT:
nmsg_res res;
PPCODE:
res = nmsg_input_set_blocking_io(THIS, flag);
if (res == nmsg_res_success)
mXPUSHi(flag);
void
bool blocking_io
PREINIT:
nmsg_message_t m;
nmsg_res res;
U32 SAVE_signals;
PPCODE:
res = nmsg_res_failure;
while (res != nmsg_res_success) {
SAVE_signals = PL_signals;
PL_signals |= PERL_SIGNALS_UNSAFE_FLAG;
res = nmsg_input_read(THIS, &m);
void
get_time(THIS)
Net::Nmsg::XS::msg THIS
PREINIT:
struct timespec ts;
PPCODE:
nmsg_message_get_time(THIS, &ts);
mXPUSHi(ts.tv_sec);
mXPUSHi(ts.tv_nsec);
void
get_num_fields(THIS)
Net::Nmsg::XS::msg THIS
PREINIT:
nmsg_res res;
size_t len;
PPCODE:
res = nmsg_message_get_num_fields(THIS, &len);
if (res == nmsg_res_success)
mXPUSHu(len);
void
Net::Nmsg::XS::msg THIS
const char *field
PREINIT:
nmsg_res res;
size_t len;
PPCODE:
res = nmsg_message_get_num_field_values(THIS, field, &len);
if (res == nmsg_res_success)
mXPUSHu(len);
void
Net::Nmsg::XS::msg THIS
unsigned idx
PREINIT:
nmsg_res res;
size_t len;
PPCODE:
res = nmsg_message_get_num_field_values_by_idx(THIS, idx, &len);
if (res == nmsg_res_success)
mXPUSHu(len);
void
PREINIT:
nmsg_res res;
size_t len;
void *data;
nmsg_msgmod_field_type type;
PPCODE:
res = nmsg_message_get_field(THIS, field, v_idx, &data, &len);
if (res == nmsg_res_success && data != NULL) {
res = nmsg_message_get_field_type(THIS, field, &type);
if (res == nmsg_res_success) {
mXPUSHs(_xs_field_to_sv(aTHX_ data, len, type));
nmsg_res res;
size_t len;
void *data;
nmsg_msgmod_field_type type;
int i;
PPCODE:
res = nmsg_message_get_field_type(THIS, field, &type);
if (res != nmsg_res_success)
croak("nmsg_message_get_field_type failed: %s", nmsg_res_lookup(res));
for (i = 0; ; i++) {
res = nmsg_message_get_field(THIS, field, i, &data, &len);
PREINIT:
nmsg_res res;
nmsg_msgmod_field_type type;
size_t len;
void *data;
PPCODE:
res = nmsg_message_get_field_by_idx(THIS, f_idx, v_idx, &data, &len);
if (res == nmsg_res_success) {
res = nmsg_message_get_field_type_by_idx(THIS, f_idx, &type);
if (res == nmsg_res_success && data != NULL) {
mXPUSHs(_xs_field_to_sv(aTHX_ data, len, type));
nmsg_res res;
nmsg_msgmod_field_type type;
size_t len;
void *data;
int i;
PPCODE:
res = nmsg_message_get_field_type_by_idx(THIS, f_idx, &type);
if (res == nmsg_res_success) {
for (i = 0; ; i++) {
res = nmsg_message_get_field_by_idx(THIS, f_idx, i, &data, &len);
if (res != nmsg_res_success || data == NULL)
Net::Nmsg::XS::msg THIS
const char *field
PREINIT:
nmsg_res res;
unsigned flags;
PPCODE:
res = nmsg_message_get_field_flags(THIS, field, &flags);
if (res == nmsg_res_success)
mXPUSHu(flags);
void
Net::Nmsg::XS::msg THIS
unsigned f_idx
PREINIT:
nmsg_res res;
unsigned flags;
PPCODE:
res = nmsg_message_get_field_flags_by_idx(THIS, f_idx, &flags);
if (res == nmsg_res_success)
mXPUSHu(flags);
void
Net::Nmsg::XS::msg THIS
const char *name
PREINIT:
nmsg_res res;
unsigned idx;
PPCODE:
res = nmsg_message_get_field_idx(THIS, name, &idx);
if (res == nmsg_res_success)
mXPUSHu(idx);
void
Net::Nmsg::XS::msg THIS
unsigned idx
PREINIT:
nmsg_res res;
const char *name;
PPCODE:
res = nmsg_message_get_field_name(THIS, idx, &name);
if (res == nmsg_res_success)
mXPUSHs(newSVpv(name, 0));
void
Net::Nmsg::XS::msg THIS
const char *name;
PREINIT:
nmsg_res res;
nmsg_msgmod_field_type type;
PPCODE:
res = nmsg_message_get_field_type(THIS, name, &type);
if (res == nmsg_res_success)
mXPUSHi(type);
void
Net::Nmsg::XS::msg THIS
unsigned idx
PREINIT:
nmsg_res res;
nmsg_msgmod_field_type type;
PPCODE:
res = nmsg_message_get_field_type_by_idx(THIS, idx, &type);
if (res == nmsg_res_success)
mXPUSHi(type);
void
const char *field
const char *name
PREINIT:
nmsg_res res;
unsigned value;
PPCODE:
res = nmsg_message_enum_name_to_value(THIS, field, name, &value);
if (res == nmsg_res_success)
mXPUSHu(value);
void
unsigned f_idx
const char *name
PREINIT:
nmsg_res res;
unsigned value;
PPCODE:
res = nmsg_message_enum_name_to_value_by_idx(THIS, f_idx, name, &value);
if (res == nmsg_res_success)
mXPUSHu(value);
void
const char *field
unsigned value
PREINIT:
nmsg_res res;
const char *name;
PPCODE:
res = nmsg_message_enum_value_to_name(THIS, field, value, &name);
if (res == nmsg_res_success)
mXPUSHs(newSVpv(name, 0));
void
unsigned f_idx
unsigned value
PREINIT:
nmsg_res res;
const char *name;
PPCODE:
res = nmsg_message_enum_value_to_name_by_idx(THIS, f_idx, value, &name);
if (res == nmsg_res_success)
mXPUSHs(newSVpv(name, 0));
void
Net::Nmsg::XS::msg THIS
long time_sec
int time_nsec
PREINIT:
struct timespec ts;
PPCODE:
ts.tv_sec = time_sec;
ts.tv_nsec = time_nsec;
nmsg_message_set_time(THIS, &ts);
void
Net::Nmsg::XS::msg THIS
const char *endline
PREINIT:
nmsg_res res;
char *pres;
PPCODE:
pthread_mutex_lock(&presentation_lock);
res = nmsg_message_to_pres(THIS, &pres, endline);
if (res != nmsg_res_success)
goto out;
mXPUSHs(newSVpv(pres, 0));
Net::Nmsg::XS::msg THIS
unsigned f_idx
PREINIT:
nmsg_res res;
nmsg_msgmod_field_type type;
PPCODE:
res = nmsg_message_get_field_type_by_idx(THIS, f_idx, &type);
if (res == nmsg_res_success) {
mXPUSHs(newSViv(type));
switch (type) {
Net::Nmsg::XS::msg THIS
unsigned f_idx
PREINIT:
nmsg_res res;
unsigned flags;
PPCODE:
res = nmsg_message_get_field_flags_by_idx(THIS, f_idx, &flags);
if (res == nmsg_res_success) {
if (flags & NMSG_FF_REPEATED)
mXPUSHs(newSViv(NMSG_FF_REPEATED));
mXPUSHs(newSVpvs("repeated"));
PREINIT:
nmsg_res res;
nmsg_msgmod_field_type type;
unsigned v;
const char *name;
PPCODE:
res = nmsg_message_get_field_type_by_idx(THIS, f_idx, &type);
if (res == nmsg_res_success && type == nmsg_msgmod_ft_enum) {
for (v = 0; ; v++) {
res = nmsg_message_enum_value_to_name_by_idx(
THIS, f_idx, v, &name);
Net-Oping
view release on metacpan or search on metacpan
RETVAL
void
_ping_iterator_get_hostname (iter)
pingobj_iter_t *iter
PPCODE:
char *buffer;
size_t buffer_size;
int status;
do {
Net-Patricia
view release on metacpan or search on metacpan
Patricia.xs view on Meta::CPAN
SV * data
PROTOTYPE: $$$$$
PREINIT:
prefix_t prefix;
Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_lookup(tree, &prefix);
if (NULL != node) {
/* { */
if (node->data) {
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_best(tree, &prefix);
if (NULL != node) {
XPUSHs((SV *)node->data);
} else {
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_exact(tree, &prefix);
if (NULL != node) {
XPUSHs((SV *)node->data);
} else {
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_exact(tree, &prefix);
if (NULL != node) {
XPUSHs(sv_mortalcopy((SV *)node->data));
deref_data(node->data);
Patricia.xs view on Meta::CPAN
patricia_node_t *node = NULL;
struct frozen_header frozen_header;
struct frozen_node *frozen_nodes, *frozen_node;
size_t n = 0, i = 0, nd = 0;
SV *frozen_patricia;
PPCODE:
if (SvTRUE(cloning))
XSRETURN_UNDEF;
/* I do not know enough of patricia.c to
* decide whether inactive nodes can
Patricia.xs view on Meta::CPAN
struct frozen_node *frozen_node;
struct _patricia_tree_t *tree;
patricia_node_t *node = NULL, *child, **fixup;
int n, n_calculated, i, d_index, l_index, r_index;
STRLEN len;
PPCODE:
if (SvTRUE(cloning))
XSRETURN_UNDEF;
tree = calloc(1, sizeof(*tree));
frozen_patricia = (struct frozen_patricia*)SvPV(serialized, len);
Net-Pcap
view release on metacpan or search on metacpan
PREINIT:
char *errbuf = NULL;
Newx(errbuf, PCAP_ERRBUF_SIZE+1, char);
PPCODE:
if ( SvROK(err) && SvROK(devinfo) && (SvTYPE(SvRV(devinfo)) == SVt_PVHV) ) {
int r;
pcap_if_t *alldevs, *d;
HV *hv;
SV *err_sv = SvRV(err);
pcap_t *p
PREINIT:
unsigned int h;
PPCODE:
h = (unsigned int) pcap_getevent(p);
ST(0) = sv_newmortal();
sv_setref_iv(ST(0), "Win32::Event", h);
XSRETURN(1);
Net-Prometheus-PerlCollector
view release on metacpan or search on metacpan
lib/Net/Prometheus/PerlCollector.xs view on Meta::CPAN
int detail
INIT:
SV *arena;
STRLEN arenas = 0, svs = 0;
HV *svs_by_type = NULL, *svs_by_class = NULL;
PPCODE:
if(detail)
svs_by_type = newHV();
if(detail > 1)
svs_by_class = newHV();
Net-Prometheus
view release on metacpan or search on metacpan
lib/Net/Prometheus/PerlCollector.xs view on Meta::CPAN
int detail
INIT:
SV *arena;
STRLEN arenas = 0, svs = 0;
HV *svs_by_type = NULL, *svs_by_class = NULL;
PPCODE:
if(detail)
svs_by_type = newHV();
if(detail > 1)
svs_by_class = newHV();
Net-RULI
view release on metacpan or search on metacpan
RULI/fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
type = constant(aTHX_ s, len);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
switch (type) {
case PERL_constant_NOTFOUND:
Net-SLP
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Net-SNMP-XS
view release on metacpan or search on metacpan
void
_buffer_append (BUFOBJ self, SV *value)
ALIAS:
_buffer_put = 1
PPCODE:
{
STRLEN vlen;
const char *vstr = SvPVbyte (value, vlen);
if (ix)
XPUSHs (&PL_sv_yes);
}
void
_buffer_get (BUFOBJ self, int count = -1)
PPCODE:
{
// grrr.
if (count < 0)
{
hv_delete ((HV *)SvRV (self), "_index" , 6, G_DISCARD);
void
oid_base_match (SV *base_, SV *oid_)
PROTOTYPE: $$
ALIAS:
oid_context_match = 0
PPCODE:
{
if (!SvOK (base_) || !SvOK (oid_))
XSRETURN_NO;
STRLEN blen, olen;
#if HAVE_VERSIONSORT
void
oid_lex_sort (...)
PROTOTYPE: @
PPCODE:
{
// make sure SvPVX is valid
int i;
for (i = items; i--; )
{
Net-SSH-Perl
view release on metacpan or search on metacpan
lib/Net/SSH/Perl/Key/Ed25519.xs view on Meta::CPAN
RETVAL
void
ed25519_generate_keypair (secret)
SV *secret
PPCODE:
{
STRLEN secret_l; unsigned char *secret_p;
unsigned char public_key[32];
unsigned char private_key[64];
Net-SSH2
view release on metacpan or search on metacpan
CODE:
net_ss_debug_out = debug & 1; /* allow for future flags */
void
net_ss_version(...)
PPCODE:
EXTEND(SP, 3);
ST(0) = sv_2mortal(newSVpv(LIBSSH2_VERSION, 0));
if (GIMME_V != G_ARRAY)
XSRETURN(1);
#ifdef LIBSSH2_VERSION_NUM
void
net_ss_hostkey_hash(SSH2* ss, SSH2_HOSTKEY_HASH type)
PREINIT:
const char* hash;
static STRLEN rglen[] = { 16/*MD5*/, 20/*SHA1*/ };
PPCODE:
if (type < 1 || type > countof(rglen)) {
croak("%s::hostkey: unknown hostkey hash: %d",
class, (int)type);
}
if ((hash = (const char*)libssh2_hostkey_hash(ss->session, type))) {
net_ss_remote_hostkey(SSH2* ss)
PREINIT:
const char *key_pv;
size_t key_len;
int type_int;
PPCODE:
if ((key_pv = libssh2_session_hostkey(ss->session, &key_len, &type_int))) {
XPUSHs(sv_2mortal(newSVpvn(key_pv, key_len)));
if (GIMME_V != G_ARRAY)
XSRETURN(1);
else {
char *langtag;
size_t exitsignal_len;
size_t errmsg_len;
size_t langtag_len;
int retcount = 1;
PPCODE:
if (!libssh2_channel_get_exit_signal(ch->channel,
&exitsignal, &exitsignal_len,
&errmsg, &errmsg_len,
&langtag, &langtag_len)) {
LIBSSH2_SESSION *session = ch->ss->session;
void
net_ch_window_write(SSH2_CHANNEL* ch)
PREINIT:
unsigned long window_size_initial = 0;
PPCODE:
XPUSHs(sv_2mortal(newSVuv(libssh2_channel_window_write_ex(ch->channel,
&window_size_initial))));
if (GIMME_V == G_ARRAY) {
XPUSHs(sv_2mortal(newSVuv(window_size_initial)));
XSRETURN(2);
void
net_ch_window_read(SSH2_CHANNEL *ch)
PREINIT:
unsigned long read_avail = 0;
unsigned long window_size_initial = 0;
PPCODE:
XPUSHs(sv_2mortal(newSVuv(libssh2_channel_window_read_ex(ch->channel,
&read_avail,
&window_size_initial))));
if (GIMME_V == G_ARRAY) {
XPUSHs(sv_2mortal(newSVuv(read_avail)));
void
net_sf_error(SSH2_SFTP* sf)
PREINIT:
unsigned long error;
SV *errstr;
PPCODE:
error = libssh2_sftp_last_error(sf->sftp);
ST(0) = sv_2mortal(newSVuv(error));
if (GIMME_V == G_ARRAY) {
EXTEND(SP, 2);
if ((error >= 0) && (error < countof(sftp_error)))
PREINIT:
const char* pv_path;
STRLEN len_path;
int error;
LIBSSH2_SFTP_ATTRIBUTES attrs;
PPCODE:
pv_path = SvPVbyte(path, len_path);
error = libssh2_sftp_stat_ex(sf->sftp, (char*)pv_path, len_path,
(follow ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT),
&attrs);
if (error < 0)
void
net_fi_stat(SSH2_FILE* fi)
PREINIT:
LIBSSH2_SFTP_ATTRIBUTES attrs;
PPCODE:
if (libssh2_sftp_fstat(fi->handle, &attrs))
XSRETURN_EMPTY;
XSRETURN_STAT_ATTRS(NULL/*name*/);
SSH2_NERROR
PREINIT:
SV* buffer;
char* pv_buffer;
int count;
LIBSSH2_SFTP_ATTRIBUTES attrs;
PPCODE:
buffer = newSV(MAXPATHLEN + 1);
SvPOK_on(buffer);
pv_buffer = SvPVX(buffer);
count = libssh2_sftp_readdir(di->handle, pv_buffer, MAXPATHLEN, &attrs);
void
net_pk_fetch(SSH2_PUBLICKEY* pk)
PREINIT:
unsigned long keys, i, j;
libssh2_publickey_list* list = NULL;
PPCODE:
if (!libssh2_publickey_list_fetch(pk->pkey, &keys, &list) || !list)
XSRETURN_EMPTY;
if (GIMME_V == G_ARRAY) {
EXTEND(SP, keys);
Net-SSLeay
view release on metacpan or search on metacpan
int max
PREINIT:
char *buf;
int got;
int succeeded = 1;
PPCODE:
New(0, buf, max, char);
got = SSL_read(s, buf, max);
if (got <= 0 && SSL_ERROR_ZERO_RETURN != SSL_get_error(s, got))
succeeded = 0;
int max
PREINIT:
char *buf;
int got;
int succeeded = 1;
PPCODE:
New(0, buf, max, char);
got = SSL_peek(s, buf, max);
if (got <= 0 && SSL_ERROR_ZERO_RETURN != SSL_get_error(s, got))
succeeded = 0;
int max
PREINIT:
char *buf;
size_t readbytes;
int succeeded;
PPCODE:
Newx(buf, max, char);
succeeded = SSL_read_ex(s, buf, max, &readbytes);
/* Return 2-item list:
int max
PREINIT:
char *buf;
size_t readbytes;
int succeeded;
PPCODE:
Newx(buf, max, char);
succeeded = SSL_peek_ex(s, buf, max, &readbytes);
/* Return 2-item list:
STRLEN len;
size_t written;
int succeeded;
INPUT:
char * buf = SvPV( ST(1), len);
PPCODE:
succeeded = SSL_write_ex(s, buf, len, &written);
/* Return 2-item list:
* first return value: data gotten, or undef on error
* second return value: result from SSL_read_ex()
SSL * s
PREINIT:
STACK_OF(SSL_CIPHER) *sk = NULL;
const SSL_CIPHER *c;
int i;
PPCODE:
sk = SSL_get_ciphers(s);
if( sk == NULL ) {
XSRETURN_EMPTY;
}
for (i=0; i<sk_SSL_CIPHER_num(sk); i++) {
SSL * s
PREINIT:
STACK_OF(X509) *chain = NULL;
X509 *x;
int i;
PPCODE:
chain = SSL_get_peer_cert_chain(s);
if( chain == NULL ) {
XSRETURN_EMPTY;
}
for (i=0; i<sk_X509_num(chain); i++) {
i2d_SSL_SESSION(sess)
SSL_SESSION * sess
PREINIT:
STRLEN len;
unsigned char *pc,*pi;
PPCODE:
if (!(len = i2d_SSL_SESSION(sess,NULL))) croak("invalid SSL_SESSION");
Newx(pc,len,unsigned char);
if (!pc) croak("out of memory");
pi = pc;
i2d_SSL_SESSION(sess,&pi);
SSL_get_sigalgs(SSL *ssl, int idx)
PREINIT:
int n_sigalgs;
int psign = NID_undef, phash = NID_undef, psignhash = NID_undef;
unsigned char rsig = 0, rhash = 0;
PPCODE:
n_sigalgs = SSL_get_sigalgs(ssl, idx,
&psign, &phash, &psignhash,
&rsig, &rhash);
EXTEND(SP, 6);
SSL_get_shared_sigalgs(SSL *ssl, int idx)
PREINIT:
int n_sigalgs;
int psign = NID_undef, phash = NID_undef, psignhash = NID_undef;
unsigned char rsig = 0, rhash = 0;
PPCODE:
n_sigalgs = SSL_get_shared_sigalgs(ssl, idx,
&psign, &phash, &psignhash,
&rsig, &rhash);
EXTEND(SP, 6);
BIGNUM *bn = NULL;
ASN1_INTEGER *sn;
X509_REVOKED *rev;
ASN1_ENUMERATED *rsn = NULL;
int rv;
PPCODE:
rv=0;
rev = X509_REVOKED_new();
if (rev) {
if (BN_hex2bn(&bn, serial_hex)) {
sn = BN_to_ASN1_INTEGER(bn, NULL);
INIT:
X509_ATTRIBUTE * att;
int count, i;
ASN1_STRING * s;
ASN1_TYPE * t;
PPCODE:
att = X509_REQ_get_attr(req,n);
count = X509_ATTRIBUTE_count(att);
for (i=0; i<count; i++) {
t = X509_ATTRIBUTE_get0_type(att, i);
s = t->value.asn1_string;
PREINIT:
STACK_OF(X509_EXTENSION) *exts = NULL;
X509_EXTENSION *ext, *tmpext;
ASN1_OBJECT *obj;
int i, idx, ret = 1;
PPCODE:
if (!x509 || !x509_req) XSRETURN_IV(0);
exts = X509_REQ_get_extensions(x509_req);
for(i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
ext = sk_X509_EXTENSION_value(exts, i);
obj = X509_EXTENSION_get_object(ext);
int i, j, count = 0;
X509_EXTENSION *subjAltNameExt = NULL;
STACK_OF(GENERAL_NAME) *subjAltNameDNs = NULL;
GENERAL_NAME *subjAltNameDN = NULL;
int num_gnames;
PPCODE:
if ( (i = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1)) >= 0
&& (subjAltNameExt = X509_get_ext(cert, i))
&& (subjAltNameDNs = (STACK_OF(GENERAL_NAME) *)X509V3_EXT_d2i(subjAltNameExt)))
{
num_gnames = sk_GENERAL_NAME_num(subjAltNameDNs);
GENERAL_NAMES *gnames;
GENERAL_NAME *gn;
STACK_OF(DIST_POINT) *points;
DIST_POINT *p;
int i, j;
PPCODE:
points = (STACK_OF(DIST_POINT) *)X509_get_ext_d2i(cert, NID_crl_distribution_points, NULL, NULL);
for (i = 0; i < sk_DIST_POINT_num(points); i++) {
p = sk_DIST_POINT_value(points, i);
if (!p->distpoint)
continue;
P_X509_get_ocsp_uri(cert)
X509 * cert
PREINIT:
AUTHORITY_INFO_ACCESS *info;
int i;
PPCODE:
info = (AUTHORITY_INFO_ACCESS *)X509_get_ext_d2i(cert, NID_info_access, NULL, NULL);
if (!info) XSRETURN_UNDEF;
for (i = 0; i < sk_ACCESS_DESCRIPTION_num(info); i++) {
ACCESS_DESCRIPTION *ad = sk_ACCESS_DESCRIPTION_value(info, i);
PREINIT:
EXTENDED_KEY_USAGE *extusage;
int i, nid;
char buffer[100]; /* openssl doc: a buffer length of 80 should be more than enough to handle any OID encountered in practice */
ASN1_OBJECT *o;
PPCODE:
extusage = (EXTENDED_KEY_USAGE *)X509_get_ext_d2i(cert, NID_ext_key_usage, NULL, NULL);
for(i = 0; i < sk_ASN1_OBJECT_num(extusage); i++) {
o = sk_ASN1_OBJECT_value(extusage,i);
nid = OBJ_obj2nid(o);
OBJ_obj2txt(buffer, sizeof(buffer)-1, o, 1);
void
P_X509_get_key_usage(cert)
X509 * cert
INIT:
ASN1_BIT_STRING * u;
PPCODE:
u = (ASN1_BIT_STRING *)X509_get_ext_d2i(cert, NID_key_usage, NULL, NULL);
if (u) {
if (ASN1_BIT_STRING_get_bit(u,0)) XPUSHs(sv_2mortal(newSVpv("digitalSignature",0)));
if (ASN1_BIT_STRING_get_bit(u,1)) XPUSHs(sv_2mortal(newSVpv("nonRepudiation",0)));
if (ASN1_BIT_STRING_get_bit(u,2)) XPUSHs(sv_2mortal(newSVpv("keyEncipherment",0)));
void
P_X509_get_netscape_cert_type(cert)
X509 * cert
INIT:
ASN1_BIT_STRING * u;
PPCODE:
u = (ASN1_BIT_STRING *)X509_get_ext_d2i(cert, NID_netscape_cert_type, NULL, NULL);
if (u) {
if (ASN1_BIT_STRING_get_bit(u,0)) XPUSHs(sv_2mortal(newSVpv("client",0)));
if (ASN1_BIT_STRING_get_bit(u,1)) XPUSHs(sv_2mortal(newSVpv("server",0)));
if (ASN1_BIT_STRING_get_bit(u,2)) XPUSHs(sv_2mortal(newSVpv("email",0)));
ASN1_INTEGER * i
char * str
INIT:
BIGNUM *bn;
int rv = 1;
PPCODE:
bn = BN_new();
if (!BN_hex2bn(&bn, str)) XSRETURN_IV(0);
if (!BN_to_ASN1_INTEGER(bn, i)) rv = 0;
BN_free(bn);
XSRETURN_IV(rv);
ASN1_INTEGER * i
char * str
INIT:
BIGNUM *bn;
int rv = 1;
PPCODE:
bn = BN_new();
if (!BN_dec2bn(&bn, str)) XSRETURN_IV(0);
if (!BN_to_ASN1_INTEGER(bn, i)) rv = 0;
BN_free(bn);
XSRETURN_IV(rv);
P_ASN1_INTEGER_get_hex(i)
ASN1_INTEGER * i
INIT:
BIGNUM *bn;
char *result;
PPCODE:
bn = BN_new();
if (!bn) XSRETURN_UNDEF;
ASN1_INTEGER_to_BN(i, bn);
result = BN_bn2hex(bn);
BN_free(bn);
P_ASN1_INTEGER_get_dec(i)
ASN1_INTEGER * i
INIT:
BIGNUM *bn;
char *result;
PPCODE:
bn = BN_new();
if (!bn) XSRETURN_UNDEF;
ASN1_INTEGER_to_BN(i, bn);
result = BN_bn2dec(bn);
BN_free(bn);
P_ASN1_STRING_get(s,utf8_decode=0)
ASN1_STRING * s
int utf8_decode
PREINIT:
SV * u8;
PPCODE:
#if (OPENSSL_VERSION_NUMBER >= 0x1010000f && !defined(LIBRESSL_VERSION_NUMBER)) || (LIBRESSL_VERSION_NUMBER >= 0x2070000fL)
u8 = newSVpv((const char*)ASN1_STRING_get0_data(s), ASN1_STRING_length(s));
#else
u8 = newSVpv((const char*)ASN1_STRING_data(s), ASN1_STRING_length(s));
#endif
X509 *certificate = NULL;
STACK_OF(X509) *cachain = NULL;
X509 *x;
BIO *bio;
int i, result;
PPCODE:
bio = BIO_new_file(file, "rb");
if (bio) {
OPENSSL_add_all_algorithms_noconf();
if ((p12 = d2i_PKCS12_bio(bio, NULL))) {
if(load_chain)
void
SSL_CIPHER_description(const SSL_CIPHER *cipher, char *unused_buf=NULL, int unused_size=0)
PREINIT:
char *description;
char buf[512];
PPCODE:
description = SSL_CIPHER_description(cipher, buf, sizeof(buf));
if(description == NULL) {
XSRETURN_EMPTY;
}
XPUSHs(sv_2mortal(newSVpv(description, 0)));
SSL_client_hello_get1_extensions_present(SSL *s)
PREINIT:
int ret, *out = NULL, i;
size_t outlen;
AV *av;
PPCODE:
ret = SSL_client_hello_get1_extensions_present(s, &out, &outlen);
if (ret != 1) XSRETURN_UNDEF;
av = newAV();
mXPUSHs(newRV_noinc((SV*)av));
PREINIT:
int ret, i;
uint16_t *exts;
size_t num_exts;
AV *av;
PPCODE:
ret = SSL_client_hello_get_extension_order(s, NULL, &num_exts);
if (ret != 1) XSRETURN_UNDEF;
Newx(exts, num_exts, uint16_t);
ret = SSL_client_hello_get_extension_order(s, exts, &num_exts);
#if (!defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x1010000fL)) || (defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER >= 0x3050000fL))
const BIGNUM *n, *e, *d;
const BIGNUM *p, *q;
const BIGNUM *dmp1, *dmq1, *iqmp;
#endif
PPCODE:
{
#if (!defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x1010000fL)) || (defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER >= 0x3050000fL))
RSA_get0_key(rsa, &n, &e, &d);
RSA_get0_factors(rsa, &p, &q);
RSA_get0_crt_params(rsa, &dmp1, &dmq1, &iqmp);
const X509 *data
const EVP_MD *type
PREINIT:
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int md_size;
PPCODE:
if (X509_pubkey_digest(data,type,md,&md_size))
XSRETURN_PVN((char *)md, md_size);
else
XSRETURN_UNDEF;
const X509 *data
const EVP_MD *type
PREINIT:
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int md_size;
PPCODE:
if (X509_digest(data,type,md,&md_size))
XSRETURN_PVN((char *)md, md_size);
XSRETURN_UNDEF;
void
const X509_CRL *data
const EVP_MD *type
PREINIT:
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int md_size;
PPCODE:
if (X509_CRL_digest(data,type,md,&md_size))
XSRETURN_PVN((char *)md, md_size);
XSRETURN_UNDEF;
void
const X509_REQ *data
const EVP_MD *type
PREINIT:
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int md_size;
PPCODE:
if (X509_REQ_digest(data,type,md,&md_size))
XSRETURN_PVN((char *)md, md_size);
XSRETURN_UNDEF;
void
const X509_NAME *data
const EVP_MD *type
PREINIT:
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int md_size;
PPCODE:
if (X509_NAME_digest(data,type,md,&md_size))
XSRETURN_PVN((char *)md, md_size);
XSRETURN_UNDEF;
unsigned long
const X509 *x
PREINIT:
X509_PUBKEY *pkey;
STRLEN len;
unsigned char *pc, *pi;
PPCODE:
if (!(pkey = X509_get_X509_PUBKEY(x))) croak("invalid certificate");
if (!(len = i2d_X509_PUBKEY(pkey, NULL))) croak("invalid certificate public key");
Newx(pc,len,unsigned char);
if (!pc) croak("out of memory");
pi = pc;
P_next_proto_negotiated(s)
const SSL *s
PREINIT:
const unsigned char *data;
unsigned int len;
PPCODE:
SSL_get0_next_proto_negotiated(s, &data, &len);
XPUSHs(sv_2mortal(newSVpv((char *)data, len)));
void
P_next_proto_last_status(s)
const SSL *s
PPCODE:
XPUSHs(sv_2mortal(newSVsv(cb_data_advanced_get((void*)s, "next_proto_select_cb!!last_status"))));
#endif
#if OPENSSL_VERSION_NUMBER >= 0x10000000L
i2d_OCSP_RESPONSE(r)
OCSP_RESPONSE * r
PREINIT:
STRLEN len;
unsigned char *pc,*pi;
PPCODE:
if (!(len = i2d_OCSP_RESPONSE(r,NULL))) croak("invalid OCSP response");
Newx(pc,len,unsigned char);
if (!pc) croak("out of memory");
pi = pc;
i2d_OCSP_RESPONSE(r,&pi);
i2d_OCSP_REQUEST(r)
OCSP_REQUEST * r
PREINIT:
STRLEN len;
unsigned char *pc,*pi;
PPCODE:
if (!(len = i2d_OCSP_REQUEST(r,NULL))) croak("invalid OCSP request");
Newx(pc,len,unsigned char);
if (!pc) croak("out of memory");
pi = pc;
i2d_OCSP_REQUEST(r,&pi);
X509 *cert,*issuer;
OCSP_CERTID *id;
int i;
STRLEN len;
unsigned char *pi;
PPCODE:
if (!ssl) croak("not a SSL object");
ctx = SSL_get_SSL_CTX(ssl);
if (!ctx) croak("invalid SSL object - no context");
store = SSL_CTX_get_cert_store(ctx);
OCSP_BASICRESP *bsr;
int i,want_array;
time_t nextupd = 0;
time_t gmtoff = -1;
int getall,sksn;
PPCODE:
bsr = OCSP_response_get1_basic(rsp);
if (!bsr) croak("invalid OCSP response");
want_array = (GIMME_V == G_LIST);
P_alpn_selected(s)
const SSL *s
PREINIT:
const unsigned char *data;
unsigned int len;
PPCODE:
SSL_get0_alpn_selected(s, &data, &len);
XPUSHs(sv_2mortal(newSVpv((char *)data, len)));
#endif
char *context_arg = NULL;
int use_context = 0;
int ret;
INPUT:
char * label = SvPV( ST(2), llen);
PPCODE:
Newx(out, outlen, unsigned char);
if (context != &PL_sv_undef) {
use_context = 1;
context_arg = SvPV( ST(3), contextlen);
Net-Silk
view release on metacpan or search on metacpan
RETVAL
void
num(THIS, ...)
Net::Silk::IPAddr THIS
PPCODE:
#if SK_ENABLE_IPV6
if (skipaddrIsV6(&THIS)) {
uint8_t *u8 = THIS.ip_ip.ipu_ipv6;
mXPUSHs(
newSVu128((((((((((((((((((((((((((((((((uint128_t)u8[0]) << 8)
void
octets(THIS)
Net::Silk::IPAddr THIS
PREINIT:
int i;
PPCODE:
#if SK_ENABLE_IPV6
if (skipaddrIsV6(&THIS)) {
uint8_t v6[16];
EXTEND(SP, 16);
skipaddrGetV6(&THIS, v6);
Net::Silk::IPAddr THIS
PREINIT:
char name[3];
sk_countrycode_t code;
int rv;
PPCODE:
rv = skCountrySetup(NULL, error_printf);
if (rv != 0)
croak("%s", error_buffer);
code = skCountryLookupCode(&THIS);
if (code != SK_COUNTRYCODE_INVALID)
next(THIS)
Net::Silk::IPWildcard::iter_xs THIS
PREINIT:
skipaddr_t raw_addr;
skIteratorStatus_t rv;
PPCODE:
rv = skIPWildcardIteratorNext(THIS, &raw_addr);
if (rv != SK_ITERATOR_NO_MORE_ENTRIES)
mXPUSHs(newSvIPADDR(aTHX_ &raw_addr));
void
Net::Silk::IPWildcard::iter_xs THIS
PREINIT:
skipaddr_t raw_addr;
uint32_t raw_prefix;
skIteratorStatus_t rv;
PPCODE:
rv = skIPWildcardIteratorNextCidr(THIS, &raw_addr, &raw_prefix);
if (rv != SK_ITERATOR_NO_MORE_ENTRIES) {
mXPUSHs(newSvIPADDR(aTHX_ &raw_addr));
mXPUSHu(raw_prefix);
}
#if SK_ENABLE_IPV6
uint128_t total;
#else
uint64_t total;
#endif
PPCODE:
total = 0;
for (i = 0; i < THIS.num_blocks; ++i) {
bittotal = 0;
for (j = THIS.m_min[i] >> 5; j <= THIS.m_max[i] >> 5; ++j) {
BITS_IN_WORD32(&bitcount, THIS.m_blocks[i][j]);
Net::Silk::IPSet::iter_xs THIS
PREINIT:
skipaddr_t raw_addr;
uint32_t raw_prefix;
int rv;
PPCODE:
rv = skIPSetIteratorNext(THIS, &raw_addr, &raw_prefix);
if (rv != SK_ITERATOR_NO_MORE_ENTRIES) {
mXPUSHs(newSvIPADDR(aTHX_ &raw_addr));
if (THIS->cidr_blocks)
mXPUSHu(raw_prefix);
skBagCounterType_t counter_type
PREINIT:
skBagTypedKey_t key;
skBagTypedCounter_t counter;
skBagErr_t rv;
PPCODE:
key.type = key_type;
counter.type = counter_type;
rv = skBagIteratorNextTyped(THIS, &key, &counter);
if (rv != SKBAG_ERR_KEY_NOT_FOUND) {
if (rv != SKBAG_OK)
Net::Silk::Bag THIS
PREINIT:
skBagFieldType_t type;
size_t len;
char buf[80];
PPCODE:
type = skBagKeyFieldName(THIS, buf, sizeof(buf));
len = skBagKeyFieldLength(THIS);
mXPUSHu(type);
mXPUSHu(len);
if (IS_IP_KEY(type)) {
PREINIT:
uint32_t val;
skipaddr_t lo;
skipaddr_t hi;
skIteratorStatus_t rv;
PPCODE:
rv = skPrefixMapIteratorNext(THIS, &lo, &hi, &val);
if (rv != SK_ITERATOR_NO_MORE_ENTRIES) {
if (rv != SK_ITERATOR_OK)
croak("error %d pmap iterator", rv);
mXPUSHs(newSvIPADDR(aTHX_ &lo));
PREINIT:
uint32_t val;
skPrefixMapProtoPort_t lo;
skPrefixMapProtoPort_t hi;
skIteratorStatus_t rv;
PPCODE:
rv = skPrefixMapIteratorNext(THIS, &lo, &hi, &val);
if (rv != SK_ITERATOR_NO_MORE_ENTRIES) {
if (rv != SK_ITERATOR_OK)
croak("error %d pmap iterator", rv);
mXPUSHs(newSvPROTOPORT(aTHX_ lo));
save(THIS, fname)
Net::Silk::Pmap THIS
const char *fname
PREINIT:
skPrefixMapErr_t rv;
PPCODE:
rv = skPrefixMapSave(THIS, fname);
if (rv != SKPREFIXMAP_OK)
croak("error %d saving prefix map to %s: %s",
rv, fname, skPrefixMapStrerror(rv));
_set_content_type(THIS, type)
Net::Silk::Pmap THIS
skPrefixMapContent_t type
PREINIT:
skPrefixMapErr_t rv;
PPCODE:
rv = skPrefixMapSetContentType(THIS, type);
if (rv != SKPREFIXMAP_OK)
croak("error %d setting pmap content type: %s",
rv, skPrefixMapStrerror(rv));
_set_default_value(THIS, val)
Net::Silk::Pmap THIS
uint32_t val
PREINIT:
skPrefixMapErr_t rv;
PPCODE:
rv = skPrefixMapSetDefaultVal(THIS, val);
if (rv != SKPREFIXMAP_OK)
croak("error %d setting default pmap value: %s",
rv, skPrefixMapStrerror(rv));
Net::Silk::Pmap THIS
uint32_t val
const char *label
PREINIT:
skPrefixMapErr_t rv;
PPCODE:
rv = skPrefixMapDictionaryInsert(THIS, val, label);
if (rv != SKPREFIXMAP_OK)
croak("error %d inserting pmap label: %s",
rv, skPrefixMapStrerror(rv));
_label_to_val(THIS, label)
Net::Silk::Pmap THIS
char *label
PREINIT:
uint32_t idx;
PPCODE:
idx = skPrefixMapDictionaryLookup(THIS, label);
if (idx != SKPREFIXMAP_NOT_FOUND)
mXPUSHu(idx);
void
uint32_t max_size
PREINIT:
char *buf;
uint32_t len;
int rv;
PPCODE:
if (val != SKPREFIXMAP_NOT_FOUND && val >= 0) {
if (val >= skPrefixMapDictionaryGetWordCount(THIS))
croak("invalid value index (%u out of range 0-%u)",
val, skPrefixMapDictionaryGetWordCount(THIS));
// len = skPrefixMapDictionaryGetMaxWordSize(THIS) + 1;
skipaddr_t addr_hi;
skPrefixMapProtoPort_t pp_lo;
skPrefixMapProtoPort_t pp_hi;
skPrefixMapContent_t content;
skPrefixMapErr_t rv;
PPCODE:
content = skPrefixMapGetContentType(THIS);
switch (content) {
case SKPREFIXMAP_CONT_ADDR_V4:
addr_lo = SvIPV4ADDR(aTHX_ sv_lo);
addr_hi = SvIPV4ADDR(aTHX_ sv_hi);
skPrefixMapProtoPort_t pp_key;
skPrefixMapProtoPort_t pp_lo;
skPrefixMapProtoPort_t pp_hi;
skPrefixMapContent_t content;
skPrefixMapErr_t rv;
PPCODE:
content = skPrefixMapGetContentType(THIS);
switch (content) {
case SKPREFIXMAP_CONT_ADDR_V4:
addr_key = SvIPV4ADDR(aTHX_ sv_key);
rv = skPrefixMapFindRange(THIS, &addr_key, &addr_lo, &addr_hi);
void *key = NULL;
uint32_t val;
skipaddr_t addr;
skPrefixMapProtoPort_t pp;
skPrefixMapContent_t content;
PPCODE:
content = skPrefixMapGetContentType(THIS);
switch (content) {
case SKPREFIXMAP_CONT_ADDR_V4:
addr = SvIPV4ADDR(aTHX_ sv_key);
key = &addr;
parse_high_mask(repr)
const char *repr
PREINIT:
int rv;
uint8_t high, mask;
PPCODE:
rv = skStringParseTCPFlagsHighMask(&high, &mask, repr);
if (rv == SKUTILS_ERR_SHORT) {
mask = high;
} else if (rv != SKUTILS_OK) {
croak("Illegal flag/mask: %s", repr);
Net::Silk::Site::iter_xs THIS
PREINIT:
char path[PATH_MAX];
int missing;
int rv;
PPCODE:
rv = sksiteRepoIteratorNextPath(THIS, path, sizeof(path), &missing);
if (rv != SK_ITERATOR_NO_MORE_ENTRIES) {
mXPUSHs(newSVpvn(path, strlen(path)));
}
void
sensor_ids()
PREINIT:
sk_sensor_iter_t sensor_iter;
sk_sensor_id_t id;
PPCODE:
sksiteSensorIterator(&sensor_iter);
while (sksiteSensorIteratorNext(&sensor_iter, &id)) {
mXPUSHu(id);
}
sensor_classes_by_id(id)
sk_sensor_id_t id
PREINIT:
sk_class_iter_t class_iter;
sk_class_id_t class;
PPCODE:
sksiteSensorClassIterator(id, &class_iter);
while (sksiteClassIteratorNext(&class_iter, &class)) {
mXPUSHu(class);
}
void
class_ids()
PREINIT:
sk_class_iter_t class_iter;
sk_class_id_t id;
PPCODE:
sksiteClassIterator(&class_iter);
while (sksiteClassIteratorNext(&class_iter, &id)) {
mXPUSHu(id);
}
class_sensors_by_id(id)
sk_class_id_t id
PREINIT:
sk_sensor_iter_t sensor_iter;
sk_sensor_id_t sensor;
PPCODE:
sksiteClassSensorIterator(id, &sensor_iter);
while (sksiteSensorIteratorNext(&sensor_iter, &sensor)) {
mXPUSHu(sensor);
}
class_flowtypes_by_id(id)
sk_class_id_t id
PREINIT:
sk_flowtype_iter_t flowtype_iter;
sk_flowtype_id_t flowtype;
PPCODE:
sksiteClassFlowtypeIterator(id, &flowtype_iter);
while (sksiteFlowtypeIteratorNext(&flowtype_iter, &flowtype)) {
mXPUSHu(flowtype);
}
class_default_flowtypes_by_id(id)
sk_class_id_t id
PREINIT:
sk_flowtype_iter_t flowtype_iter;
sk_flowtype_id_t flowtype;
PPCODE:
sksiteClassDefaultFlowtypeIterator(id, &flowtype_iter);
while (sksiteFlowtypeIteratorNext(&flowtype_iter, &flowtype)) {
mXPUSHu(flowtype);
}
void
flowtype_ids()
PREINIT:
sk_flowtype_iter_t flowtype_iter;
sk_flowtype_id_t id;
PPCODE:
sksiteFlowtypeIterator(&flowtype_iter);
while (sksiteFlowtypeIteratorNext(&flowtype_iter, &id)) {
mXPUSHu(id);
}
void
to_ipv4(THIS)
Net::Silk::RWRec THIS
PREINIT:
rwRec copy;
PPCODE:
copy = *THIS;
#if SK_ENABLE_IPV6
if (rwRecIsIPv6(©)) {
if (!rwRecConvertToIPv4(©))
goto proceed;
rwRecSetTcpState(THIS, state);
void
get_initial_tcpflags(THIS)
Net::Silk::RWRec THIS
PPCODE:
if (!(!(rwRecGetTcpState(THIS) & SK_TCPSTATE_EXPANDED)))
mXPUSHs(newSvTCPFLAGS(aTHX_ rwRecGetInitFlags(THIS)));
void
set_initial_tcpflags(THIS, flags)
rwRecSetFlags(THIS, rwRecGetRestFlags(THIS) | flags);
void
get_session_tcpflags(THIS)
Net::Silk::RWRec THIS
PPCODE:
if (!(!(rwRecGetTcpState(THIS) & SK_TCPSTATE_EXPANDED)))
mXPUSHs(newSvTCPFLAGS(aTHX_ rwRecGetRestFlags(THIS)));
void
set_session_tcpflags(THIS, flags)
PREINIT:
sk_file_header_t *hdr;
sk_header_entry_t *entry;
sk_hentry_iterator_t iter;
const char *invoc;
PPCODE:
hdr = skStreamGetSilkHeader(THIS);
if (hdr != NULL) {
skHeaderIteratorBindType(&iter, hdr, SK_HENTRY_INVOCATION_ID);
while ((entry = skHeaderIteratorNext(&iter)) != NULL) {
//invoc = ((sk_hentry_invocation_t*)entry)->command_line;
PREINIT:
sk_file_header_t *hdr;
sk_header_entry_t *entry;
sk_hentry_iterator_t iter;
const char *annot;
PPCODE:
hdr = skStreamGetSilkHeader(THIS);
if (hdr != NULL) {
skHeaderIteratorBindType(&iter, hdr, SK_HENTRY_ANNOTATION_ID);
while ((entry = skHeaderIteratorNext(&iter)) != NULL) {
//annot = ((sk_hentry_annotation_t*)entry)->annotation;
read(THIS)
Net::Silk::File::io_xs THIS
PREINIT:
int rv;
rwRec rec;
PPCODE:
rv = skStreamReadRecord(THIS, &rec);
if (rv == 0) {
mXPUSHs(newSvRWREC(aTHX_ &rec));
} else if (rv != SKSTREAM_ERR_EOF) {
_stream_croak(aTHX_ THIS, rv);
Net-TCPwrappers
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Net-WDNS
view release on metacpan or search on metacpan
STRLEN name_len;
size_t sz;
wdns_res res;
const char *rstr;
char rev[WDNS_MAXLEN_NAME];
PPCODE:
name = (void *)SvPV(sv_name, name_len);
res = wdns_len_uname(name, name + name_len, &sz);
if (res != wdns_res_success) {
rstr = wdns_res_to_str(res);
croak("problem determining name length (err %d: %s)", (int)res, rstr);
wdns_name_t chop;
wdns_name_t name;
size_t sz;
wdns_res res;
const char *rstr;
PPCODE:
name.data = (void *)SvPV(sv_name, name_len);
name.len = name_len;
res = wdns_len_uname(name.data, name.data + name.len, &sz);
if (res != wdns_res_success) {
rstr = wdns_res_to_str(res);
PREINIT:
const uint8_t *src;
STRLEN src_len;
char tgt[WDNS_PRESLEN_NAME];
STRLEN tgt_len;
PPCODE:
src = (void *)SvPV(src_sv, src_len);
tgt_len = wdns_domain_to_str(src, src_len, tgt);
// tgt_len is number of bytes read from source, not length of result
if (tgt_len != 0)
mXPUSHs(newSVpv(tgt, 0));
wdns_rrset_array_to_str(a, sec)
wdns_rrset_array_t *a
unsigned sec
PREINIT:
char *str;
PPCODE:
str = wdns_rrset_array_to_str(a, sec);
mXPUSHs(newSVpv(str, 0));
Safefree(str);
void
wdns_rrset_to_str(rrset, sec)
wdns_rrset_t *rrset
unsigned sec
PREINIT:
char *str;
PPCODE:
str = wdns_rrset_to_str(rrset, sec);
mXPUSHs(newSVpv(str, 0));
Safefree(str);
void
rr_to_str(rr, sec)
wdns_rr_t *rr
unsigned sec
PREINIT:
char *str;
PPCODE:
str = wdns_rr_to_str(rr, sec);
mXPUSHs(newSVpv(str, 0));
Safefree(str);
void
uint16_t rrclass
PREINIT:
STRLEN rdlen;
char *src_str;
char *tgt_str;
PPCODE:
src_str = SvPV(sv_rdata, rdlen);
tgt_str = wdns_rdata_to_str(src_str, (uint16_t)rdlen, rrtype, rrclass);
mXPUSHs(newSVpv(tgt_str, 0));
Safefree(tgt_str);
PREINIT:
uint8_t *rd;
size_t rdlen;
wdns_res res;
const char *rstr;
PPCODE:
res = wdns_str_to_rdata(str, rrtype, rrclass, &rd, &rdlen);
if (res != wdns_res_success) {
rstr = wdns_res_to_str(res);
croak("problem converting str to rdata (err %d: %s)", (int)res, rstr);
}
char *src
PREINIT:
wdns_name_t name;
wdns_res res;
const char *rstr;
PPCODE:
res = wdns_str_to_name(src, &name);
if (res != wdns_res_success) {
rstr = wdns_res_to_str(res);
croak("problem converting str to name (err %d: %s)", (int)res, rstr);
}
char *src
PREINIT:
wdns_name_t name;
wdns_res res;
const char *rstr;
PPCODE:
res = wdns_str_to_name_case(src, &name);
if (res != wdns_res_success) {
rstr = wdns_res_to_str(res);
croak("problem converting str to name case (err %d: %s)",
(int)res, rstr);
void
message_to_str(m)
wdns_message_t *m
PREINIT:
char *str;
PPCODE:
str = wdns_message_to_str(m);
mXPUSHs(newSVpv(str, 0));
Safefree(str);
void
AV *section;
AV *rrset;
AV *rdata;
SV *rd;
SV *rs;
PPCODE:
if (i >= 4)
croak("section out of range (0-3)");
a = &m->sections[i];
section = newAV();
mXPUSHs(newRV_noinc((SV *)section));
Net-ZooKeeper
view release on metacpan or search on metacpan
ZooKeeper.xs view on Meta::CPAN
ZOO_CREATOR_ALL_ACL = 3
PREINIT:
struct ACL_vector acl;
AV *acl_arr;
int i;
PPCODE:
if (!ix && !alias) {
alias = GvNAME(CvGV(cv));
}
if (ix == 1 || (alias != NULL && strEQ(alias, "ZOO_OPEN_ACL_UNSAFE"))) {
ZooKeeper.xs view on Meta::CPAN
void
zk_set_log_level(level)
int level
PPCODE:
if (level < ZOO_LOG_LEVEL_OFF || level > ZOO_LOG_LEVEL_DEBUG) {
Perl_croak(aTHX_ "invalid log level: %d", level);
}
zoo_set_debug_level(level);
ZooKeeper.xs view on Meta::CPAN
void
zk_set_deterministic_conn_order(flag)
bool flag
PPCODE:
zoo_deterministic_conn_order(!!flag);
XSRETURN_EMPTY;
void
zk_set_ignore_session_events(flag)
bool flag
PPCODE:
zk_ignore_session_events = flag;
XSRETURN_EMPTY;
void
ZooKeeper.xs view on Meta::CPAN
zk_t *zk;
zk_handle_t *handle;
HV *stash, *zk_hash, *attr_hash;
SV *attr;
int i;
PPCODE:
if (items > 2 && items % 2) {
Perl_croak(aTHX_ "invalid number of arguments");
}
for (i = 2; i < items; i += 2) {
ZooKeeper.xs view on Meta::CPAN
Net::ZooKeeper zkh
PREINIT:
zk_handle_t *handle;
HV *attr_hash;
int ret = ZBADARGUMENTS;
PPCODE:
handle = _zk_check_handle_outer(aTHX_ zkh, &attr_hash,
PACKAGE_NAME, PACKAGE_SIGNATURE);
if (!handle) {
handle = _zk_check_handle_inner(aTHX_ zkh, PACKAGE_SIGNATURE);
ZooKeeper.xs view on Meta::CPAN
void
zk_CLONE(package)
char *package
PPCODE:
XSRETURN_EMPTY;
void
zk_CLONE_SKIP(package)
char *package
PPCODE:
XSRETURN_YES;
void
zk_TIEHASH(package, ...)
char *package
PPCODE:
Perl_croak(aTHX_ "tying hashes of class "
PACKAGE_NAME " not supported");
void
zk_UNTIE(attr_hash, ref_count)
Net::ZooKeeper attr_hash
IV ref_count
PPCODE:
Perl_croak(aTHX_ "untying hashes of class "
PACKAGE_NAME " not supported");
void
zk_FIRSTKEY(attr_hash)
Net::ZooKeeper attr_hash
PREINIT:
zk_t *zk;
PPCODE:
zk = _zk_get_handle_inner(aTHX_ attr_hash);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_t *zk;
char *key;
int i;
PPCODE:
zk = _zk_get_handle_inner(aTHX_ attr_hash);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
void
zk_SCALAR(attr_hash)
Net::ZooKeeper attr_hash
PPCODE:
XSRETURN_YES;
void
zk_FETCH(attr_hash, attr_key)
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_t *zk;
char *key;
SV *val = NULL;
PPCODE:
zk = _zk_get_handle_inner(aTHX_ attr_hash);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
SV *attr_val
PREINIT:
zk_t *zk;
char *key;
PPCODE:
zk = _zk_get_handle_inner(aTHX_ attr_hash);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_t *zk;
char *key;
int i;
PPCODE:
zk = _zk_get_handle_inner(aTHX_ attr_hash);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
void
zk_DELETE(attr_hash, attr_key)
Net::ZooKeeper attr_hash
SV *attr_key
PPCODE:
Perl_warn(aTHX_ "deleting elements from hashes of class "
PACKAGE_NAME " not supported");
XSRETURN_EMPTY;
void
zk_CLEAR(attr_hash)
Net::ZooKeeper attr_hash
PPCODE:
Perl_warn(aTHX_ "clearing hashes of class "
PACKAGE_NAME " not supported");
XSRETURN_EMPTY;
ZooKeeper.xs view on Meta::CPAN
PREINIT:
zk_t *zk;
STRLEN cert_len;
zk_watch_t *watch;
int ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
char *path_buf;
int path_buf_len;
AV *acl_arr = NULL;
struct ACL_vector acl;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
char *path
PREINIT:
zk_t *zk;
int version = -1;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
zk_watch_t *old_watch = NULL;
zk_handle_t *watch_handle = NULL;
watcher_fn watcher = NULL;
zk_watch_t *new_watch = NULL;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
zk_handle_t *watch_handle = NULL;
watcher_fn watcher = NULL;
zk_watch_t *new_watch = NULL;
struct String_vector strings;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
zk_handle_t *watch_handle = NULL;
char *buf;
watcher_fn watcher = NULL;
zk_watch_t *new_watch = NULL;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
zk_t *zk;
int version = -1;
zk_stat_t *stat = NULL;
STRLEN buf_len;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
PREINIT:
zk_t *zk;
zk_stat_t *stat = NULL;
struct ACL_vector acl;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
zk_t *zk;
const char *err;
int version = -1;
struct ACL_vector acl;
int i, ret;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
PREINIT:
zk_t *zk;
zk_handle_t *handle;
HV *stash, *stat_hash, *attr_hash;
SV *attr;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
zk_watch_t *watch;
zk_handle_t *handle;
HV *stash, *watch_hash, *attr_hash;
SV *attr;
int i;
PPCODE:
zk = _zk_get_handle_outer(aTHX_ zkh);
if (!zk) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
Net::ZooKeeper::Stat zksh
PREINIT:
zk_handle_t *handle;
HV *attr_hash;
int ret = ZBADARGUMENTS;
PPCODE:
handle = _zk_check_handle_outer(aTHX_ zksh, &attr_hash,
STAT_PACKAGE_NAME,
STAT_PACKAGE_SIGNATURE);
if (!handle) {
ZooKeeper.xs view on Meta::CPAN
void
zks_CLONE(package)
char *package
PPCODE:
XSRETURN_EMPTY;
void
zks_CLONE_SKIP(package)
char *package
PPCODE:
XSRETURN_YES;
void
zks_TIEHASH(package, ...)
char *package
PPCODE:
Perl_croak(aTHX_ "tying hashes of class "
STAT_PACKAGE_NAME " not supported");
void
zks_UNTIE(attr_hash, ref_count)
Net::ZooKeeper::Stat attr_hash
IV ref_count
PPCODE:
Perl_croak(aTHX_ "untying hashes of class "
STAT_PACKAGE_NAME " not supported");
void
zks_FIRSTKEY(attr_hash)
Net::ZooKeeper::Stat attr_hash
PREINIT:
zk_stat_t *stat;
PPCODE:
stat = _zks_get_handle_inner(aTHX_ attr_hash);
if (!stat) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_stat_t *stat;
char *key;
int i;
PPCODE:
stat = _zks_get_handle_inner(aTHX_ attr_hash);
if (!stat) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
void
zks_SCALAR(attr_hash)
Net::ZooKeeper::Stat attr_hash
PPCODE:
XSRETURN_YES;
void
zks_FETCH(attr_hash, attr_key)
ZooKeeper.xs view on Meta::CPAN
PREINIT:
zk_stat_t *stat;
char *key;
SV *val = NULL;
int i;
PPCODE:
stat = _zks_get_handle_inner(aTHX_ attr_hash);
if (!stat) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_val
PREINIT:
zk_stat_t *stat;
char *key;
int i;
PPCODE:
stat = _zks_get_handle_inner(aTHX_ attr_hash);
if (!stat) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_stat_t *stat;
char *key;
int i;
PPCODE:
stat = _zks_get_handle_inner(aTHX_ attr_hash);
if (!stat) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
void
zks_DELETE(attr_hash, attr_key)
Net::ZooKeeper::Stat attr_hash
SV *attr_key
PPCODE:
Perl_warn(aTHX_ "deleting elements from hashes of class "
STAT_PACKAGE_NAME " not supported");
XSRETURN_EMPTY;
void
zks_CLEAR(attr_hash)
Net::ZooKeeper::Stat attr_hash
PPCODE:
Perl_warn(aTHX_ "clearing hashes of class "
STAT_PACKAGE_NAME " not supported");
XSRETURN_EMPTY;
ZooKeeper.xs view on Meta::CPAN
Net::ZooKeeper::Watch zkwh
PREINIT:
zk_handle_t *handle;
HV *attr_hash;
int ret = ZBADARGUMENTS;
PPCODE:
handle = _zk_check_handle_outer(aTHX_ zkwh, &attr_hash,
WATCH_PACKAGE_NAME,
WATCH_PACKAGE_SIGNATURE);
if (!handle) {
ZooKeeper.xs view on Meta::CPAN
void
zkw_CLONE(package)
char *package
PPCODE:
XSRETURN_EMPTY;
void
zkw_CLONE_SKIP(package)
char *package
PPCODE:
XSRETURN_YES;
void
zkw_TIEHASH(package, ...)
char *package
PPCODE:
Perl_croak(aTHX_ "tying hashes of class "
WATCH_PACKAGE_NAME " not supported");
void
zkw_UNTIE(attr_hash, ref_count)
Net::ZooKeeper::Watch attr_hash
IV ref_count
PPCODE:
Perl_croak(aTHX_ "untying hashes of class "
WATCH_PACKAGE_NAME " not supported");
void
zkw_FIRSTKEY(attr_hash)
Net::ZooKeeper::Watch attr_hash
PREINIT:
zk_watch_t *watch;
PPCODE:
watch = _zkw_get_handle_inner(aTHX_ attr_hash);
if (!watch) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_watch_t *watch;
char *key;
int i;
PPCODE:
watch = _zkw_get_handle_inner(aTHX_ attr_hash);
if (!watch) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
void
zkw_SCALAR(attr_hash)
Net::ZooKeeper::Watch attr_hash
PPCODE:
XSRETURN_YES;
void
zkw_FETCH(attr_hash, attr_key)
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_watch_t *watch;
char *key;
SV *val = NULL;
PPCODE:
watch = _zkw_get_handle_inner(aTHX_ attr_hash);
if (!watch) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
SV *attr_val
PREINIT:
zk_watch_t *watch;
char *key;
PPCODE:
watch = _zkw_get_handle_inner(aTHX_ attr_hash);
if (!watch) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
SV *attr_key
PREINIT:
zk_watch_t *watch;
char *key;
int i;
PPCODE:
watch = _zkw_get_handle_inner(aTHX_ attr_hash);
if (!watch) {
Perl_croak(aTHX_ "invalid handle");
}
ZooKeeper.xs view on Meta::CPAN
void
zkw_DELETE(attr_hash, attr_key)
Net::ZooKeeper::Watch attr_hash
SV *attr_key
PPCODE:
Perl_warn(aTHX_ "deleting elements from hashes of class "
WATCH_PACKAGE_NAME " not supported");
XSRETURN_EMPTY;
void
zkw_CLEAR(attr_hash)
Net::ZooKeeper::Watch attr_hash
PPCODE:
Perl_warn(aTHX_ "clearing hashes of class "
WATCH_PACKAGE_NAME " not supported");
XSRETURN_EMPTY;
ZooKeeper.xs view on Meta::CPAN
zk_watch_t *watch;
unsigned int timeout;
struct timeval end_timeval;
int i, done;
struct timespec wait_timespec;
PPCODE:
watch = _zkw_get_handle_outer(aTHX_ zkwh, NULL);
if (!watch) {
Perl_croak(aTHX_ "invalid handle");
}
( run in 2.519 seconds using v1.01-cache-2.11-cpan-71847e10f99 )