Net-Silk

 view release on metacpan or  search on metacpan

Silk.xs  view on Meta::CPAN

    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)

Silk.xs  view on Meta::CPAN

#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

Silk.xs  view on Meta::CPAN

    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

Silk.xs  view on Meta::CPAN

    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

Silk.xs  view on Meta::CPAN

    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;

Silk.xs  view on Meta::CPAN

    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

Silk.xs  view on Meta::CPAN

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

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

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

Silk.xs  view on Meta::CPAN

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

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

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

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

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;

Silk.xs  view on Meta::CPAN

    }
    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 *

Silk.xs  view on Meta::CPAN

    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

Silk.xs  view on Meta::CPAN

    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];

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

    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];

Silk.xs  view on Meta::CPAN

    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(&copy)) {
        if (!rwRecConvertToIPv4(&copy))
            goto proceed;
    }
    else
#endif
  proceed:
    {

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

    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:

Silk.xs  view on Meta::CPAN

        }

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

Silk.xs  view on Meta::CPAN

    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