Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 3.498 )
Net-Bind-rbldnsdAccessor
view release on metacpan or search on metacpan
rbldnsdAccessor.xs view on Meta::CPAN
char c
PREINIT:
SV * len;
PPCODE:
if (max >= RBLF_DLEN)
croak ("maximum transfer length exceeds internal buffer %d\n",RBLF_DLEN);
memset(abuf,c,RBLF_DLEN);
XPUSHs(sv_2mortal(newSViv(rblf_strncpy(abuf,src,max))));
rbldnsdAccessor.xs view on Meta::CPAN
PREINIT:
STRLEN len;
unsigned char * cp;
int rv;
PPCODE:
invalid_pkt = 1;
cp = (unsigned char *)SvPV(buffer,len);
bzero(&pkt,sizeof(struct dnspacket));
rv = rblf_safemcpy(pkt.p_buf, cp, (size_t)len,(pkt.p_buf + DNS_MAXPACKET));
if (rv < 0) {
rbldnsdAccessor.xs view on Meta::CPAN
void
rblf_next_answer()
PREINIT:
SV * rd;
PPCODE:
if (invalid_pkt) {
bail:
if (GIMME_V != G_ARRAY)
XSRETURN_UNDEF;
XSRETURN_EMPTY;
rbldnsdAccessor.xs view on Meta::CPAN
char * name
PREINIT:
int answers = 0;
PPCODE:
invalid_pkt = rblf_query(name,&pkt);
if (!invalid_pkt)
answers = (int)(pkt.p_buf[p_ancnt2]);
XPUSHs(sv_2mortal(newSViv(answers)));
rbldnsdAccessor.xs view on Meta::CPAN
rblf_dump_packet()
PREINIT:
STRLEN len;
PPCODE:
if (pkt.p_endp == NULL) {
bail:
if (GIMME != G_ARRAY)
XSRETURN_UNDEF;
XSRETURN_EMPTY;
Net-Bluetooth
view release on metacpan or search on metacpan
void
_close(sock)
int sock
PPCODE:
close(sock);
InOutStream
_perlfh(fd)
int fd
RETVAL
void
get_remote_devices(...)
PPCODE:
EXTEND(sp, 1);
char addr[19];
char name[248];
char *local_addr;
int len = 8; // 1.28 * len
void
sdp_search(addr, service, name)
char *addr
char *service
char *name
PPCODE:
EXTEND(sp, 1);
uuid_t svc_uuid;
bdaddr_t target;
sdp_list_t *response_list = NULL;
sdp_session_t *session = 0;
void
_accept(fd, proto)
int fd
char *proto
PPCODE:
EXTEND(sp, 2);
socklen_t addr_len;
int res;
if(strcasecmp(proto, "RFCOMM") == 0) {
char *proto
int port
char *service_id
char *name
char *desc
PPCODE:
uint8_t rfcomm_channel = 0;
uint16_t l2cap_port = 0;
const char *service_name = name;
const char *service_dsc = desc;
const char *service_prov = name;
void
_getpeername(fd, proto)
int fd
char *proto
PPCODE:
EXTEND(sp, 2);
if(strcasecmp(proto, "RFCOMM") == 0) {
struct sockaddr_rc rcaddr;
socklen_t len = sizeof(rcaddr);
if(getpeername(fd, (struct sockaddr *) &rcaddr, &len) == 0) {
Net-CDP
view release on metacpan or search on metacpan
PROTOTYPE:
PREINIT:
dMY_CXT;
UV count;
cdp_llist_t *ports;
PPCODE:
MY_CXT.errors[0] = '\0';
if (GIMME_V == G_VOID) XSRETURN_EMPTY;
ports = cdp_get_ports(MY_CXT.errors);
if (!ports) croak(MY_CXT.errors);
PUSH_port_llist(ports);
addresses(self)
Net_CDP self
PROTOTYPE: $
PREINIT:
const cdp_llist_t *addresses;
PPCODE:
addresses = cdp_get_addresses(self);
PUSH_llist(addresses, "Net::CDP::Address");
int
_fd(self)
void
addresses(self, new_addresses=NULL)
Net_CDP_Packet self
Net_CDP_Address_List new_addresses
PROTOTYPE: $;$
PPCODE:
if (items > 1) {
if (self->addresses) cdp_llist_free(self->addresses);
self->addresses = new_addresses;
}
PUSH_llist(self->addresses, "Net::CDP::Address");
void
ip_prefixes(self, new_ip_prefixes=NULL)
Net_CDP_Packet self
Net_CDP_IPPrefix_List new_ip_prefixes
PROTOTYPE: $;$
PPCODE:
if (items > 1) {
if (self->ip_prefixes) cdp_llist_free(self->ip_prefixes);
self->ip_prefixes = new_ip_prefixes;
}
PUSH_llist(self->ip_prefixes, "Net::CDP::IPPrefix");
voice_vlan(self, new_voice_vlan=NULL, new_appliance_id=NULL)
Net_CDP_Packet self
U16_UNDEF new_voice_vlan
U8_UNDEF new_appliance_id
PROTOTYPE: $;$$
PPCODE:
if (items > 1) {
if (new_voice_vlan && (*new_voice_vlan < 1 || *new_voice_vlan > MAX_VLAN_ID))
croak("Invalid new_voice_vlan (must be between 1 and %u)", MAX_VLAN_ID);
if (new_appliance_id && *new_appliance_id < 1)
croak("Invalid new_appliance_id (must be between 1 and 255)");
voice_vlan_query(self, new_voice_vlan=NULL, new_appliance_id=NULL)
Net_CDP_Packet self
U16_UNDEF new_voice_vlan
U8_UNDEF new_appliance_id
PROTOTYPE: $;$$
PPCODE:
if (items > 1) {
if (new_voice_vlan && (*new_voice_vlan < 1 || *new_voice_vlan > MAX_VLAN_ID))
croak("Invalid new_voice_vlan (must be between 1 and %u)", MAX_VLAN_ID);
if (new_appliance_id && *new_appliance_id < 1)
croak("Invalid new_appliance_id (must be between 1 and 255)");
void
management_addresses(self, new_addresses=NULL)
Net_CDP_Packet self
Net_CDP_Address_List new_addresses
PROTOTYPE: $;$
PPCODE:
if (items > 1) {
if (self->mgmt_addresses) cdp_llist_free(self->mgmt_addresses);
self->mgmt_addresses = new_addresses;
CHECK_VERSION;
}
Net-CIDR-Compare
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-CUPS
view release on metacpan or search on metacpan
RETVAL
void
NETCUPS_getDestination( name )
char* name;
PPCODE:
cups_dest_t * destinations = NULL;
cups_dest_t * destination = NULL;
int count = 0;
SV* rv = NULL;
count = cupsGetDests( &destinations );
XPUSHs( rv );
XSRETURN( 1 );
void
NETCUPS_getDestinations()
PPCODE:
cups_dest_t * destinations = NULL;
int count = 0;
int loop = 0;
SV* rv = NULL;
count = cupsGetDests( &destinations );
void
NETCUPS_requestData( request, resource, filename )
ipp_t* request;
const char* resource;
const char* filename;
PPCODE:
http_t* http = NULL;
ipp_t* response = NULL;
const char* server = NULL;
SV* rv = NULL;
int port;
http_t *http; /* HTTP object */
ipp_t *request; /* IPP request object */
ipp_t *response; /* IPP response object */
ipp_attribute_t *attr; /* Current IPP attribute */
PPCODE:
SV* rv = NULL;
int count = 0;
cups_lang_t *language;
language = cupsLangDefault();
http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption());
http_t *http; /* HTTP object */
ipp_t *request; /* IPP request object */
ipp_t *response; /* IPP response object */
ipp_attribute_t *attr; /* Current IPP attribute */
PPCODE:
SV* rv = NULL;
int count = 0;
cups_lang_t *language;
language = cupsLangDefault();
http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption());
void
NETCUPS_deleteDestination( destination );
const char* destination;
PPCODE:
ipp_t *request;
http_t *http;
char uri[HTTP_MAX_URI];
httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
const char* location;
const char* printer_info;
const char* ppd_name;
const char* device_uri;
PPCODE:
http_t *http = NULL; /* HTTP object */
ipp_t *request = NULL; /* IPP request object */
char uri[HTTP_MAX_URI]; /* Job URI */
http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption());
void
NETCUPS_getPPDFileName(ppdfilename);
const char* ppdfilename;
PPCODE:
http_t *http; /* HTTP object */
ipp_t *request; /* IPP request object */
ipp_t *response; /* IPP response object */
ipp_attribute_t *attr; /* Current IPP attribute */
int i = 0;
NETCUPS_getDeviceAttribute( device, attribute, attribute_type )
const char* device;
const char* attribute;
int attribute_type;
PPCODE:
http_t *http = NULL; /* HTTP object */
ipp_t *request = NULL; /* IPP request */
ipp_t *response = NULL; /* IPP response */
ipp_attribute_t *attr = NULL; /* IPP attribute */
SV* rv = NULL;
INIT:
int count = 0;
int loop = 0;
SV* rv = NULL;
cups_option_t* options = NULL;
PPCODE:
count = self->num_options;
options = self->options;
for( loop = 0; loop < count; loop++ )
{
void
NETCUPS_getJobs( dest, whose, scope )
const char* dest;
int whose;
int scope;
PPCODE:
int loop = 0;
int count = 0;
SV* rv = NULL;
cups_job_t* jobs = NULL;
count = cupsGetJobs( &jobs, dest, whose, scope );
void
NETCUPS_getAttributes( ipp )
ipp_t* ipp;
PPCODE:
SV* rv = NULL;
int count = 0;
ipp_attribute_t* attr = NULL;
for (attr = ippFirstAttribute(ipp); attr != NULL; attr = ippNextAttribute(ipp))
{
void
NETCUPS_getAttributeValue( ipp, name )
ipp_t* ipp;
const char* name;
PPCODE:
SV* rv = NULL;
int count = 0;
ipp_attribute_t* attr = NULL;
for (attr = ippFirstAttribute(ipp); attr != NULL; attr = ippNextAttribute(ipp))
{
OUTPUT:
RETVAL
void
NETCUPS_newIPP()
PPCODE:
ipp_t * ipp = NULL;
SV* rv = NULL;
ipp = ippNew();
rv = sv_newmortal();
sv_setref_pv( rv, "Net::CUPS::IPP", ipp );
XSRETURN( 1 );
void
NETCUPS_newIPPRequest( op )
ipp_op_t op;
PPCODE:
ipp_t * ipp = NULL;
SV* rv = NULL;
ipp = ippNewRequest( op );
rv = sv_newmortal();
sv_setref_pv( rv, "Net::CUPS::IPP", ipp );
Net-Connection-Sniffer
view release on metacpan or search on metacpan
PROTOTYPES: ENABLE
void
xs2p_gvars()
PPCODE:
EXTEND(SP,4);
PUSHs(sv_2mortal(newSVuv(now)));
PUSHs(sv_2mortal(newSVuv(start)));
PUSHs(sv_2mortal(newSVnv(rate)));
PUSHs(sv_2mortal(newSVnv(bw)));
int vector
PREINIT:
unsigned char * buf;
STRLEN len;
int dnslen, listenlen;
PPCODE:
switch(vector)
{
case SEND_dns :
if (av_len(dnsrequest) < 0) {
dnsRflag = 0;
HV * hp;
INIT:
if (SvTYPE(SvRV(hpp)) != SVt_PVHV)
croak("hp is not a hash REF");
hp = (HV *)SvRV(hpp);
PPCODE:
if (ix == 1) {
XPUSHs(sv_2mortal(newSVuv(fetch_uv(hp,key))));
XSRETURN(1);
} else
inc_sv(hp,key);
Net-Curl
view release on metacpan or search on metacpan
Curl_Easy.xsh view on Meta::CPAN
const char *sclass
SV *base
PREINIT:
perl_curl_easy_t *easy;
HV *stash;
PPCODE:
if ( ! SvOK( base ) || ! SvROK( base ) )
croak( "object base must be a valid reference\n" );
easy = perl_curl_easy_new();
perl_curl_easy_preset( easy );
Curl_Easy.xsh view on Meta::CPAN
PREINIT:
perl_curl_easy_t *clone;
const char *sclass;
perl_curl_easy_callback_code_t i;
HV *stash;
PPCODE:
if ( ! SvOK( base ) || ! SvROK( base ) )
croak( "object base must be a valid reference\n" );
sclass = sv_reftype( SvRV( ST(0) ), TRUE );
clone = perl_curl_easy_duphandle( easy );
Net-DNS-Native
view release on metacpan or search on metacpan
OUTPUT:
RETVAL
void
_get_result(Net_DNS_Native *self, int fd)
PPCODE:
pthread_mutex_lock(&self->mutex);
DNS_result *res = bstree_get(self->fd_map, fd);
bstree_del(self->fd_map, fd);
pthread_mutex_unlock(&self->mutex);
free(res->arg);
free(res);
void
_timedout(Net_DNS_Native *self, int fd)
PPCODE:
char unknown = 0;
pthread_mutex_lock(&self->mutex);
if (bstree_get(self->fd_map, fd) == NULL) {
unknown = 1;
queue_destroy(self->tout_queue);
Safefree(self);
void
pack_sockaddr_in6(int port, SV *sv_address)
PPCODE:
STRLEN len;
char *address = SvPV(sv_address, len);
if (len != 16)
croak("address length is %lu should be 16", len);
XPUSHs(sv_2mortal(newSVpvn((char*) addr, sizeof(struct sockaddr_in6))));
void
unpack_sockaddr_in6(SV *sv_addr)
PPCODE:
STRLEN len;
char *addr = SvPV(sv_addr, len);
if (len != sizeof(struct sockaddr_in6))
croak("address length is %lu should be %lu", len, sizeof(struct sockaddr_in6));
Net-DNS-SEC-Validator
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-DNS-ToolKit
view release on metacpan or search on metacpan
SV **aptrs;
STRLEN len, size, bsize;
u_char **lastdnptr, **aoff;
u_char * exp_dn, * msg, * comp_dn;
int i, v, dnsize;
PPCODE:
if (! SvROK(buffer) || ! SvROK(name))
XSRETURN_EMPTY;
# see: perlapi on 'svtype' and /usr/lib/perl5/i386-linux/CORE/sv.h
SV * header
PROTOTYPE: $
PREINIT:
STRLEN len;
MY_HEADER * hp;
PPCODE:
if (! SvROK(header))
XSRETURN_EMPTY;
hp = (MY_HEADER *)SvPV(SvRV(header),len);
EXTEND(SP, 16);
PROTOTYPE: $
PREINIT:
u_char bmask[] = {128,64,32,16,8,4,2,1};
unsigned int i, hi, lo, tens[] = {1000,100,10,1, 1000,100,10,1};
char out[15];
PPCODE:
hi = lo = 0;
for(i=0;i<4;i++) {
if (ch & bmask[i])
hi += tens[i];
}
PROTOTYPE: $$$
PREINIT:
STRLEN size;
unsigned char * cp;
SV * out;
PPCODE:
if (!SvROK(buffer)) /* not a pointer */
XSRETURN_EMPTY;
cp = (u_char *)(SvPV(SvRV(buffer),size) + off);
Net::DNS::ToolKit::get32 = 1
PREINIT:
SV * out;
STRLEN size;
u_char * cp;
PPCODE:
if (GIMME_V == G_VOID)
XSRETURN_UNDEF; /* punt, nothing to return */
if (!SvROK(buffer)) {
bail:
unsigned int off
PREINIT:
SV * netaddr;
STRLEN size;
u_char * cp, out[NS_INADDRSZ];
PPCODE:
if (GIMME_V == G_VOID)
XSRETURN_UNDEF; /* punt, nothing to return */
if (!SvROK(buffer)) {
bail:
unsigned int off
PREINIT:
SV * ipv6addr;
STRLEN size;
u_char * cp, out[NS_IN6ADDRSZ];
PPCODE:
if (GIMME_V == G_VOID)
XSRETURN_UNDEF; /* punt, nothing to return */
if (!SvROK(buffer)) {
bail:
void
gettimeofday()
PREINIT:
SV * tmp; /* older perl does not know about newSVuv */
PPCODE:
if (gettimeofday(&tv,NULL)) { /* any error */
if (GIMME_V == G_ARRAY)
XSRETURN_EMPTY;
else
XSRETURN_UNDEF;
}
XSRETURN(1);
void
get_default()
PPCODE:
mysin();
XPUSHs(sv_2mortal(newSVpvn((char *)&mysa.sin_addr, NS_INADDRSZ)));
XSRETURN(1);
void
get_path()
PREINIT:
SV * out;
PPCODE:
if (path == NULL)
XSRETURN_UNDEF;
out = sv_newmortal();
sv_setpvn(out, path, (STRLEN)pathz);
XPUSHs(out);
void
lastchance()
PREINIT:
int i, nscount;
u_char * netptr;
PPCODE:
if ((nscount = lchance()) < 1) {
if (GIMME_V != G_ARRAY)
XSRETURN_UNDEF;
else
XSRETURN_EMPTY;
Net-DNS_A
view release on metacpan or search on metacpan
char *host
INIT:
int res;
struct sigevent sev;
struct gaicb *gptr = &gcb;
PPCODE:
if (count) {
XPUSHs(sv_2mortal(newSViv(0)));
XPUSHs(sv_2mortal(newSVpv("Please call retrieve()", 0)));
}
else {
void
retrieve()
INIT:
int res;
char host[NI_MAXHOST];
PPCODE:
if (0 == count) {
XPUSHs(sv_2mortal(newSViv(0)));
XPUSHs(sv_2mortal(newSVpv("Please call lookup()", 0)));
}
Net-Drizzle
view release on metacpan or search on metacpan
inc/ExtUtils/ParseXS.pm view on Meta::CPAN
my $END = "!End!\n\n"; # "impossible" keyword (multiple newline)
# Match an XS keyword
$BLOCK_re= '\s*(' . join('|', qw(
REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE OUTPUT
CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE VERSIONCHECK INCLUDE
SCOPE INTERFACE INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK
)) . "|$END)\\s*:";
inc/ExtUtils/ParseXS.pm view on Meta::CPAN
s/^/&/ if $in_out{$_};
}
$func_args = join(", ", @func_args);
@args_match{@args} = @args_num;
$PPCODE = grep(/^\s*PPCODE\s*:/, @line);
$CODE = grep(/^\s*CODE\s*:/, @line);
# Detect CODE: blocks which use ST(n)= or XST_m*(n,v)
# to set explicit return values.
$EXPLICIT_RETURN = ($CODE &&
("@line" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x ));
inc/ExtUtils/ParseXS.pm view on Meta::CPAN
print Q(<<"EOF");
# PERL_UNUSED_VAR(cv); /* -W */
EOF
}
#gcc -Wall: if an xsub has PPCODE is used
#it is possible none of ST, XSRETURN or XSprePUSH macros are used
#hence `ax' (setup by dXSARGS) is unused
#XXX: could breakup the dXSARGS; into dSP;dMARK;dITEMS
#but such a move could break third-party extensions
print Q(<<"EOF") if $PPCODE;
# PERL_UNUSED_VAR(ax); /* -Wall */
EOF
print Q(<<"EOF") if $PPCODE;
# SP -= items;
EOF
# Now do a block of some sort.
inc/ExtUtils/ParseXS.pm view on Meta::CPAN
}
print $deferred;
process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD") ;
if (check_keyword("PPCODE")) {
print_section();
death ("PPCODE must be last thing") if @line;
print "\tLEAVE;\n" if $ScopeThisXSUB;
print "\tPUTBACK;\n\treturn;\n";
} elsif (check_keyword("CODE")) {
print_section() ;
} elsif (defined($class) and $func_name eq "DESTROY") {
inc/ExtUtils/ParseXS.pm view on Meta::CPAN
process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD") ;
print Q(<<"EOF") if $ScopeThisXSUB;
# ]]
EOF
print Q(<<"EOF") if $ScopeThisXSUB and not $PPCODE;
# LEAVE;
EOF
# print function trailer
print Q(<<"EOF");
inc/ExtUtils/ParseXS.pm view on Meta::CPAN
# if (errbuf[0])
# Perl_croak(aTHX_ errbuf);
EOF
if ($xsreturn) {
print Q(<<"EOF") unless $PPCODE;
# XSRETURN($xsreturn);
EOF
} else {
print Q(<<"EOF") unless $PPCODE;
# XSRETURN_EMPTY;
EOF
}
print Q(<<"EOF");
Net-ESMTP
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-FreeDB
view release on metacpan or search on metacpan
FreeDB.xs.linux view on Meta::CPAN
int i;
char id[30];
struct discdata data;
HV* hash = newHV();
AV* tracks = newAV();
PPCODE:
data = get_disc_id(dev);
for (i = 0; i < (data.num_of_trks); i++) {
av_push(tracks, newSVnv(data.track_offsets[i]));
}
Net-Hesiod
view release on metacpan or search on metacpan
char ** results;
char ** res;
int i;
dTARGET;
SV *tmp;
PPCODE:
results = hesiod_resolve(context,name,type);
/* Handle an invalid query */
if ( ! results ) { XSRETURN_EMPTY; }
res = results;
i =0;
const char * name;
PREINIT:
struct passwd *pw;
dTARGET;
SV *tmp;
PPCODE:
pw = hesiod_getpwnam(context,name);
/* Handle errors by returning empty */
if ( ! pw ) { XSRETURN_EMPTY; }
/* Presumably, have a valid response */
tmp = sv_newmortal(); sv_setpv(tmp,pw->pw_name);
uid_t uid;
PREINIT:
struct passwd *pw;
dTARGET;
SV *tmp;
PPCODE:
pw = hesiod_getpwuid(context,uid);
/* Handle errors by returning empty */
if ( ! pw ) { XSRETURN_EMPTY; }
/* Presumably, have a valid response */
tmp = sv_newmortal(); sv_setpv(tmp,pw->pw_name);
PREINIT:
struct servent *sent;
dTARGET;
SV *tmp;
int port;
PPCODE:
sent = hesiod_getservbyname(context,name, proto);
/* Handle errors by returning empty */
if ( ! sent ) { XSRETURN_EMPTY; }
/* Presumably, have a valid response */
/* servent struct is supposed to store port number in
char * user;
PREINIT:
struct hesiod_postoffice *po;
dTARGET;
SV * tmp;
PPCODE:
po = hesiod_getmailhost(context,user);
/* Handle errors by returning empty */
if ( ! po ) { XSRETURN_EMPTY; }
/* Presumably, have a valid response */
tmp= sv_newmortal(); sv_setpv(tmp,po->hesiod_po_type);
Net-IP-Match-Bin
view release on metacpan or search on metacpan
PREINIT:
XS2_CTX* ctx;
SV* sv;
int i;
PPCODE:
STRLEN len;
char *sclass = SvPV(class, len);
#if PVER >= 5008008
Newx(ctx, 1, XS2_CTX);
#else
PREINIT:
XS2_CTX* ctx;
SV* sv;
int i;
PPCODE:
if (!SvROK(self)) {
XSRETURN_UNDEF;
} else {
ctx = INT2PTR(XS2_CTX*, SvIV(SvRV(self)));
}
PREINIT:
XS2_CTX* ctx;
SV* sv;
int i;
PPCODE:
if (!SvROK(self)) {
XSRETURN_UNDEF;
} else {
ctx = INT2PTR(XS2_CTX*, SvIV(SvRV(self)));
}
char *p;
int i;
SV* sv;
int func_call;
int res;
PPCODE:
if (items < 2) {
/* too few args */
XSRETURN_UNDEF;
}
if (!SvROK(ST(0))) {
PREINIT:
XS2_CTX* ctx;
AV* out;
I32 i;
PPCODE:
I32 gimme = GIMME_V;
I32 len = 0;
if (!SvROK(self)) {
XSRETURN_UNDEF;
SV* self
PREINIT:
XS2_CTX* ctx;
PPCODE:
if (!SvROK(self)) {
XSRETURN_UNDEF;
} else {
ctx = INT2PTR(XS2_CTX*, SvIV(SvRV(self)));
_clean(aTHX_ ctx);
SV* self
PREINIT:
XS2_CTX* ctx;
PPCODE:
if (!SvROK(self)) {
XSRETURN_UNDEF;
} else {
ctx = INT2PTR(XS2_CTX*, SvIV(SvRV(self)));
_clean(aTHX_ ctx);
Net-IP-Util
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:
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-IP-XS
view release on metacpan or search on metacpan
char *prefix
PREINIT:
char buf[MAX_IPV6_STR_LEN];
int len;
int res;
PPCODE:
res = NI_ip_splitprefix(prefix, buf, &len);
if (res) {
XPUSHs(sv_2mortal(newSVpv(buf, 0)));
XPUSHs(sv_2mortal(newSViv(len)));
}
PREINIT:
char *prefixes[MAX_PREFIXES];
int pcount;
int res;
int i;
PPCODE:
pcount = 0;
res = NI_ip_range_to_prefix(begin, end, ipversion, prefixes, &pcount);
if (!res) {
for (i = 0; i < pcount; i++) {
free(prefixes[i]);
int len
int version
PREINIT:
char buf[MAX_IPV6_RANGE_STR_LEN];
int res;
PPCODE:
res = NI_ip_prefix_to_range(ip, len, version, buf);
if (res) {
XPUSHs(sv_2mortal(newSVpv(ip, 0)));
XPUSHs(sv_2mortal(newSVpv(buf, 0)));
} else {
char *ip
PREINIT:
char buf1[MAX_IPV6_STR_LEN];
char buf2[MAX_IPV6_STR_LEN];
int res;
PPCODE:
buf1[0] = '\0';
buf2[0] = '\0';
res = NI_ip_normalize(ip, buf1, buf2);
if (res >= 1) {
XPUSHs(sv_2mortal(newSVpv(buf1, 0)));
PREINIT:
char *prefixes[MAX_PREFIXES];
int pcount;
int res;
int i;
PPCODE:
if (!sv_isa(self, "Net::IP::XS")) {
ST(0) = &PL_sv_undef;
} else {
pcount = 0;
res = NI_find_prefixes(self, prefixes, &pcount);
Net-Interface
view release on metacpan or search on metacpan
inst/netsymbols.pl view on Meta::CPAN
print NFx qq|\t_NI_AF_TEST = __NI_AF_TEST
PREINIT:
SV * rv;
int n, i;
PPCODE:
if (ix >= $endv) {
croak("%s is not implemented on this architecture", GvNAME(CvGV(cv)));
}
rv = sv_2mortal(newSViv(ix));
n = sizeof(ni_af_sym_tab) / sizeof(ni_iff_t);
inst/netsymbols.pl view on Meta::CPAN
# add test element and complete
print NFx qq| PREINIT:
SV * rv;
int n, i;
PPCODE:
if (ix >= $endv) {
croak("%s is not implemented on this architecture", GvNAME(CvGV(cv)));
}
rv = sv_2mortal(newSVnv(bigsymvals[ix]));
n = sizeof(ni_sym_iff_tab) / sizeof(ni_iff_t);
Net-Kafka
view release on metacpan or search on metacpan
PREINIT:
plrd_kafka_t *krd;
rd_kafka_conf_t* conf;
rd_kafka_t* rk;
char errstr[ERRSTR_SIZE];
PPCODE:
Newxz(krd, 1, plrd_kafka_t);
conf = krd_parse_config(aTHX_ krd, params);
if (type == RD_KAFKA_PRODUCER) {
DEBUGF(krd->debug_xs, "Creating producer");
prd_init(krd, conf);
krd_queue_poll(rdk, timeout_ms = 0)
plrd_kafka_t *rdk
int timeout_ms
PREINIT:
rd_kafka_event_t* rke;
PPCODE:
rke = rd_kafka_queue_poll(rdk->queue, timeout_ms);
if (! rke) {
XSRETURN_EMPTY;
return;
}
void
krd_consumer_poll(rdk, timeout_ms = 0)
plrd_kafka_t *rdk
int timeout_ms
PPCODE:
rd_kafka_message_t *rd_msg = rd_kafka_consumer_poll( rdk->rk, timeout_ms );
if (! rd_msg) {
XSRETURN_EMPTY;
return;
void
krd_topic(rdk, topic)
plrd_kafka_t* rdk
char *topic
PPCODE:
rd_kafka_topic_t* rd_topic = rd_kafka_topic_new(rdk->rk, topic, NULL);
DEBUG2F(rdk->debug_xs, "Created Net::Kafka::Topic %s", rd_kafka_topic_name(rd_topic));
ST(0) = sv_newmortal();
sv_setref_pv( ST(0), "Net::Kafka::Topic", (void *)rd_topic );
XSRETURN(1);
int partition
long timeout_ms
PREINIT:
rd_kafka_resp_err_t err;
long low, high;
PPCODE:
err = rd_kafka_query_watermark_offsets(rdk->rk, topic, partition, &low, &high, timeout_ms);
if (err != RD_KAFKA_RESP_ERR_NO_ERROR) {
croak("Error querying watermark offsets: %s", rd_kafka_err2str(err));
}
EXTEND(SP, 2);
void
krdm_timestamp(rd_msg)
rd_kafka_message_t *rd_msg
PREINIT:
rd_kafka_timestamp_type_t tstype;
PPCODE:
long timestamp = rd_kafka_message_timestamp(rd_msg, &tstype);
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSViv(timestamp)));
PUSHs(sv_2mortal(newSViv(tstype)));
const void *value;
size_t value_len;
INPUT:
rd_kafka_headers_t* hdrs
const char *name
PPCODE:
err = rd_kafka_header_get_last(hdrs, name, &value, &value_len);
if (err == RD_KAFKA_RESP_ERR_NO_ERROR) {
PUSHs(sv_2mortal(newSVpvn(value, value_len)));
} else if (err == RD_KAFKA_RESP_ERR__NOENT) {
XSRETURN_UNDEF;
void
ktpl_get(rktpl, idx)
rd_kafka_topic_partition_list_t *rktpl
int idx
PPCODE:
if (!rktpl || idx < 0 || idx >= rktpl->cnt) {
return;
}
char* tn = rktpl->elems[idx].topic;
EXTEND(SP, 3);
rd_kafka_topic_partition_list_t *rktpl
char *topic
int partition
PREINIT:
rd_kafka_topic_partition_t *tp;
PPCODE:
tp = rd_kafka_topic_partition_list_find(rktpl, topic, partition);
if (tp == NULL) {
XSRETURN_EMPTY;
return;
}
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] = {};
( run in 3.498 seconds using v1.01-cache-2.11-cpan-4e7a2411597 )