void Context::bindSampler(GLuint textureUnit, GLuint sampler) { ASSERT(textureUnit < mCaps.maxCombinedTextureImageUnits); mResourceManager->checkSamplerAllocation(sampler); mState.setSamplerBinding(textureUnit, getSampler(sampler)); }
void ResourceManager::checkSamplerAllocation(GLuint sampler) { if (sampler != 0 && !getSampler(sampler)) { Sampler *samplerObject = new Sampler(sampler); mSamplerMap[sampler] = samplerObject; samplerObject->addRef(); } }
void ResourceManager::checkSamplerAllocation(GLuint sampler) { if (sampler != 0 && !getSampler(sampler)) { Sampler *samplerObject = new Sampler(sampler); mSamplerMap[sampler] = samplerObject; samplerObject->addRef(); // Samplers cannot be created via Bind } }
inline void doUnbindPassOpacityMap( PassRenderNode & node , Pass & pass ) { auto unit = pass.getTextureUnit( TextureChannel::eOpacity ); if ( unit ) { unit->getSampler()->unbind( 0u ); unit->getTexture()->unbind( 0u ); } }
inline void doBindPassOpacityMap( PassRenderNode & node , Pass & pass ) { auto unit = pass.getTextureUnit( TextureChannel::eOpacity ); if ( unit ) { node.m_textures.find( unit->getIndex() )->second.get().setValue( 0 ); unit->getTexture()->bind( 0u ); unit->getSampler()->bind( 0u ); } }
void wxraytracerFrame::OnRenderStart( wxCommandEvent& event ) { switch(canvas->getState()){ case RenderCanvas::RENDERING: canvas->renderPause(); return; case RenderCanvas::PAUSED: canvas->renderResume(); return; case RenderCanvas::STOPPED: case RenderCanvas::WAITING: default: break; } wxMenu* menuFile = GetMenuBar()->GetMenu(0); menuFile->Enable(menuFile->FindItem(wxT( "&Open..." )), FALSE); menuFile->Enable(menuFile->FindItem(wxT( "&Save As...")), TRUE ); RenderParams rp; int selection = samplerCombo_->GetSelection(); if (selection >= 0 ) { void* data = samplerCombo_->GetClientData(selection); assert(data); SamplerType sampleType = *reinterpret_cast<SamplerType*>(data); rp.sampler_ = getSampler(sampleType); } selection = builderCombo_->GetSelection(); if (selection >= 0 ) { void* data = builderCombo_->GetClientData(selection); assert(data); rp.builder_ = reinterpret_cast<builderFunc>(data); } wxString numSamples = sampleNumCombo_->GetValue(); long val = 1; numSamples.ToLong(&val, 10); rp.numSamples_ = val; rp.pixelSize_ = pixSizeSpin_->GetValue() / 100.0f; rp.transform_ = transformCheck_->IsChecked(); rp.debugFlags_ |= menuDebug_->IsChecked(Menu_Debug_Sampler) ? DEBUG_FLAG_SAMPLER : 0x0000; canvas->renderStart(rp); }
Sampler *ResourceManager::checkSamplerAllocation(rx::GLImplFactory *factory, GLuint samplerHandle) { // Samplers cannot be created via Bind if (samplerHandle == 0) { return nullptr; } Sampler *sampler = getSampler(samplerHandle); if (!sampler) { sampler = new Sampler(factory, samplerHandle); mSamplerMap[samplerHandle] = sampler; sampler->addRef(); } return sampler; }
GLfloat Context::getSamplerParameterf(GLuint sampler, GLenum pname) { mResourceManager->checkSamplerAllocation(sampler); Sampler *samplerObject = getSampler(sampler); ASSERT(samplerObject); switch (pname) { case GL_TEXTURE_MIN_FILTER: return static_cast<GLfloat>(samplerObject->getMinFilter()); case GL_TEXTURE_MAG_FILTER: return static_cast<GLfloat>(samplerObject->getMagFilter()); case GL_TEXTURE_WRAP_S: return static_cast<GLfloat>(samplerObject->getWrapS()); case GL_TEXTURE_WRAP_T: return static_cast<GLfloat>(samplerObject->getWrapT()); case GL_TEXTURE_WRAP_R: return static_cast<GLfloat>(samplerObject->getWrapR()); case GL_TEXTURE_MIN_LOD: return samplerObject->getMinLod(); case GL_TEXTURE_MAX_LOD: return samplerObject->getMaxLod(); case GL_TEXTURE_COMPARE_MODE: return static_cast<GLfloat>(samplerObject->getComparisonMode()); case GL_TEXTURE_COMPARE_FUNC: return static_cast<GLfloat>(samplerObject->getComparisonFunc()); default: UNREACHABLE(); return 0; } }
void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param) { mResourceManager->checkSamplerAllocation(sampler); Sampler *samplerObject = getSampler(sampler); ASSERT(samplerObject); switch (pname) { case GL_TEXTURE_MIN_FILTER: samplerObject->setMinFilter(uiround<GLenum>(param)); break; case GL_TEXTURE_MAG_FILTER: samplerObject->setMagFilter(uiround<GLenum>(param)); break; case GL_TEXTURE_WRAP_S: samplerObject->setWrapS(uiround<GLenum>(param)); break; case GL_TEXTURE_WRAP_T: samplerObject->setWrapT(uiround<GLenum>(param)); break; case GL_TEXTURE_WRAP_R: samplerObject->setWrapR(uiround<GLenum>(param)); break; case GL_TEXTURE_MIN_LOD: samplerObject->setMinLod(param); break; case GL_TEXTURE_MAX_LOD: samplerObject->setMaxLod(param); break; case GL_TEXTURE_COMPARE_MODE: samplerObject->setComparisonMode(uiround<GLenum>(param)); break; case GL_TEXTURE_COMPARE_FUNC: samplerObject->setComparisonFunc(uiround<GLenum>(param)); break; default: UNREACHABLE(); break; } }
int readPackets(HSP *sp) { int batch = 0; static uint32_t MySkipCount=1; if(sp->sFlow->sFlowSettings->ulogSubSamplingRate == 0) { // packet sampling was disabled by setting desired rate to 0 return 0; } if(sp->ulog_soc) { for( ; batch < HSP_READPACKET_BATCH; batch++) { char buf[HSP_MAX_MSG_BYTES]; socklen_t peerlen = sizeof(sp->ulog_peer); int len = recvfrom(sp->ulog_soc, buf, HSP_MAX_MSG_BYTES, 0, (struct sockaddr *)&sp->ulog_peer, &peerlen); if(len <= 0) break; if(debug > 1) myLog(LOG_INFO, "got ULOG msg: %u bytes", len); for(struct nlmsghdr *msg = (struct nlmsghdr *)buf; NLMSG_OK(msg, len); msg=NLMSG_NEXT(msg, len)) { if(debug > 1) { myLog(LOG_INFO, "netlink (%u bytes left) msg [len=%u type=%u flags=0x%x seq=%u pid=%u]", len, msg->nlmsg_len, msg->nlmsg_type, msg->nlmsg_flags, msg->nlmsg_seq, msg->nlmsg_pid); } switch(msg->nlmsg_type) { case NLMSG_NOOP: case NLMSG_ERROR: case NLMSG_OVERRUN: // ignore these break; case NLMSG_DONE: // last in multi-part default: { if(--MySkipCount == 0) { /* reached zero. Set the next skip */ MySkipCount = sfl_random((2 * sp->sFlow->sFlowSettings->ulogSubSamplingRate) - 1); /* and take a sample */ // we're seeing type==111 on Fedora14 //if(msg->nlmsg_flags & NLM_F_REQUEST) { } //if(msg->nlmsg_flags & NLM_F_MULTI) { } //if(msg->nlmsg_flags & NLM_F_ACK) { } //if(msg->nlmsg_flags & NLM_F_ECHO) { } ulog_packet_msg_t *pkt = NLMSG_DATA(msg); if(debug > 1) { myLog(LOG_INFO, "mark=%u ts=%s hook=%u in=%s out=%s len=%u prefix=%s maclen=%u\n", pkt->mark, ctime(&pkt->timestamp_sec), pkt->hook, pkt->indev_name, pkt->outdev_name, pkt->data_len, pkt->prefix, pkt->mac_len); if(pkt->mac_len == 14) { u_char macdst[12], macsrc[12]; printHex(pkt->mac+6,6,macsrc,12,NO); printHex(pkt->mac+0,6,macdst,12,NO); uint16_t ethtype = (pkt->mac[12] << 8) + pkt->mac[13]; myLog(LOG_INFO, "%s -> %s (ethertype=0x%04X)", macsrc, macdst, ethtype); } } SFL_FLOW_SAMPLE_TYPE fs = { 0 }; SFLSampler *sampler = NULL; // set the ingress and egress ifIndex numbers. // Can be "INTERNAL" (0x3FFFFFFF) or "UNKNOWN" (0). if(pkt->indev_name[0]) { SFLAdaptor *in = adaptorListGet(sp->adaptorList, pkt->indev_name); if(in && in->ifIndex) { fs.input = in->ifIndex; sampler = getSampler(sp, pkt->indev_name, in->ifIndex); } } else { fs.input = SFL_INTERNAL_INTERFACE; } if(pkt->outdev_name[0]) { SFLAdaptor *out = adaptorListGet(sp->adaptorList, pkt->outdev_name); if(out && out->ifIndex) { fs.output = out->ifIndex; sampler = getSampler(sp, pkt->outdev_name, out->ifIndex); } } else { fs.output = SFL_INTERNAL_INTERFACE; } if(sampler == NULL) { // maybe ULOG sent us a packet on device lo(?) if(debug > 1) myLog(LOG_INFO, "dropped sample with no ifIndex\n"); } else { SFLFlow_sample_element hdrElem = { 0 }; hdrElem.tag = SFLFLOW_HEADER; uint32_t FCS_bytes = 4; uint32_t maxHdrLen = sampler->sFlowFsMaximumHeaderSize; hdrElem.flowType.header.frame_length = pkt->data_len + FCS_bytes; hdrElem.flowType.header.stripped = FCS_bytes; u_char hdr[HSP_MAX_HEADER_BYTES]; if(pkt->mac_len == 14) { // set the header_protocol to ethernet and // reunite the mac header and payload in one buffer hdrElem.flowType.header.header_protocol = SFLHEADER_ETHERNET_ISO8023; memcpy(hdr, pkt->mac, 14); maxHdrLen -= 14; uint32_t payloadBytes = (pkt->data_len < maxHdrLen) ? pkt->data_len : maxHdrLen; memcpy(hdr+14, pkt->payload, payloadBytes); hdrElem.flowType.header.header_length = payloadBytes + 14; hdrElem.flowType.header.header_bytes = hdr; hdrElem.flowType.header.frame_length += 14; } else { // no need to copy - just point at the payload u_char ipversion = pkt->payload[0] >> 4; if(ipversion != 4 && ipversion != 6) { if(debug) myLog(LOG_ERR, "received non-IP packet. Encapsulation is unknown"); } else { hdrElem.flowType.header.header_protocol = (ipversion == 4) ? SFLHEADER_IPv4 : SFLHEADER_IPv6; hdrElem.flowType.header.stripped += 14; // assume ethernet was (or will be) the framing hdrElem.flowType.header.header_length = (pkt->data_len < maxHdrLen) ? pkt->data_len : maxHdrLen; hdrElem.flowType.header.header_bytes = pkt->payload; } } SFLADD_ELEMENT(&fs, &hdrElem); // submit the actual sampling rate so it goes out with the sFlow feed // otherwise the sampler object would fill in his own (sub-sampling) rate. uint32_t actualSamplingRate = sp->sFlow->sFlowSettings->ulogActualSamplingRate; fs.sampling_rate = actualSamplingRate; // estimate the sample pool from the samples. Could maybe do this // above with the (possibly more granular) ulogSamplingRate, but then // we would have to look up the sampler object every time, which // might be too expensive in the case where ulogSamplingRate==1. sampler->samplePool += actualSamplingRate; sfl_sampler_writeFlowSample(sampler, &fs); } } } } } } }
int readPackets(HSP *sp) { int batch = 0; static uint32_t MySkipCount=1; if(sp->sFlow->sFlowSettings == NULL) { // config was turned off return 0; } if(sp->sFlow->sFlowSettings->ulogSubSamplingRate == 0) { // packet sampling was disabled by setting desired rate to 0 return 0; } if(sp->ulog_soc) { for( ; batch < HSP_READPACKET_BATCH; batch++) { char buf[HSP_MAX_ULOG_MSG_BYTES]; socklen_t peerlen = sizeof(sp->ulog_peer); int len = recvfrom(sp->ulog_soc, buf, HSP_MAX_ULOG_MSG_BYTES, 0, (struct sockaddr *)&sp->ulog_peer, &peerlen); if(len <= 0) break; if(debug > 1) myLog(LOG_INFO, "got ULOG msg: %u bytes", len); for(struct nlmsghdr *msg = (struct nlmsghdr *)buf; NLMSG_OK(msg, len); msg=NLMSG_NEXT(msg, len)) { if(debug > 1) { myLog(LOG_INFO, "netlink (%u bytes left) msg [len=%u type=%u flags=0x%x seq=%u pid=%u]", len, msg->nlmsg_len, msg->nlmsg_type, msg->nlmsg_flags, msg->nlmsg_seq, msg->nlmsg_pid); } // check for drops indicated by sequence no uint32_t droppedSamples = 0; if(sp->ulog_seqno) { droppedSamples = msg->nlmsg_seq - sp->ulog_seqno - 1; if(droppedSamples) { sp->ulog_drops += droppedSamples; } } sp->ulog_seqno = msg->nlmsg_seq; switch(msg->nlmsg_type) { case NLMSG_NOOP: case NLMSG_ERROR: case NLMSG_OVERRUN: // ignore these break; case NLMSG_DONE: // last in multi-part default: { if(--MySkipCount == 0) { /* reached zero. Set the next skip */ MySkipCount = sfl_random((2 * sp->sFlow->sFlowSettings->ulogSubSamplingRate) - 1); /* and take a sample */ // we're seeing type==111 on Fedora14 //if(msg->nlmsg_flags & NLM_F_REQUEST) { } //if(msg->nlmsg_flags & NLM_F_MULTI) { } //if(msg->nlmsg_flags & NLM_F_ACK) { } //if(msg->nlmsg_flags & NLM_F_ECHO) { } ulog_packet_msg_t *pkt = NLMSG_DATA(msg); if(debug > 1) { myLog(LOG_INFO, "mark=%u ts=%s hook=%u in=%s out=%s len=%u prefix=%s maclen=%u", pkt->mark, ctime(&pkt->timestamp_sec), pkt->hook, pkt->indev_name, pkt->outdev_name, pkt->data_len, pkt->prefix, pkt->mac_len); if(pkt->mac_len == 14) { u_char macdst[12], macsrc[12]; printHex(pkt->mac+6,6,macsrc,12,NO); printHex(pkt->mac+0,6,macdst,12,NO); uint16_t ethtype = (pkt->mac[12] << 8) + pkt->mac[13]; myLog(LOG_INFO, "%s -> %s (ethertype=0x%04X)", macsrc, macdst, ethtype); } } SFL_FLOW_SAMPLE_TYPE fs = { 0 }; SFLAdaptor *sampler_dev = NULL; int inIsLoopback=0, outIsLoopback=0; // set the ingress and egress ifIndex numbers. // Can be "INTERNAL" (0x3FFFFFFF) or "UNKNOWN" (0). if(pkt->indev_name[0]) { SFLAdaptor *in = adaptorListGet(sp->adaptorList, pkt->indev_name); if(in) { fs.input = in->ifIndex; // record whether this was a loopback or not - used below HSPAdaptorNIO *inNIO = (HSPAdaptorNIO *)in->userData; inIsLoopback = inNIO->loopback; #ifdef HSF_CUMULUS // On Cumulus Linux the sampling direction is indicated in the low // bit of the pkt->hook field: 0==ingress,1==egress if((pkt->hook & 1) == 0) { sampler_dev = in; } #else // set this provisionally - may be overidden below sampler_dev = in; #endif } } else { fs.input = SFL_INTERNAL_INTERFACE; } if(pkt->outdev_name[0]) { SFLAdaptor *out = adaptorListGet(sp->adaptorList, pkt->outdev_name); if(out && out->ifIndex) { fs.output = out->ifIndex; HSPAdaptorNIO *outNIO = (HSPAdaptorNIO *)out->userData; outIsLoopback = outNIO->loopback; #ifdef HSF_CUMULUS // On Cumulus Linux the sampling direction is indicated in the low // bit of the pkt->hook field: 0==ingress,1==egress if((pkt->hook & 1) == 1) { sampler_dev = out; } #else // If one of them is not a loopback interface, then assume the // sample was taken there. In a typical scenario most samples // will be "lo" -> "eth0" or "eth0" -> "lo", so this ensures that // that we make that look like bidirectional sampling on eth0. if(sampler_dev == NULL || (inIsLoopback && !outIsLoopback)) { sampler_dev = out; } #endif } } else { fs.output = SFL_INTERNAL_INTERFACE; } // must have a sampler_dev with an ifIndex if(sampler_dev && sampler_dev->ifIndex) { HSPAdaptorNIO *samplerNIO = (HSPAdaptorNIO *)sampler_dev->userData; if(debug > 2) { myLog(LOG_INFO, "selected sampler %s (loopback in=%d out=%d)", sampler_dev->deviceName, inIsLoopback, outIsLoopback); } SFLSampler *sampler = getSampler(sp, sampler_dev); if(sampler) { SFLFlow_sample_element hdrElem = { 0 }; hdrElem.tag = SFLFLOW_HEADER; uint32_t FCS_bytes = 4; uint32_t maxHdrLen = sampler->sFlowFsMaximumHeaderSize; hdrElem.flowType.header.frame_length = pkt->data_len + FCS_bytes; hdrElem.flowType.header.stripped = FCS_bytes; u_char hdr[HSP_MAX_HEADER_BYTES]; if(pkt->mac_len == 14) { // set the header_protocol to ethernet and // reunite the mac header and payload in one buffer hdrElem.flowType.header.header_protocol = SFLHEADER_ETHERNET_ISO8023; memcpy(hdr, pkt->mac, 14); maxHdrLen -= 14; uint32_t payloadBytes = (pkt->data_len < maxHdrLen) ? pkt->data_len : maxHdrLen; memcpy(hdr+14, pkt->payload, payloadBytes); hdrElem.flowType.header.header_length = payloadBytes + 14; hdrElem.flowType.header.header_bytes = hdr; hdrElem.flowType.header.frame_length += 14; } else { // no need to copy - just point at the payload u_char ipversion = pkt->payload[0] >> 4; if(ipversion != 4 && ipversion != 6) { if(debug) myLog(LOG_ERR, "received non-IP packet. Encapsulation is unknown"); } else { hdrElem.flowType.header.header_protocol = (ipversion == 4) ? SFLHEADER_IPv4 : SFLHEADER_IPv6; hdrElem.flowType.header.stripped += 14; // assume ethernet was (or will be) the framing hdrElem.flowType.header.header_length = (pkt->data_len < maxHdrLen) ? pkt->data_len : maxHdrLen; hdrElem.flowType.header.header_bytes = pkt->payload; } } SFLADD_ELEMENT(&fs, &hdrElem); // submit the actual sampling rate so it goes out with the sFlow feed // otherwise the sampler object would fill in his own (sub-sampling) rate. // If it's a switch port then samplerNIO->sampling_n will be set, so that // takes precendence (allows different ports to have different sampling // settings). uint32_t actualSamplingRate = samplerNIO->sampling_n ?: sp->sFlow->sFlowSettings->ulogActualSamplingRate; fs.sampling_rate = actualSamplingRate; // estimate the sample pool from the samples. Could maybe do this // above with the (possibly more granular) ulogSamplingRate, but then // we would have to look up the sampler object every time, which // might be too expensive in the case where ulogSamplingRate==1. sampler->samplePool += actualSamplingRate; // accumulate any dropped-samples we detected against whichever sampler // sends the next sample. This is not perfect, but is likely to accrue // drops against the point whose sampling-rate needs to be adjusted. samplerNIO->ulog_drops += droppedSamples; fs.drops = samplerNIO->ulog_drops; sfl_sampler_writeFlowSample(sampler, &fs); } } } } } } }
/** * Reads a sampled packet header and associated information from * the buffer creates a packet sample. * Includes looking up the sampler from the ingress and egress * port information, and creating a new sampler (and poller) if * one does not already exist. */ void readPackets(HSP *sp, PUCHAR buffer) { PSFlowSample sample = (PSFlowSample)buffer; if (sample->version != 1) { myLog(LOG_INFO, "readPackets: unknown filter sample version: %u", sample->version); return; } SFL_FLOW_SAMPLE_TYPE fs = { 0 }; char *sampler_dev = NULL; uint32_t sampler_ifIndex = 0; // set the ingress and egress ifIndex numbers. // Can be "INTERNAL" (0x3FFFFFFF) or "UNKNOWN" (0). // mimic ingress sampling by using the ingress interface as the data source SFLAdaptor *in = getVAdaptorByIds(sp->vAdaptorList, sample->switchID, sample->srcPort); if (in) { fs.input = in->ifIndex; sampler_dev = in->deviceName; sampler_ifIndex = in->ifIndex; } SFLAdaptor *out = getVAdaptorByIds(sp->vAdaptorList, sample->switchID, sample->destPort); if (out) { fs.output = out->ifIndex; } else { fs.output = 0; } // must have an ifIndex to generate a sample if (sampler_ifIndex) { SFLSampler *sampler = getSampler(sp, sampler_dev, sampler_ifIndex); if (sampler) { // submit the actual sampling rate so it goes out with the sFlow feed // otherwise the sampler object would fill in his own (sub-sampling) rate. fs.sampling_rate = sample->sampleRate; // estimate the sample pool from the samples. Could maybe do this // above with the (possibly more granular) samplingRate, but then // we would have to look up the sampler object every time, which // might be too expensive in the case where samplingRate==1. sampler->samplePool += sample->sampleRate; fs.drops = sample->drops; PSFlowRecord currRecord = &sample->firstRecord; SFLFlow_sample_element hdrElem = { 0 }; SFLFlow_sample_element extSwElem = { 0 }; while (currRecord->recordType != NULL_RECORD_TYPE) { switch(currRecord->recordType) { case SAMPLED_HEADER_RECORD_TYPE: { PSFlowSampledHeader sampledHeader = GET_OPAQUE_DATA_ADDR(currRecord, PSFlowSampledHeader); hdrElem.tag = SFLFLOW_HEADER; hdrElem.flowType.header.frame_length = sampledHeader->frameLength; hdrElem.flowType.header.stripped = sampledHeader->stripped; hdrElem.flowType.header.header_protocol = SFLOW_HEADER_PROTOCOL; hdrElem.flowType.header.header_length = currRecord->dataLength - sizeof(SFlowSampledHeader); hdrElem.flowType.header.header_bytes = GET_OPAQUE_DATA_ADDR(sampledHeader, PUCHAR); SFLADD_ELEMENT(&fs, &hdrElem); if (LOG_INFO <= debug) { /*u_char pkt[HSP_MAX_HEADER_BYTES*2 +1]; //2 chars/byte + null printHex(GET_OPAQUE_DATA_ADDR(sampledHeader, PUCHAR), hdrElem.flowType.header.header_length, pkt, HSP_MAX_HEADER_BYTES*2+1, NO);*/ myLog(LOG_INFO, "readPackets: sampler: %s index: %u headerLength: %u, frameLength: %u dropped: %u", sampler->userData, SFL_DS_INDEX(sampler->dsi), hdrElem.flowType.header.header_length, hdrElem.flowType.header.frame_length, fs.drops); } break; } case EXTENDED_SWITCH_RECORD_TYPE: { PSFlowExtendedSwitch extendedSwitch = GET_OPAQUE_DATA_ADDR(currRecord, PSFlowExtendedSwitch); extSwElem.tag = SFLFLOW_EX_SWITCH; extSwElem.flowType.sw.src_vlan = extendedSwitch->sourceVLAN; extSwElem.flowType.sw.src_priority = extendedSwitch->sourcePriority; extSwElem.flowType.sw.dst_vlan = extendedSwitch->destVLAN; extSwElem.flowType.sw.dst_priority = extendedSwitch->destPriority; SFLADD_ELEMENT(&fs, &extSwElem); if (LOG_INFO <= debug) { myLog(LOG_INFO, "readPackets: sampler %s index %u srcVlan: %u srcPriority: %u dstVlan: %u dstPriority: %u", sampler->userData, SFL_DS_INDEX(sampler->dsi), extSwElem.flowType.sw.src_vlan, extSwElem.flowType.sw.src_priority, extSwElem.flowType.sw.dst_vlan, extSwElem.flowType.sw.dst_priority); } break; } case EXTENDED_TUNNEL_RECORD_TYPE: { PSFlowExtendedTunnel extendedTunnel = GET_OPAQUE_DATA_ADDR(currRecord, PSFlowExtendedTunnel); if (LOG_INFO <= debug) { myLog(LOG_INFO, "readPackets: sampler %s index %u VSID: %u", sampler->userData, SFL_DS_INDEX(sampler->dsi), extendedTunnel->vsid); } break; } default: { myLog(LOG_INFO, "readPackets: unknown filter record type: %u", currRecord->recordType); } } currRecord = GET_NEXT_SFLOW_RECORD(currRecord); } sfl_sampler_writeFlowSample(sampler, &fs); } } }