Net-Silk
view release on metacpan or search on metacpan
PREINIT:
int rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skStringParseIP(&RETVAL, spec);
if (rv != SKUTILS_OK)
croak("invalid ip (error %d parsing string: %s",
rv, skStringParseStrerror(rv));
OUTPUT:
RETVAL
Net::Silk::IPv4Addr
_as_ipv4(THIS)
Net::Silk::IPAddr THIS
CODE:
RETVAL = THIS;
OUTPUT:
RETVAL
Net::Silk::IPv6Addr
_as_ipv6(THIS)
Net::Silk::IPAddr THIS
CODE:
#if SK_ENABLE_IPV6
skipaddrCopy(&RETVAL, &THIS);
if (!skipaddrIsV6(&RETVAL)) {
skipaddrV4toV6(&RETVAL, &RETVAL);
}
#else
croak("SiLK was not built with IPv6 support.");
#endif
OUTPUT:
RETVAL
char *
str(THIS, ...)
Net::Silk::IPAddr THIS
PREINIT:
// the ... is necessary to throw off signature of CORE::str
char buf[SK_NUM2DOT_STRLEN];
CODE:
skipaddrString(buf, &THIS, SKIPADDR_CANONICAL);
RETVAL = buf;
OUTPUT:
RETVAL
char *
padded(THIS)
Net::Silk::IPAddr THIS
PREINIT:
char buf[SK_NUM2DOT_STRLEN];
CODE:
skipaddrString(buf, &THIS, SKIPADDR_ZEROPAD);
RETVAL = buf;
OUTPUT:
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)
+ (uint128_t)u8[1]) << 8)
+ (uint128_t)u8[2]) << 8)
+ (uint128_t)u8[3]) << 8)
+ (uint128_t)u8[4]) << 8)
+ (uint128_t)u8[5]) << 8)
+ (uint128_t)u8[6]) << 8)
+ (uint128_t)u8[7]) << 8)
+ (uint128_t)u8[8]) << 8)
+ (uint128_t)u8[9]) << 8)
+ (uint128_t)u8[10]) << 8)
+ (uint128_t)u8[11]) << 8)
+ (uint128_t)u8[12]) << 8)
+ (uint128_t)u8[13]) << 8)
+ (uint128_t)u8[14]) << 8)
+ (uint128_t)u8[15]));
} else
#endif
{
mXPUSHu(skipaddrGetV4(&THIS));
}
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);
for (i = 0; i < 16; i++) {
mPUSHu(v6[i]);
}
} else
#endif
{
uint32_t v4 = skipaddrGetV4(&THIS);
EXTEND(SP, 4);
mPUSHu(0);
mPUSHu(0);
mPUSHu(0);
mPUSHu(0);
sv_setuv(ST(3), v4 & 0xff);
v4 >>= 8;
sv_setuv(ST(2), v4 & 0xff);
v4 >>= 8;
sv_setuv(ST(1), v4 & 0xff);
v4 >>= 8;
sv_setuv(ST(0), v4 & 0xff);
}
bool
is_ipv6(THIS)
Net::Silk::IPAddr THIS
CODE:
RETVAL = skipaddrIsV6(&THIS);
OUTPUT:
RETVAL
void
country_code(THIS)
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)
skCountryCodeToName(code, name, sizeof(name));
mXPUSHs(newSVpvn(name, sizeof(name)));
MODULE = Net::Silk PACKAGE = Net::Silk::IPv4Addr PREFIX = sk
Net::Silk::IPv4Addr
new(CLASS, spec)
const char *CLASS
Net::Silk::IPv4Addr spec
PREINIT:
CODE:
PERL_UNUSED_VAR(CLASS);
RETVAL = spec;
#if SK_ENABLE_IPV6
if (skipaddrIsV6(&RETVAL)) {
int rv = skipaddrV6toV4(&RETVAL, &RETVAL);
if (rv < 0)
croak("invalid ipv6 address");
}
#endif
OUTPUT:
RETVAL
Net::Silk::IPv4Addr
from_str(CLASS, spec)
const char *CLASS
const char *spec
PREINIT:
int rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skStringParseIP(&RETVAL, spec);
if (rv != SKUTILS_OK)
croak("invalid ipv4 (error %d parsing string: %s)",
rv, skStringParseStrerror(rv));
#if SK_ENABLE_IPV6
if (skipaddrIsV6(&RETVAL)) {
int rv = skipaddrV6toV4(&RETVAL, &RETVAL);
if (rv < 0)
croak("invalid ipv4 address");
}
#endif
OUTPUT:
RETVAL
Net::Silk::IPv4Addr
from_int(CLASS, val)
const char *CLASS
SV *val
CODE:
PERL_UNUSED_VAR(CLASS);
RETVAL = SvNumIPV4ADDR(aTHX_ val);
#if SK_ENABLE_IPV6
if (skipaddrIsV6(&RETVAL)) {
total <<= 16;
total += THIS.port;
total -= num;
if (total & 0xfff00000)
croak("error: proto/port underflow");
RETVAL.proto = (total & 0xff0000) >> 16;
RETVAL.port = total & 0x0ffff;
OUTPUT:
RETVAL
uint32_t
num(THIS)
Net::Silk::ProtoPort THIS
CODE:
RETVAL = THIS.proto;
RETVAL <<= 16;
RETVAL += THIS.port;
OUTPUT:
RETVAL
MODULE = Net::Silk PACKAGE = Net::Silk::IPWildcard::iter_xs PREFIX = sk
PROTOTYPES: DISABLE
Net::Silk::IPWildcard::iter_xs
bind(CLASS, wc)
const char *CLASS
SV *wc
PREINIT:
STRLEN len;
char *s;
int rv;
skIPWildcardIterator_t iter;
CODE:
PERL_UNUSED_VAR(CLASS);
if (!SvOK(wc))
if (!SvOK(wc) && !SvROK(wc))
croak("invalid ip (expected a reference to %s)",
SILK_IPWILDCARD_CLASS);
if (! SvROK(wc) || ! sv_derived_from(wc, SILK_IPWILDCARD_CLASS))
croak("invalid ip (not a %s derived reference)",
SILK_IPWILDCARD_CLASS);
s = SvPV(SvRV(wc), len);
if (len != sizeof(skIPWildcard_t))
croak("invalid ip (size %lu of packed data != %lu of skIPWildcard_t)",
len, sizeof(skIPWildcard_t));
rv = skIPWildcardIteratorBind(&iter, (skIPWildcard_t *)s);
if (rv != 0)
croak("error %d binding wildcard iterator", rv);
RETVAL = &iter;
OUTPUT:
RETVAL
void
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
next_cidr(THIS)
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);
}
MODULE = Net::Silk PACKAGE = Net::Silk::IPWildcard PREFIX = sk
Net::Silk::IPWildcard
new(CLASS, spec)
const char *CLASS
Net::Silk::IPWildcard spec
CODE:
PERL_UNUSED_VAR(CLASS);
RETVAL = spec;
OUTPUT:
RETVAL
bool
contains(THIS, addr)
Net::Silk::IPWildcard THIS
Net::Silk::IPAddr addr
CODE:
RETVAL = skIPWildcardCheckIp(&THIS, &addr) ? 1 : 0;
OUTPUT:
RETVAL
bool
is_ipv6(THIS)
Net::Silk::IPWildcard THIS
CODE:
RETVAL = skIPWildcardIsV6(&THIS);
OUTPUT:
RETVAL
void
_cardinality(THIS)
Net::Silk::IPWildcard THIS
PREINIT:
int i, j;
uint8_t bitcount;
uint32_t bittotal;
bool gtzero = 0;
#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]);
bittotal += bitcount;
}
if (total == 0)
#if SK_ENABLE_IPV6
total = (uint128_t)bittotal;
#else
total = (uint64_t)bittotal;
#endif
else
total *= bittotal;
if (total > 1)
gtzero = 1;
}
if (total == 0 && gtzero)
croak("cardinality overflow");
#if SK_ENABLE_IPV6
mXPUSHs(newSVu128(total));
#else
mXPUSHs(newSVu64(total));
#endif
MODULE = Net::Silk PACKAGE = Net::Silk::IPSet::iter_xs PREFIX = sk
PROTOTYPES: DISABLE
Net::Silk::IPSet::iter_xs
bind(CLASS, ipset, cidr_blocks=0)
const char *CLASS
Net::Silk::IPSet ipset
unsigned cidr_blocks
PREINIT:
skipset_iterator_t iter;
int rv;
CODE:
PERL_UNUSED_VAR(CLASS);
RETVAL = &iter;
skIPSetClean(ipset);
if (cidr_blocks)
rv = skIPSetIteratorBind(RETVAL, ipset, 1, SK_IPV6POLICY_MIX);
else
rv = skIPSetIteratorBind(RETVAL, ipset, 0, SK_IPV6POLICY_MIX);
if (rv != SKIPSET_OK)
croak("error binding iterator %d: %s", rv, skIPSetStrerror(rv));
OUTPUT:
RETVAL
void
next(THIS)
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);
}
MODULE = Net::Silk PACKAGE = Net::Silk::IPSet PREFIX = sk
PROTOTYPES: DISABLE
Net::Silk::IPSet
_new(CLASS)
const char *CLASS
PREINIT:
skipset_t *ipset;
int rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skIPSetCreate(&ipset, 0);
if (rv != SKIPSET_OK)
croak("error creating ipset: %s", skIPSetStrerror(rv));
RETVAL = ipset;
OUTPUT:
RETVAL
Net::Silk::IPSet
load(CLASS, fname)
const char *CLASS
const char *fname
PREINIT:
int rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skIPSetLoad(&RETVAL, fname);
if (rv != SKIPSET_OK)
croak("error %d loading ipset from %s: %s",
rv, fname, skIPSetStrerror(rv));
OUTPUT:
RETVAL
bool
supports_ipv6(CLASS)
const char *CLASS
CODE:
PERL_UNUSED_VAR(CLASS);
#if SK_ENABLE_IPV6
RETVAL = 1;
#else
RETVAL = 0;
#endif
OUTPUT:
RETVAL
void
save(THIS, fname)
Net::Silk::IPSet THIS
const char *fname
PREINIT:
int rv;
CODE:
rv = skIPSetRemoveAddress(THIS, &addr,
skipaddrIsV6(&addr) ? 128 : 32);
if (rv != SKIPSET_OK)
croak("error %d removing ip: %s", rv, skIPSetStrerror(rv));
void
remove_wildcard(THIS, other)
Net::Silk::IPSet THIS
Net::Silk::IPWildcard other
PREINIT:
int rv;
CODE:
rv = skIPSetRemoveIPWildcard(THIS, &other);
if (rv != SKIPSET_OK)
croak("error %d removing wildcard: %s", rv, skIPSetStrerror(rv));
void
clear(THIS)
Net::Silk::IPSet THIS
CODE:
skIPSetRemoveAll(THIS);
MODULE = Net::Silk PACKAGE = Net::Silk::Bag::iter_xs PREFIX = sk
Net::Silk::Bag::iter_xs
bind(CLASS, bag, sorted=0)
const char *CLASS
Net::Silk::Bag bag
bool sorted
PREINIT:
skBagErr_t rv;
CODE:
PERL_UNUSED_VAR(CLASS);
if (sorted)
rv = skBagIteratorCreate(bag, &RETVAL);
else
rv = skBagIteratorCreateUnsorted(bag, &RETVAL);
if (rv != SKBAG_OK)
croak("error %d binding bag: %s", rv, skBagStrerror(rv));
OUTPUT:
RETVAL
void
DESTROY(THIS)
Net::Silk::Bag::iter_xs THIS
CODE:
skBagIteratorDestroy(THIS);
void
next(THIS, key_type, counter_type)
Net::Silk::Bag::iter_xs THIS
skBagKeyType_t key_type
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)
croak("error %d bag next: %s", rv, skBagStrerror(rv));
mXPUSHs(newSvBAGKEY(aTHX_ &key));
mXPUSHs(newSVu64(counter.val.u64));
}
MODULE = Net::Silk PACKAGE = Net::Silk::Bag PREFIX = sk
BOOT:
// BOOT ends after first blank line outside of a block
{
HV *stash;
stash = gv_stashpv("Net::Silk::Bag", TRUE);
MCE(SILK_BAG_KEY_ANY, SKBAG_KEY_ANY);
MCE(SILK_BAG_KEY_U8, SKBAG_KEY_U8);
MCE(SILK_BAG_KEY_U16, SKBAG_KEY_U16);
MCE(SILK_BAG_KEY_U32, SKBAG_KEY_U32);
MCE(SILK_BAG_KEY_IPADDR, SKBAG_KEY_IPADDR);
MCE(SILK_BAG_COUNTER_ANY, SKBAG_COUNTER_ANY);
MCE(SILK_BAG_COUNTER_U64, SKBAG_COUNTER_U64);
MCE(SILK_BAG_FIELD_SIPv4, SKBAG_FIELD_SIPv4);
MCE(SILK_BAG_FIELD_DIPv4, SKBAG_FIELD_DIPv4);
MCE(SILK_BAG_FIELD_SPORT, SKBAG_FIELD_SPORT);
MCE(SILK_BAG_FIELD_DPORT, SKBAG_FIELD_DPORT);
MCE(SILK_BAG_FIELD_PROTO, SKBAG_FIELD_PROTO);
MCE(SILK_BAG_FIELD_PACKETS, SKBAG_FIELD_PACKETS);
MCE(SILK_BAG_FIELD_BYTES, SKBAG_FIELD_BYTES);
MCE(SILK_BAG_FIELD_FLAGS, SKBAG_FIELD_FLAGS);
MCE(SILK_BAG_FIELD_STARTTIME, SKBAG_FIELD_STARTTIME);
MCE(SILK_BAG_FIELD_ELAPSED, SKBAG_FIELD_ELAPSED);
MCE(SILK_BAG_FIELD_ENDTIME, SKBAG_FIELD_ENDTIME);
MCE(SILK_BAG_FIELD_SID, SKBAG_FIELD_SID);
MCE(SILK_BAG_FIELD_INPUT, SKBAG_FIELD_INPUT);
MCE(SILK_BAG_FIELD_OUTPUT, SKBAG_FIELD_OUTPUT);
MCE(SILK_BAG_FIELD_NHIPv4, SKBAG_FIELD_NHIPv4);
MCE(SILK_BAG_FIELD_INIT_FLAGS, SKBAG_FIELD_INIT_FLAGS);
MCE(SILK_BAG_FIELD_REST_FLAGS, SKBAG_FIELD_REST_FLAGS);
MCE(SILK_BAG_FIELD_TCP_STATE, SKBAG_FIELD_TCP_STATE);
MCE(SILK_BAG_FIELD_APPLICATION, SKBAG_FIELD_APPLICATION);
MCE(SILK_BAG_FIELD_FTYPE_CLASS, SKBAG_FIELD_FTYPE_CLASS);
MCE(SILK_BAG_FIELD_FTYPE_TYPE, SKBAG_FIELD_FTYPE_TYPE);
MCE(SILK_BAG_FIELD_ICMP_TYPE_CODE, SKBAG_FIELD_ICMP_TYPE_CODE);
MCE(SILK_BAG_FIELD_SIPv6, SKBAG_FIELD_SIPv6);
MCE(SILK_BAG_FIELD_DIPv6, SKBAG_FIELD_DIPv6);
MCE(SILK_BAG_FIELD_NHIPv6, SKBAG_FIELD_NHIPv6);
MCE(SILK_BAG_FIELD_RECORDS, SKBAG_FIELD_RECORDS);
MCE(SILK_BAG_FIELD_SUM_PACKETS, SKBAG_FIELD_SUM_PACKETS);
MCE(SILK_BAG_FIELD_SUM_BYTES, SKBAG_FIELD_SUM_BYTES);
MCE(SILK_BAG_FIELD_SUM_ELAPSED, SKBAG_FIELD_SUM_ELAPSED);
MCE(SILK_BAG_FIELD_ANY_PORT, SKBAG_FIELD_ANY_PORT);
MCE(SILK_BAG_FIELD_ANY_SNMP, SKBAG_FIELD_ANY_SNMP);
// note: this triggers _destroy() for old SV
sv_setref_pv(THIS, SILK_BAG_CLASS, new);
void
clear(THIS)
SV *THIS
PREINIT:
skBagErr_t rv;
skBagFieldType_t key, value;
size_t keylen, valuelen;
skBag_t *bag;
CODE:
if (! SvROK(THIS) || ! sv_derived_from(THIS, SILK_BAG_CLASS))
croak("error bag clear (not a %s reference)", SILK_BAG_CLASS);
bag = INT2PTR(skBag_t*, SvIV(SvRV(THIS)));
key = skBagKeyFieldType(bag);
keylen = skBagKeyFieldLength(bag);
value = skBagCounterFieldType(bag);
valuelen = skBagCounterFieldLength(bag);
rv = skBagCreateTyped(&bag, key, value, keylen, valuelen);
if (rv != SKBAG_OK)
croak("error allocating bag");
// note: this triggers _destroy() for old SV
sv_setref_pv(THIS, SILK_BAG_CLASS, bag);
uint64_t
_cardinality(THIS)
Net::Silk::Bag THIS
CODE:
RETVAL = skBagCountKeys(THIS);
OUTPUT:
RETVAL
bool
_autoconvert_enabled(THIS)
Net::Silk::Bag THIS
CODE:
RETVAL = skBagAutoConvertIsEnabled(THIS);
OUTPUT:
RETVAL
void
_autoconvert_enable(THIS)
Net::Silk::Bag THIS
CODE:
skBagAutoConvertEnable(THIS);
void
_autoconvert_disable(THIS)
Net::Silk::Bag THIS
CODE:
skBagAutoConvertDisable(THIS);
void
_bag_info(THIS)
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)) {
mXPUSHu(SKBAG_KEY_IPADDR);
}
else {
switch(len) {
case 4:
mXPUSHu(SKBAG_KEY_U32);
break;
case 2:
mXPUSHu(SKBAG_KEY_U16);
break;
case 1:
mXPUSHu(SKBAG_KEY_U8);
break;
default:
mXPUSHu(SKBAG_KEY_U32);
}
}
mXPUSHs(newSVpv(buf, 0));
type = skBagCounterFieldName(THIS, buf, sizeof(buf));
len = skBagCounterFieldLength(THIS);
mXPUSHu(type);
mXPUSHu(len);
mXPUSHu(SKBAG_COUNTER_U64);
mXPUSHs(newSVpv(buf, 0));
void
_modify(THIS, ktype, ctype, klen, clen)
Net::Silk::Bag THIS
skBagFieldType_t ktype
skBagFieldType_t ctype
size_t klen
size_t clen
PREINIT:
skBagErr_t rv;
CODE:
rv = skBagModify(THIS, ktype, ctype, klen, clen);
if (rv != SKBAG_OK)
croak("error bag setting info: %d", rv);
bool
_is_ipaddr(THIS)
Net::Silk::Bag THIS
CODE:
RETVAL = IS_IP_KEY(skBagKeyFieldType(THIS)) || \
skBagCounterFieldLength(THIS) == 16;
OUTPUT:
RETVAL
skBagTypedCounter_t
_set_val(THIS, sv_key, val)
Net::Silk::Bag THIS
SV *sv_key
skBagTypedCounter_t val
PREINIT:
skBagTypedKey_t key;
skBagTypedCounter_t
_get_val(THIS, sv_key)
Net::Silk::Bag THIS
SV *sv_key
PREINIT:
skBagTypedKey_t key;
skBagTypedCounter_t val;
skBagErr_t rv;
CODE:
_sv_pack_bagkey(aTHX_ THIS, sv_key, &key);
rv = skBagCounterGet(THIS, &key, &val);
if (rv != SKBAG_OK)
croak("error bag %d: %s", rv, skBagStrerror(rv));
RETVAL = val;
OUTPUT:
RETVAL
void
_add_bag(THIS, other)
Net::Silk::Bag THIS
Net::Silk::Bag other
PREINIT:
skBagErr_t rv;
CODE:
rv = skBagAddBag(THIS, other, NULL, NULL);
if (rv != SKBAG_OK)
croak("error %d bag add bag: %s", rv, skBagStrerror(rv));
MODULE = Net::Silk PACKAGE = Net::Silk::Pmap::iter_xs PREFIX = sk
Net::Silk::Pmap::iter_xs
bind(CLASS, pmap)
const char *CLASS
Net::Silk::Pmap pmap
PREINIT:
int rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skPrefixMapIteratorCreate(&RETVAL, pmap);
if (rv != 0)
croak("error binding prefix map iterator %d", rv);
OUTPUT:
RETVAL
void
DESTROY(THIS)
Net::Silk::Pmap::iter_xs THIS
CODE:
skPrefixMapIteratorDestroy(&THIS);
void
next_ip(THIS)
Net::Silk::Pmap::iter_xs THIS
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));
mXPUSHs(newSvIPADDR(aTHX_ &hi));
mXPUSHu(val);
}
void
next_pp(THIS)
Net::Silk::Pmap::iter_xs THIS
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));
mXPUSHs(newSvPROTOPORT(aTHX_ hi));
mXPUSHu(val);
}
MODULE = Net::Silk PACKAGE = Net::Silk::Pmap PREFIX = sk
BOOT:
// BOOT ends after first blank line outside of a block
{
HV *stash;
stash = gv_stashpv("Net::Silk::Pmap", TRUE);
MCE(SILK_PMAP_TYPE_IPV4, SKPREFIXMAP_CONT_ADDR_V4);
MCE(SILK_PMAP_TYPE_IPV6, SKPREFIXMAP_CONT_ADDR_V6);
MCE(SILK_PMAP_TYPE_PROTO_PORT, SKPREFIXMAP_CONT_PROTO_PORT);
}
PROTOTYPES: DISABLE
Net::Silk::Pmap
_init(CLASS)
const char *CLASS
PREINIT:
skPrefixMapErr_t rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skPrefixMapCreate(&RETVAL);
if (rv != SKPREFIXMAP_OK)
croak("error %d creating pmap: %s", rv, skPrefixMapStrerror(rv));
OUTPUT:
RETVAL
Net::Silk::Pmap
_load(CLASS, fname)
const char *CLASS
const char *fname
PREINIT:
skPrefixMapErr_t rv;
CODE:
PERL_UNUSED_VAR(CLASS);
rv = skPrefixMapLoad(&RETVAL, fname);
if (rv != SKPREFIXMAP_OK)
croak("error %d reading prefix map from %s: %s",
rv, fname, skPrefixMapStrerror(rv));
OUTPUT:
RETVAL
void
_destroy(THIS)
Net::Silk::Pmap THIS
CODE:
skPrefixMapDelete(THIS);
void
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));
void
_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));
skPrefixMapContent_t
_get_content_type(THIS)
Net::Silk::Pmap THIS
CODE:
RETVAL = skPrefixMapGetContentType(THIS);
OUTPUT:
RETVAL
const char *
get_content_type(THIS)
Net::Silk::Pmap THIS
CODE:
RETVAL = skPrefixMapGetContentName(skPrefixMapGetContentType(THIS));
OUTPUT:
RETVAL
void
_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));
void
_insert_label(THIS, val, label)
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));
uint32_t
_get_or_insert_label(THIS, label)
Net::Silk::Pmap THIS
const char *label
PREINIT:
skPrefixMapErr_t rv;
CODE:
rv = skPrefixMapDictionarySearch(THIS, label, &RETVAL);
if (rv != SKPREFIXMAP_OK)
croak("error %d find/insert pmap label: %s",
rv, skPrefixMapStrerror(rv));
OUTPUT:
RETVAL
void
_set_name(THIS, name)
Net::Silk::Pmap THIS
const char *name
PREINIT:
skPrefixMapErr_t rv;
CODE:
rv = skPrefixMapSetMapName(THIS, name);
if (rv != SKPREFIXMAP_OK)
croak("error %d setting pmap name: %s", rv, skPrefixMapStrerror(rv));
const char *
get_name(THIS)
Net::Silk::Pmap THIS
CODE:
RETVAL = skPrefixMapGetMapName(THIS);
OUTPUT:
RETVAL
uint32_t
_get_max_label_size(THIS)
Net::Silk::Pmap THIS
CODE:
RETVAL = skPrefixMapDictionaryGetMaxWordSize(THIS);
OUTPUT:
RETVAL
void
_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
_val_to_label(THIS, val, max_size)
Net::Silk::Pmap THIS
uint32_t val
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;
len = max_size + 1;
buf = malloc(len);
if (buf == NULL)
croak("unable to allocate string (out of memory)");
rv = skPrefixMapDictionaryGetEntry(THIS, val, buf, len);
if (rv >= len)
croak("error pmap string allocation overflow");
mXPUSHs(newSVpvn(buf, rv));
Safefree(buf);
}
uint32_t
val_count(THIS)
Net::Silk::Pmap THIS
CODE:
RETVAL = skPrefixMapDictionaryGetWordCount(THIS);
OUTPUT:
RETVAL
void
_add_range(THIS, sv_lo, sv_hi, val)
Net::Silk::Pmap THIS
SV *sv_lo
SV *sv_hi
uint32_t val
PREINIT:
void *ptr_lo = NULL;
void *ptr_hi = NULL;
skipaddr_t addr_lo;
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);
ptr_lo = &addr_lo;
ptr_hi = &addr_hi;
break;
#if SK_ENABLE_IPV6
case SKPREFIXMAP_CONT_ADDR_V6:
addr_lo = SvIPV6ADDR(aTHX_ sv_lo);
addr_hi = SvIPV6ADDR(aTHX_ sv_hi);
ptr_lo = &addr_lo;
ptr_hi = &addr_hi;
break;
#endif
case SKPREFIXMAP_CONT_PROTO_PORT:
pp_lo = SvPROTOPORT(aTHX_ sv_lo);
pp_hi = SvPROTOPORT(aTHX_ sv_hi);
ptr_lo = &pp_lo;
ptr_hi = &pp_hi;
break;
default:
croak("unknown pmap key type");
}
rv = skPrefixMapAddRange(THIS, ptr_lo, ptr_hi, val);
if (rv != SKPREFIXMAP_OK)
croak("error %d adding pmap range: %s", rv, skPrefixMapStrerror(rv));
void
_get_range(THIS, sv_key)
Net::Silk::Pmap THIS
SV *sv_key
PREINIT:
SV *sv_lo;
SV *sv_hi;
skipaddr_t addr_key;
skipaddr_t addr_lo;
skipaddr_t addr_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);
sv_lo = newSvIPV4ADDR(aTHX_ &addr_lo);
sv_hi = newSvIPV4ADDR(aTHX_ &addr_hi);
break;
#if SK_ENABLE_IPV6
case SKPREFIXMAP_CONT_ADDR_V6:
addr_key = SvIPV6ADDR(aTHX_ sv_key);
rv = skPrefixMapFindRange(THIS, &addr_key, &addr_lo, &addr_hi);
sv_lo = newSvIPV4ADDR(aTHX_ &addr_lo);
sv_hi = newSvIPV4ADDR(aTHX_ &addr_hi);
break;
#endif
case SKPREFIXMAP_CONT_PROTO_PORT:
pp_key = SvPROTOPORT(aTHX_ sv_key);
rv = skPrefixMapFindRange(THIS, &pp_key, &pp_lo, &pp_hi);
sv_lo = newSvPROTOPORT(aTHX_ pp_lo);
sv_hi = newSvPROTOPORT(aTHX_ pp_hi);
break;
default:
croak("unknown pmap key type");
}
mXPUSHs(sv_lo);
mXPUSHs(sv_hi);
void
get_val(THIS, sv_key)
Net::Silk::Pmap THIS
SV *sv_key
PREINIT:
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;
break;
#if SK_ENABLE_IPV6
case SKPREFIXMAP_CONT_ADDR_V6:
addr = SvIPV6ADDR(aTHX_ sv_key);
key = &addr;
break;
#endif
case SKPREFIXMAP_CONT_PROTO_PORT:
if (! SvROK(sv_key))
croak("not a reference");
pp = SvPROTOPORT(aTHX_ sv_key);
key = &pp;
break;
default:
croak("unknown pmap key type");
}
// should be skPrefixMapFindValue in SiLK-3.8.0 and above
val = skPrefixMapGet(THIS, key);
if (val != SKPREFIXMAP_NOT_FOUND) {
mXPUSHu(val);
}
MODULE = Net::Silk PACKAGE = Net::Silk::TCPFlags PREFIX = sk
PROTOTYPES: DISABLE
uint8_t
parse_flags(repr)
const char *repr
CODE:
if (skStringParseTCPFlags(&RETVAL, repr)) {
croak("Illegal TCP flag value: %s", repr);
}
OUTPUT:
RETVAL
void
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);
}
mXPUSHu(high);
mXPUSHu(mask);
char *
str(THIS, ...)
Net::Silk::TCPFlags THIS;
PREINIT:
// the ... is necessary to throw off signature of CORE::str
char buf[SK_TCPFLAGS_STRLEN];
CODE:
skTCPFlagsString(THIS, buf, 0);
RETVAL = buf;
OUTPUT:
RETVAL
char *
padded(THIS)
Net::Silk::TCPFlags THIS;
PREINIT:
char buf[SK_TCPFLAGS_STRLEN];
CODE:
skTCPFlagsString(THIS, buf, SK_PADDED_FLAGS);
RETVAL = buf;
OUTPUT:
RETVAL
MODULE = Net::Silk PACKAGE = Net::Silk::Site::iter_xs
PROTOTYPES: DISABLE
void
DESTROY(THIS)
Net::Silk::Site::iter_xs THIS
CODE:
sksiteRepoIteratorDestroy(&THIS);
Net::Silk::Site::iter_xs
new(CLASS, flowtypes, sensors, start_time, end_time, missing)
char *CLASS
HV *flowtypes
AV *sensors
int64_t start_time
int64_t end_time
bool missing
PREINIT:
int max;
sk_vector_t *ft_vec = NULL;
sk_vector_t *sensor_vec = NULL;
sk_flowtype_id_t ft;
sk_sensor_id_t sensor;
uint32_t flags;
int rv;
CODE:
croak("error appending to flowtype vector");
}
} else {
SV *val;
I32 len;
char *class_name, *type_name;
while ((val = hv_iternextsv(flowtypes, &class_name, &len))) {
type_name = SvPV_nolen(val);
ft = sksiteFlowtypeLookupByClassType(class_name, type_name);
if (ft == SK_INVALID_FLOWTYPE)
croak("Invalid (class, type) pair ('%s', '%s')",
class_name, type_name);
rv = skVectorAppendValue(ft_vec, &ft);
if (rv != 0)
croak("error appending to flowtype vector");
}
}
// pull sensors
max = av_top_index(sensors);
if (max != -1) {
SV **avp;
sensor_vec = skVectorNew(sizeof(sk_sensor_id_t));
if (sensor_vec == NULL)
croak("error allocating sensor vector");
max = av_top_index(sensors);
int i;
for (i = 0; i <= max; i++) {
const char *sensor_name;
avp = av_fetch(sensors, i, 0);
sensor_name = SvPV_nolen(*avp);
sensor = sksiteSensorLookup(sensor_name);
if (sensor == SK_INVALID_SENSOR)
croak("Invalid sensor name '%s'", sensor_name);
rv = skVectorAppendValue(sensor_vec, &sensor);
if (rv != 0)
croak("error appending to sensor vector");
}
}
flags = missing ? RETURN_MISSING : 0;
rv = sksiteRepoIteratorCreate(&RETVAL, ft_vec, sensor_vec,
start_time, end_time, flags);
if (rv != 0)
croak("error allocating iterator");
if (ft_vec)
skVectorDestroy(ft_vec);
if (sensor_vec)
skVectorDestroy(sensor_vec);
OUTPUT:
RETVAL
char *
next(THIS)
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)));
}
MODULE = Net::Silk PACKAGE = Net::Silk::Site PREFIX = sk
BOOT:
// BOOT ends after first blank line outside of a block
{
HV *stash;
stash = gv_stashpv("Net::Silk::Site", TRUE);
MCPV(SILK_DATA_ROOTDIR_ENVAR);
MCPV(SILK_CONFIG_FILE_ENVAR);
}
PROTOTYPES: DISABLE
int
silk_init_set_envvar(val, envvar)
const char *val
const char *envvar
PREINIT:
static char env_buf[101 + PATH_MAX];
int rv;
CODE:
rv = snprintf(env_buf, sizeof(env_buf), "%s=%s", envvar, val);
if (rv >= (int)sizeof(env_buf) || putenv(env_buf) != 0) {
warn("Could not set %s", envvar);
RETVAL = -1;
} else {
RETVAL = 0;
}
OUTPUT:
RETVAL
bool
set_site_config(filename)
const char *filename
CODE:
RETVAL = sksiteSetConfigPath(filename) ? 0 : 1;
OUTPUT:
RETVAL
char *
get_site_config()
PREINIT:
char siteconf[PATH_MAX];
CODE:
sksiteGetConfigPath(siteconf, sizeof(siteconf));
RETVAL = siteconf;
OUTPUT:
RETVAL
bool
set_data_rootdir(rootdir)
const char *rootdir
CODE:
RETVAL = sksiteSetRootDir(rootdir) ? 0 : 1;
OUTPUT:
RETVAL
char *
get_data_rootdir()
PREINIT:
char rootdir[PATH_MAX];
CODE:
sksiteGetRootDir(rootdir, sizeof(rootdir));
RETVAL = rootdir;
OUTPUT:
RETVAL
int
_site_configure(verbose)
int verbose
CODE:
RETVAL = sksiteConfigure(verbose);
OUTPUT:
RETVAL
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);
}
void
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);
}
char *
sensor_name(id)
sk_sensor_id_t id
PREINIT:
char name[SK_MAX_STRLEN_SENSOR+1];
CODE:
sksiteSensorGetName(name, sizeof(name), id);
RETVAL = name;
OUTPUT:
RETVAL
const char *
sensor_description_by_id(id)
sk_sensor_id_t id
PREINIT:
char name[SK_MAX_STRLEN_SENSOR+1];
CODE:
RETVAL = sksiteSensorGetDescription(id);
OUTPUT:
RETVAL
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);
}
void
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);
}
void
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);
}
void
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);
}
sk_class_id_t
default_class_id(id)
CODE:
RETVAL = sksiteClassGetDefault();
OUTPUT:
RETVAL
char *
class_name(id)
sk_class_id_t id
PREINIT:
char name[SK_MAX_STRLEN_FLOWTYPE+1];
CODE:
sksiteClassGetName(name, sizeof(name), id);
RETVAL = name;
OUTPUT:
RETVAL
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);
}
char *
flowtype_name(id)
sk_flowtype_id_t id
PREINIT:
char name[SK_MAX_STRLEN_SENSOR+1];
CODE:
sksiteFlowtypeGetName(name, sizeof(name), id);
RETVAL = name;
OUTPUT:
RETVAL
char *
flowtype_type(id)
sk_flowtype_id_t id
PREINIT:
char name[SK_MAX_STRLEN_SENSOR+1];
CODE:
sksiteFlowtypeGetType(name, sizeof(name), id);
RETVAL = name;
OUTPUT:
RETVAL
sk_class_id_t
flowtype_class(id)
sk_flowtype_id_t id
CODE:
RETVAL = sksiteFlowtypeGetClassID(id);
OUTPUT:
RETVAL
MODULE = Net::Silk PACKAGE = Net::Silk::RWRec PREFIX = rwRec
PROTOTYPES: DISABLE
Net::Silk::RWRec
new_cleared(CLASS)
const char *CLASS
PREINIT:
rwRec rec;
CODE:
PERL_UNUSED_VAR(CLASS);
RWREC_CLEAR(&rec);
RETVAL = &rec;
OUTPUT:
RETVAL
Net::Silk::RWRec
to_ipv6(THIS)
Net::Silk::RWRec THIS
PREINIT:
rwRec copy;
CODE:
#if SK_ENABLE_IPV6
copy = *THIS;
rwRecConvertToIPv6(©);
RETVAL = ©
#else
croak("SiLK was not built with IPv6 support");
#endif
OUTPUT:
RETVAL
void
to_ipv4(THIS)
Net::Silk::RWRec THIS
PREINIT:
rwRec copy;
PPCODE:
copy = *THIS;
#if SK_ENABLE_IPV6
if (rwRecIsIPv6(©)) {
if (!rwRecConvertToIPv4(©))
goto proceed;
}
else
#endif
proceed:
{
mXPUSHs(sv_setref_pvn(newSV(0), SILK_RWREC_CLASS,
(char *)©, sizeof(copy)));
}
Net::Silk::RWRec
copy(THIS)
Net::Silk::RWRec THIS
PREINIT:
rwRec copy;
CODE:
copy = *THIS;
RETVAL = ©
OUTPUT:
RETVAL
uint16_t
get_application(THIS)
Net::Silk::RWRec THIS
CODE:
RETVAL = rwRecGetApplication(THIS);
OUTPUT:
RETVAL
void
set_application(THIS, val)
Net::Silk::RWRec THIS
int val
CODE:
if (val < 0 || val > UINT16_MAX)
croak("The application value must be a 16-bit integer");
rwRecSetApplication(THIS, val);
uint32_t
get_bytes(THIS)
Net::Silk::RWRec THIS
CODE:
RETVAL = rwRecGetBytes(THIS);
OUTPUT:
RETVAL
void
set_bytes(THIS, val)
Net::Silk::RWRec THIS
int val
CODE:
if (val < 0 || val > UINT32_MAX)
croak("The bytes value must be a 32-bit integer");
rwRecSetBytes(THIS, val);
uint8_t
Net::Silk::RWRec THIS
int val
CODE:
if (val < 0 || val > UINT16_MAX)
croak("The sensor id value must be a 16-bit integer");
rwRecSetSensor(THIS, (sk_sensor_id_t)val);
uint8_t
get_classtype_id(THIS)
Net::Silk::RWRec THIS
CODE:
RETVAL = rwRecGetFlowType(THIS);
OUTPUT:
RETVAL
void
set_classtype_id(THIS, val)
Net::Silk::RWRec THIS
int val
CODE:
if (val < 0 || val > UINT8_MAX)
croak("The classtype id value must be a 8-bit integer");
rwRecSetFlowType(THIS, (sk_flowtype_id_t)val);
char *
_classname(THIS)
Net::Silk::RWRec THIS
PREINIT:
char class_name[SK_MAX_STRLEN_FLOWTYPE+1];
sk_flowtype_id_t flowtype;
CODE:
flowtype = rwRecGetFlowType(THIS);
sksiteFlowtypeGetClass(class_name, sizeof(class_name), flowtype);
RETVAL = class_name;
OUTPUT:
RETVAL
Net::Silk::TCPFlags
get_tcpflags(THIS)
Net::Silk::RWRec THIS
CODE:
RETVAL = rwRecGetFlags(THIS);
OUTPUT:
RETVAL
void
set_tcpflags(THIS, flags)
Net::Silk::RWRec THIS
Net::Silk::TCPFlags flags
PREINIT:
uint8_t state;
CODE:
state = rwRecGetTcpState(THIS) & ~SK_TCPSTATE_EXPANDED;
rwRecSetFlags(THIS, flags);
rwRecSetInitFlags(THIS, 0);
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)
Net::Silk::RWRec THIS
Net::Silk::TCPFlags flags
PREINIT:
uint8_t state;
CODE:
if (rwRecGetProto(THIS) != IPPROTO_TCP)
croak("Cannot set initial_tcpflags when protocol is not TCP");
state = rwRecGetTcpState(THIS);
rwRecSetInitFlags(THIS, flags);
if (! (state & SK_TCPSTATE_EXPANDED)) {
rwRecSetTcpState(THIS, state | SK_TCPSTATE_EXPANDED);
rwRecSetRestFlags(THIS, 0);
}
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)
Net::Silk::RWRec THIS
Net::Silk::TCPFlags flags
PREINIT:
uint8_t state;
CODE:
if (rwRecGetProto(THIS) != IPPROTO_TCP)
croak("Cannot set session_tcpflags when protocol is not TCP");
state = rwRecGetTcpState(THIS);
rwRecSetRestFlags(THIS, flags);
if (! (state & SK_TCPSTATE_EXPANDED)) {
rwRecSetTcpState(THIS, state | SK_TCPSTATE_EXPANDED);
rwRecSetInitFlags(THIS, 0);
}
rwRecSetFlags(THIS, rwRecGetInitFlags(THIS) | flags);
Net::Silk::IPAddr
get_sip(THIS)
Net::Silk::RWRec THIS
CODE:
rwRecMemGetSIP(THIS, &RETVAL);
OUTPUT:
RETVAL
void
set_sip(THIS, addr)
Net::Silk::RWRec THIS
Net::Silk::IPAddr addr
CODE:
rwRecMemSetSIP(THIS, &addr);
Net::Silk::IPAddr
get_dip(THIS)
Net::Silk::RWRec THIS
CODE:
rwRecMemGetDIP(THIS, &RETVAL);
OUTPUT:
RETVAL
void
set_dip(THIS, addr)
Net::Silk::RWRec THIS
Net::Silk::IPAddr addr
CODE:
rwRecMemSetDIP(THIS, &addr);
Net::Silk::IPAddr
get_nhip(THIS)
Net::Silk::RWRec THIS
CODE:
rwRecMemGetNhIP(THIS, &RETVAL);
OUTPUT:
RETVAL
void
set_nhip(THIS, addr)
if (hdr != NULL) {
rv = skHeaderAddAnnotation(hdr, annotation);
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
}
void
init_add_invocation(THIS, invocation)
Net::Silk::File::io_xs THIS
char *invocation
PREINIT:
skstream_mode_t mode;
int rv;
sk_file_header_t *hdr;
CODE:
mode = skStreamGetMode(THIS);
if (mode != SK_IO_WRITE)
croak("Cannot set annotations unless in WRITE mode");
hdr = skStreamGetSilkHeader(THIS);
if (hdr != NULL) {
rv = skHeaderAddInvocation(hdr, 0, 1, &invocation);
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
}
void
init_finalize(THIS, ...)
Net::Silk::File::io_xs THIS
PREINIT:
int fd;
int rv;
skstream_mode_t mode;
CODE:
if (items > 1) {
fd = (int)SvUV(ST(1));
rv = skStreamFDOpen(THIS, fd);
} else {
rv = skStreamOpen(THIS);
}
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
mode = skStreamGetMode(THIS);
if (mode == SK_IO_WRITE) {
rv = skStreamWriteSilkHeader(THIS);
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
} else {
rv = skStreamReadSilkHeader(THIS, NULL);
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
}
void
invocations(THIS)
Net::Silk::File::io_xs THIS
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;
invoc = skHentryInvocationGetInvocation(entry);
mXPUSHs(newSVpvn(invoc, strlen(invoc)));
}
}
void
notes(THIS)
Net::Silk::File::io_xs THIS
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;
annot = skHentryAnnotationGetNote(entry);
mXPUSHs(newSVpvn(annot, strlen(annot)));
}
}
const char *
name(THIS)
Net::Silk::File::io_xs THIS
CODE:
RETVAL = skStreamGetPathname(THIS);
OUTPUT:
RETVAL
int
mode(THIS)
Net::Silk::File::io_xs THIS
CODE:
RETVAL = (int)skStreamGetMode(THIS);
OUTPUT:
RETVAL
int
fileno(THIS)
Net::Silk::File::io_xs THIS
CODE:
RETVAL = skStreamGetDescriptor(THIS);
OUTPUT:
RETVAL
void
flush(THIS)
Net::Silk::File::io_xs THIS
PREINIT:
int rv;
CODE:
rv = skStreamFlush(THIS);
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
Net::Silk::RWRec
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);
}
void
write(THIS, rec)
Net::Silk::File::io_xs THIS
Net::Silk::RWRec rec
PREINIT:
int rv;
CODE:
rv = skStreamWriteRecord(THIS, rec);
if (rv != 0)
_stream_croak(aTHX_ THIS, rv);
( run in 1.080 second using v1.01-cache-2.11-cpan-5511b514fd6 )