/*
* This file was generated automatically by ExtUtils::ParseXS version 3.40 from the
* contents of Util.xs. Do not edit this file, edit Util.xs instead.
*
* ANY CHANGES MADE HERE WILL BE LOST!
*
*/
#line 1 "Util.xs"
/*
* Copyright 2006 - 2012, Michael Robinton <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _CYGWIN
#include <windows.h>
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
/* needed for testing with 'printf'
#include <stdio.h>
*/
#ifdef _CYGWIN
#include <Win32-Extensions.h>
#endif
#include "localconf.h"
#ifdef __cplusplus
}
#endif
/* workaround for OS's without inet_aton */
/* #include "xs_include/inet_aton.c" removed 10-12-11 */
typedef union
{
u_int32_t u[4];
unsigned char c[16];
} n128;
char * is_ipv6to4 = "ipv6to4", * is_shiftleft = "shiftleft", * is_comp128 = "comp128";
char * is_sub128 = "sub128", * is_add128 = "add128";
char * is_hasbits = "hasbits";
/* , * is_isIPv4 = "isIPv4"; */
char * is_bcd2bin = "bcd2bin", * is_simple_pack = "simple_pack", * is_bcdn2bin = "bcdn2bin";
char * is_mask4to6 = "mask4to6", * is_ipv4to6 = "ipv4to6";
char * is_maskanyto6 = "maskanyto6", * is_ipanyto6 = "ipanyto6";
typedef struct bcdstuff
{ /* character array of 40 bytes */
char txt[21]; /* 20 bytes + string terminator */
u_int32_t bcd[5]; /* 20 bytes, 40 digits */
} BCD;
#define zero ('0' & 0x7f)
/* useful for debug, prints the 128 bits of 8, 16 bit registers */
void
printb128(char * b)
{
int c;
for(c=0;c<16;c++) {
if (b[c] &0x80)
printf("1");
else
printf("0");
if (b[c] &0x40)
printf("1");
else
printf("0");
if (b[c] &0x20)
printf("1");
else
printf("0");
if (b[c] &0x10)
printf("1");
else
printf("0");
if (b[c] &0x8)
printf("1");
else
printf("0");
if (b[c] &0x4)
printf("1");
else
printf("0");
if (b[c] &0x2)
printf("1");
else
printf("0");
if (b[c] &0x1)
printf("1");
else
printf("0");
if (c == 3 || c == 7 || c == 11)
printf("\n");
}
printf("\n\n");
}
void
extendipv4(void * aa, void * ux)
{
register u_int32_t * a = ux;
*a++ = 0;
*a++ = 0;
*a++ = 0;
*a = *((u_int32_t *)aa);
}
void
extendmask4(void * aa, void * ux)
{
register u_int32_t * a = ux;
*a++ = 0xffffffff;
*a++ = 0xffffffff;
*a++ = 0xffffffff;
*a = *((u_int32_t *)aa);
}
void
fastcomp128(void * aa)
{
register u_int32_t * a = aa;
*a++ ^= 0xffffffff;
*a++ ^= 0xffffffff;
*a++ ^= 0xffffffff;
*a++ ^= 0xffffffff;
}
/* add two 128 bit numbers
return the carry
*/
int
adder128(void * aa, void * bb, n128 * ap128, int carry)
{
int i;
register u_int32_t a, b, r;
for (i=3; i >= 0; i--) {
a = *((u_int32_t *)aa + i);
b = *((u_int32_t *)bb + i);
r = a + b;
a = 0; /* ripple carry forward */
if ( r < a || r < b) /* if overflow */
a = 1;
b = r + carry; /* carry propagate in */
if (b < r) /* ripple carry forward */
carry = 1; /* if overflow */
else
carry = a;
*((u_int32_t *)(ap128->u) + i) = b;
}
return carry;
}
int
addercon(void * aa, u_int32_t * bb, n128 * ap128, int32_t con)
{
register u_int32_t tmp = 0x80000000;
if (con & tmp)
tmp = 0xffffffff;
else
tmp = 0;
bb[0] = tmp;
bb[1] = tmp;
bb[2] = tmp;
bb[3] = (u_int32_t)con;
return adder128(aa,bb,ap128,0);
}
int
have128(void * bp)
{
register u_int32_t * p = bp;
if (*p++ || *p++ || *p++ || *p++)
return 1;
return 0;
}
int
_isipv4(void * bp)
{
register u_int32_t * p = bp;
if (*p++ || *p++ || *p++)
return 0;
return 1;
}
/* network byte swap and copy */
void
netswap_copy(void * dest, void * src, int len)
{
register u_int32_t * d = dest, * s = src;
for (/* -- */;len>0;len--) {
#ifdef host_is_LITTLE_ENDIAN
*d++ = (((*s & 0xff000000) >> 24) | ((*s & 0x00ff0000) >> 8) | \
((*s & 0x0000ff00) << 8) | ((*s & 0x000000ff) << 24));
#else
# ifdef host_is_BIG_ENDIAN
*d++ = *s;
# else
# error ENDIANness not defined
# endif
#endif
s++;
}
}
/* do ntohl / htonl changes as necessary for this OS
*/
void
netswap(void * ap, int len)
{
#ifdef host_is_LITTLE_ENDIAN
register u_int32_t * a = ap;
for (/* -- */;len >0;len--) {
*a = (((*a & 0xff000000) >> 24) | ((*a & 0x00ff0000) >> 8) | \
((*a & 0x0000ff00) << 8) | ((*a & 0x000000ff) << 24));
a++;
}
#endif
}
/* shift right to purge '0's,
return mask bit count and remainder value,
left fill with ones
*/
unsigned char
_countbits(void *ap)
{
register u_int32_t * p0 = (u_int32_t *)ap, * p1 = p0 +1, * p2 = p1 +1, * p3 = p2 +1;
unsigned char count = 128;
fastcomp128(ap);
do {
if (!(*p3 & 1))
break;
count--;
*p3 >>= 1;
if (*p2 & 1)
*p3 |= 0x80000000;
*p2 >>= 1;
if (*p1 & 1)
*p2 |= 0x80000000;
*p1 >>= 1;
if (*p0 & 1)
*p1 |= 0x80000000;
*p0 >>= 1;
} while (count > 0);
return count;
}
/* multiply 128 bit number x 2
*/
void
_128x2(u_int32_t * ap)
{
register u_int32_t * p = ap +3, tmpc, carry = 0;
do {
tmpc = *p & 0x80000000; /* propagate hi bit to next word */
*p <<= 1;
if (carry)
*p += 1;
carry = tmpc;
} while (p-- > ap);
/* printf("2o %04X:%04X:%04X:%04X\n",*(ap),*(ap +1),*(ap +2),*(ap +3)); */
}
/* multiply 128 bit number X10
*/
void
_128x10(n128 * ap128, n128 * tp128)
{
register u_int32_t * ap = ap128->u, * tp = tp128->u;
_128x2(ap); /* multiply by two */
*tp = *ap; /* temp save */
*(tp +1) = *(ap +1);
*(tp +2) = *(ap +2);
*(tp +3) = *(ap +3);
_128x2(ap);
_128x2(ap); /* times 8 */
(void) adder128(ap,tp,ap128,0);
/* printf("x %04X:%04X:%04X:%04X\n",*((u_int32_t *)ap),*((u_int32_t *)ap +1),*((u_int32_t *)ap +2),*((u_int32_t *)ap +3)); */
}
/* multiply 128 bit number by 10, add bcd digit to result
*/
void
_128x10plusbcd(n128 * ap128, n128 * tp128, char digit)
{
register u_int32_t * ap = ap128->u, * tp = tp128->u;
/* printf("digit %X + %X = ",digit,*(ap +3)); */
_128x10(ap128,tp128);
*tp = 0;
*(tp + 1) = 0;
*(tp + 2) = 0;
*(tp + 3) = digit;
(void) adder128(ap,tp,ap128,0);
/* printf("%d %04X:%04X:%04X:%04X\n",digit,*((u_int32_t *)ap),*((u_int32_t *)ap +1),*((u_int32_t *)ap +2),*((u_int32_t *)ap +3)); */
}
char
_simple_pack(void * str,int len, BCD * n)
{
int i = len -1, j=19, lo=1;
register unsigned char c, * bcdn = (unsigned char *)(n->bcd), * sp = (unsigned char *) str;
if (len > 40)
return '*'; /* error, input string too long */
memset (bcdn, 0, 20);
do {
c = *(sp + i) & 0x7f;
if (c < zero || c > (zero + 9))
return c; /* error, out of range */
if (lo) { /* lo byte ? */
*(bcdn + j) = c & 0xF;
lo = 0;
}
else {
c <<= 4;
*(bcdn + j) |= c;
lo = 1; /* lo byte next */
j--;
}
} while (i-- > 0);
return 0;
}
/* convert a packed bcd string to 128 bit binary string
*/
void
_bcdn2bin(void * bp, n128 * ap128, n128 * cp128, int len)
{
int i = 0, hasdigits = 0, lo;
register unsigned char c, * cp = (unsigned char *)bp;
memset(ap128->c, 0, 16);
memset(cp128->c, 0, 16);
while (i < len ) {
c = *cp++;
for (lo=0;lo<2;lo+=1) {
if (lo) {
if (hasdigits) /* suppress leading zero multiplications */
_128x10plusbcd(ap128, cp128, c & 0xF);
else {
if (c & 0xF) {
hasdigits = 1;
ap128->u[3] = c & 0xF;
}
}
}
else {
if (hasdigits) /* suppress leading zero multiplications */
_128x10plusbcd(ap128, cp128, c >> 4);
else {
if (c & 0XF0) {
hasdigits = 1;
ap128->u[3] = c >> 4;
}
}
}
i++;
if (i >= len)
break;
}
}
}
/* convert a 128 bit number string to a bcd number string
returns the length of the bcd string === 20
*/
int
_bin2bcd (unsigned char * binary, BCD * n)
{
register u_int32_t tmp, add3, msk8, bcd8, carry = 0;
u_int32_t word;
unsigned char binmsk = 0;
int c = 0,i, j, p;
memset (n->bcd, 0, 20);
for (p=0;p<128;p++) { /* bit pointer */
if (! binmsk) {
word = *((unsigned char *)binary + c);
binmsk = 0x80;
c++;
}
carry = word & binmsk; /* bit to convert */
binmsk >>= 1;
for (i=4;i>=0;i--) {
bcd8 = n->bcd[i];
if (carry | bcd8) { /* if something to do */
add3 = 3;
msk8 = 8;
for (j=0;j<8;j++) { /* prep bcd digits for X2 */
tmp = bcd8 + add3;
if (tmp & msk8)
bcd8 = tmp;
add3 <<= 4;
msk8 <<= 4;
}
tmp = bcd8 & 0x80000000; /* propagated carry */
bcd8 <<= 1; /* x 2 */
if (carry)
bcd8 += 1;
n->bcd[i] = bcd8;
carry = tmp;
}
}
}
netswap(n->bcd,5);
return 20;
}
/* convert a bcd number string to a bcd text string
returns the number of digits
*/
int
_bcd2txt(unsigned char * bcd2p, BCD * n)
{
register unsigned char bcd, dchar;
int i, j = 0;
for (i=0;i<20;i++) {
dchar = *(bcd2p + i);
bcd = dchar >> 4;
if (j || bcd) {
n->txt[j] = bcd + zero;
j++;
}
bcd = dchar & 0xF;
if (j || bcd || i == 19) { /* must be at least one digit */
n->txt[j] = bcd + zero;
j++;
}
}
n->txt[j] = 0; /* string terminator */
return j;
}
/* INCLUDE: xs_include/miniSocket.inc removed 10-12-11 */
#line 486 "Util.c"
#ifndef PERL_UNUSED_VAR
# define PERL_UNUSED_VAR(var) if (0) var = var
#endif
#ifndef dVAR
# define dVAR dNOOP
#endif
/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
# define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
# define PERL_DECIMAL_VERSION \
PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
# define PERL_VERSION_GE(r,v,s) \
(PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
# define PERL_VERSION_LE(r,v,s) \
(PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif
/* XS_INTERNAL is the explicit static-linkage variant of the default
* XS macro.
*
* XS_EXTERNAL is the same as XS_INTERNAL except it does not include
* "STATIC", ie. it exports XSUB symbols. You probably don't want that
* for anything but the BOOT XSUB.
*
* See XSUB.h in core!
*/
/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
# undef XS_EXTERNAL
# undef XS_INTERNAL
# if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
# define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
# define XS_INTERNAL(name) STATIC XSPROTO(name)
# endif
# if defined(__SYMBIAN32__)
# define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
# define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
# endif
# ifndef XS_EXTERNAL
# if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
# define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
# define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
# else
# ifdef __cplusplus
# define XS_EXTERNAL(name) extern "C" XSPROTO(name)
# define XS_INTERNAL(name) static XSPROTO(name)
# else
# define XS_EXTERNAL(name) XSPROTO(name)
# define XS_INTERNAL(name) STATIC XSPROTO(name)
# endif
# endif
# endif
#endif
/* perl >= 5.10.0 && perl <= 5.15.1 */
/* The XS_EXTERNAL macro is used for functions that must not be static
* like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
* macro defined, the best we can do is assume XS is the same.
* Dito for XS_INTERNAL.
*/
#ifndef XS_EXTERNAL
# define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
# define XS_INTERNAL(name) XS(name)
#endif
/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
* internal macro that we're free to redefine for varying linkage due
* to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
* XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
*/
#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
# define XS_EUPXS(name) XS_EXTERNAL(name)
#else
/* default to internal */
# define XS_EUPXS(name) XS_INTERNAL(name)
#endif
#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)
/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
const GV *const gv = CvGV(cv);
PERL_ARGS_ASSERT_CROAK_XS_USAGE;
if (gv) {
const char *const gvname = GvNAME(gv);
const HV *const stash = GvSTASH(gv);
const char *const hvname = stash ? HvNAME(stash) : NULL;
if (hvname)
Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
else
Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
} else {
/* Pants. I don't think that it should be possible to get here. */
Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
}
}
#undef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define croak_xs_usage S_croak_xs_usage
#endif
/* NOTE: the prototype of newXSproto() is different in versions of perls,
* so we define a portable version of newXSproto()
*/
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */
#if PERL_VERSION_LE(5, 21, 5)
# define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
# define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif
#line 630 "Util.c"
XS_EUPXS(XS_NetAddr__IP__Util_comp128); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_comp128)
{
dVAR; dXSARGS;
dXSI32;
if (items < 1)
croak_xs_usage(cv, "s, ...");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
#line 487 "Util.xs"
unsigned char * ap;
char * subname;
u_int32_t wa[4];
STRLEN len;
int i;
#line 650 "Util.c"
#line 493 "Util.xs"
ap = (unsigned char *) SvPV(s,len);
if (len != 16) {
if (ix == 2)
subname = is_ipv6to4;
else if (ix == 1)
subname = is_shiftleft;
else
subname = is_comp128;
croak("Bad arg length for %s%s, length is %d, should be %d",
"NetAddr::IP::Util::",subname,len *8,128);
}
if (ix == 2) {
XPUSHs(sv_2mortal(newSVpvn((char *)(ap +12),4)));
XSRETURN(1);
}
else if (ix == 1) {
if (items < 2) {
memcpy(wa,ap,16);
}
else if ((i = SvIV(ST(1))) == 0) {
memcpy(wa,ap,16);
}
else if (i < 0 || i > 128) {
croak("Bad arg value for %s, is %d, should be 0 thru 128",
"NetAddr::IP::Util::shiftleft",i);
}
else {
netswap_copy(wa,ap,4);
do {
_128x2(wa);
i--;
} while (i > 0);
netswap(wa,4);
}
}
else {
memcpy(wa,ap,16);
fastcomp128(wa);
}
XPUSHs(sv_2mortal(newSVpvn((char *)wa,16)));
XSRETURN(1);
#line 693 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_add128); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_add128)
{
dVAR; dXSARGS;
dXSI32;
if (items != 2)
croak_xs_usage(cv, "as, bs");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * as = ST(0)
;
SV * bs = ST(1)
;
#line 542 "Util.xs"
unsigned char * ap, *bp;
char * subname;
u_int32_t wa[4], wb[4];
n128 a128;
STRLEN len;
#line 720 "Util.c"
#line 548 "Util.xs"
ap = (unsigned char *) SvPV(as,len);
if (len != 16) {
Bail:
if (ix == 1)
subname = is_sub128;
else
subname = is_add128;
croak("Bad arg length for %s%s, length is %d, should be %d",
"NetAddr::IP::Util::",subname,len *8,128);
}
bp = (unsigned char *) SvPV(bs,len);
if (len != 16) {
goto Bail;
}
netswap_copy(wa,ap,4);
netswap_copy(wb,bp,4);
if (ix == 1) {
fastcomp128(wb);
XPUSHs(sv_2mortal(newSViv((I32)adder128(wa,wb,&a128,1))));
}
else {
XPUSHs(sv_2mortal(newSViv((I32)adder128(wa,wb,&a128,0))));
}
if (GIMME_V == G_ARRAY) {
netswap(a128.u,4);
XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
XSRETURN(2);
}
XSRETURN(1);
#line 752 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_addconst); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_addconst)
{
dVAR; dXSARGS;
if (items != 2)
croak_xs_usage(cv, "s, cnst");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
I32 cnst = (I32)SvIV(ST(1))
;
#line 584 "Util.xs"
n128 a128;
unsigned char * ap;
u_int32_t wa[4], wb[4];
STRLEN len;
#line 777 "Util.c"
#line 589 "Util.xs"
ap = (unsigned char *) SvPV(s,len);
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::addconst",len *8,128);
}
netswap_copy(wa,ap,4);
XPUSHs(sv_2mortal(newSViv((I32)addercon(wa,wb,&a128,cnst))));
if (GIMME_V == G_ARRAY) {
netswap(a128.u,4);
XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
XSRETURN(2);
}
XSRETURN(1);
#line 792 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_hasbits); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_hasbits)
{
dVAR; dXSARGS;
if (items != 1)
croak_xs_usage(cv, "s");
{
SV * s = ST(0)
;
#line 608 "Util.xs"
unsigned char * bp;
char * subname;
STRLEN len;
#line 812 "Util.c"
int RETVAL;
dXSTARG;
#line 612 "Util.xs"
bp = (unsigned char *) SvPV(s,len);
if (len != 16) {
subname = is_hasbits;
croak("Bad arg length for %s%s, length is %d, should be %d",
"NetAddr::IP::Util::",subname,len *8,128);
}
RETVAL = have128(bp);
#line 823 "Util.c"
XSprePUSH; PUSHi((IV)RETVAL);
}
XSRETURN(1);
}
XS_EUPXS(XS_NetAddr__IP__Util_bin2bcd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_bin2bcd)
{
dVAR; dXSARGS;
dXSI32;
if (items != 1)
croak_xs_usage(cv, "s");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
#line 629 "Util.xs"
BCD n;
unsigned char * cp;
STRLEN len;
#line 846 "Util.c"
#line 633 "Util.xs"
cp = (unsigned char *) SvPV(s,len);
if (ix == 0) {
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::bin2bcd",len *8,128);
}
(void) _bin2bcd(cp,&n);
XPUSHs(sv_2mortal(newSVpvn((char *)n.txt,_bcd2txt((unsigned char *)n.bcd,&n))));
}
else if (ix == 1) {
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::bin2bcdn",len *8,128);
}
XPUSHs(sv_2mortal(newSVpvn((char *)n.bcd,_bin2bcd(cp,&n))));
}
else {
if (len > 20) {
croak("Bad arg length for %s, length is %d, should %d digits or less",
"NetAddr::IP::Util::bcdn2txt",len *2,40);
}
XPUSHs(sv_2mortal(newSVpvn((char *)n.txt,_bcd2txt(cp,&n))));
}
XSRETURN(1);
#line 872 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_bcd2bin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_bcd2bin)
{
dVAR; dXSARGS;
dXSI32;
if (items < 1)
croak_xs_usage(cv, "s, ...");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
#line 671 "Util.xs"
BCD n;
n128 c128, a128;
unsigned char * cp, badc;
char * subname;
STRLEN len;
#line 897 "Util.c"
#line 677 "Util.xs"
cp = (unsigned char *) SvPV(s,len);
if (len > 40) {
if (ix == 0)
subname = is_bcd2bin;
else if (ix ==1)
subname = is_simple_pack;
Badigits:
croak("Bad arg length for %s%s, length is %d, should be %d digits or less",
"NetAddr::IP::Util::",subname,len,40);
}
if (ix == 2) {
if (len > 20) {
len <<= 1; /* times 2 */
subname = is_bcdn2bin;
goto Badigits;
}
if (items < 2) {
croak("Bad usage, should have %s('packedbcd,length)",
"NetAddr::IP::Util::bcdn2bin");
}
len = SvIV(ST(1));
_bcdn2bin(cp,&a128,&c128,(int)len);
netswap(a128.u,4);
XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
XSRETURN(1);
}
badc = _simple_pack(cp,(int)len, &n);
if (badc) {
if (ix == 1)
subname = is_simple_pack;
else
subname = is_bcd2bin;
croak("Bad char in string for %s%s, character is '%c', allowed are 0-9",
"NetAddr::IP::Util::",subname,badc);
}
if (ix == 0) {
_bcdn2bin((void *)n.bcd,&a128,&c128,40);
netswap(a128.u,4);
XPUSHs(sv_2mortal(newSVpvn((char *)a128.c,16)));
}
else { /* ix == 1 */
XPUSHs(sv_2mortal(newSVpvn((char *)n.bcd,20)));
}
XSRETURN(1);
#line 943 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_notcontiguous); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_notcontiguous)
{
dVAR; dXSARGS;
if (items != 1)
croak_xs_usage(cv, "s");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
#line 726 "Util.xs"
unsigned char * ap, count;
u_int32_t wa[4];
STRLEN len;
#line 965 "Util.c"
#line 730 "Util.xs"
ap = (unsigned char *) SvPV(s,len);
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::countbits",len *8,128);
}
netswap_copy(wa,ap,4);
count = _countbits(wa);
XPUSHs(sv_2mortal(newSViv((I32)have128(wa))));
if (GIMME_V == G_ARRAY) {
XPUSHs(sv_2mortal(newSViv((I32)count)));
XSRETURN(2);
}
XSRETURN(1);
#line 980 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_ipv4to6); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_ipv4to6)
{
dVAR; dXSARGS;
dXSI32;
if (items != 1)
croak_xs_usage(cv, "s");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
#line 750 "Util.xs"
unsigned char * ip;
char * subname;
u_int32_t wa[4];
STRLEN len;
#line 1004 "Util.c"
#line 755 "Util.xs"
ip = (unsigned char *) SvPV(s,len);
if (len != 4) {
if (ix == 1)
subname = is_mask4to6;
else
subname = is_ipv4to6;
croak("Bad arg length for %s%s, length is %d, should be 32",
"NetAddr::IP::Util::",subname,len *8);
}
if (ix == 0)
extendipv4(ip, wa);
else
extendmask4(ip, wa);
XPUSHs(sv_2mortal(newSVpvn((char *)wa,16)));
XSRETURN(1);
#line 1021 "Util.c"
PUTBACK;
return;
}
}
XS_EUPXS(XS_NetAddr__IP__Util_ipanyto6); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_NetAddr__IP__Util_ipanyto6)
{
dVAR; dXSARGS;
dXSI32;
if (items != 1)
croak_xs_usage(cv, "s");
PERL_UNUSED_VAR(ax); /* -Wall */
SP -= items;
{
SV * s = ST(0)
;
#line 777 "Util.xs"
unsigned char * ip;
char * subname;
u_int32_t wa[4];
STRLEN len;
#line 1045 "Util.c"
#line 782 "Util.xs"
ip = (unsigned char *) SvPV(s,len);
if (len == 16) /* if already 128 bits, return input */
XPUSHs(sv_2mortal(newSVpvn((char *)ip,16)));
else if (len == 4) {
if (ix == 0)
extendipv4(ip, wa);
else
extendmask4(ip, wa);
XPUSHs(sv_2mortal(newSVpvn((char *)wa,16)));
}
else {
if (ix == 1)
subname = is_maskanyto6;
else
subname = is_ipanyto6;
croak("Bad arg length for %s%s, length is %d, should be 32 or 128",
"NetAddr::IP::Util::",subname,len *8);
}
XSRETURN(1);
#line 1066 "Util.c"
PUTBACK;
return;
}
}
#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_NetAddr__IP__Util); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_NetAddr__IP__Util)
{
#if PERL_VERSION_LE(5, 21, 5)
dVAR; dXSARGS;
#else
dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
char* file = __FILE__;
#else
const char* file = __FILE__;
#endif
PERL_UNUSED_VAR(file);
PERL_UNUSED_VAR(cv); /* -W */
PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
XS_VERSION_BOOTCHECK;
# ifdef XS_APIVERSION_BOOTCHECK
XS_APIVERSION_BOOTCHECK;
# endif
#endif
{
CV * cv;
cv = newXSproto_portable("NetAddr::IP::Util::comp128", XS_NetAddr__IP__Util_comp128, file, "$;@");
XSANY.any_i32 = 0;
cv = newXSproto_portable("NetAddr::IP::Util::ipv6to4", XS_NetAddr__IP__Util_comp128, file, "$;@");
XSANY.any_i32 = 2;
cv = newXSproto_portable("NetAddr::IP::Util::shiftleft", XS_NetAddr__IP__Util_comp128, file, "$;@");
XSANY.any_i32 = 1;
cv = newXSproto_portable("NetAddr::IP::Util::add128", XS_NetAddr__IP__Util_add128, file, "$$");
XSANY.any_i32 = 0;
cv = newXSproto_portable("NetAddr::IP::Util::sub128", XS_NetAddr__IP__Util_add128, file, "$$");
XSANY.any_i32 = 1;
(void)newXSproto_portable("NetAddr::IP::Util::addconst", XS_NetAddr__IP__Util_addconst, file, "$$");
(void)newXSproto_portable("NetAddr::IP::Util::hasbits", XS_NetAddr__IP__Util_hasbits, file, "$");
cv = newXSproto_portable("NetAddr::IP::Util::bcdn2txt", XS_NetAddr__IP__Util_bin2bcd, file, "$");
XSANY.any_i32 = 2;
cv = newXSproto_portable("NetAddr::IP::Util::bin2bcd", XS_NetAddr__IP__Util_bin2bcd, file, "$");
XSANY.any_i32 = 0;
cv = newXSproto_portable("NetAddr::IP::Util::bin2bcdn", XS_NetAddr__IP__Util_bin2bcd, file, "$");
XSANY.any_i32 = 1;
cv = newXSproto_portable("NetAddr::IP::Util::bcd2bin", XS_NetAddr__IP__Util_bcd2bin, file, "$;@");
XSANY.any_i32 = 0;
cv = newXSproto_portable("NetAddr::IP::Util::bcdn2bin", XS_NetAddr__IP__Util_bcd2bin, file, "$;@");
XSANY.any_i32 = 2;
cv = newXSproto_portable("NetAddr::IP::Util::simple_pack", XS_NetAddr__IP__Util_bcd2bin, file, "$;@");
XSANY.any_i32 = 1;
(void)newXSproto_portable("NetAddr::IP::Util::notcontiguous", XS_NetAddr__IP__Util_notcontiguous, file, "$");
cv = newXSproto_portable("NetAddr::IP::Util::ipv4to6", XS_NetAddr__IP__Util_ipv4to6, file, "$");
XSANY.any_i32 = 0;
cv = newXSproto_portable("NetAddr::IP::Util::mask4to6", XS_NetAddr__IP__Util_ipv4to6, file, "$");
XSANY.any_i32 = 1;
cv = newXSproto_portable("NetAddr::IP::Util::ipanyto6", XS_NetAddr__IP__Util_ipanyto6, file, "$");
XSANY.any_i32 = 0;
cv = newXSproto_portable("NetAddr::IP::Util::maskanyto6", XS_NetAddr__IP__Util_ipanyto6, file, "$");
XSANY.any_i32 = 1;
}
#if PERL_VERSION_LE(5, 21, 5)
# if PERL_VERSION_GE(5, 9, 0)
if (PL_unitcheckav)
call_list(PL_scopestack_ix, PL_unitcheckav);
# endif
XSRETURN_YES;
#else
Perl_xs_boot_epilog(aTHX_ ax);
#endif
}