flow
const uint8_t flow[] = { 0x0d, 0x80, 0x00 };
if (flowspec_valid(flow, sizeof(flow), 0) != -1)
if (flowspec_valid(flow, sizeof(flow), 1) != 0)
struct iked_flow *flow;
while ((flow = RB_MIN(iked_flows, head))) {
log_debug("%s: free %p", __func__, flow);
RB_REMOVE(iked_flows, head, flow);
flow_free(flow);
struct iked_flow *flow;
RB_FOREACH(flow, iked_flows, &pol->pol_flows) {
iov[1].iov_base = flow;
iov[1].iov_len = sizeof(*flow);
struct iked_flow *flow;
if ((flow = calloc(1, sizeof(*flow))) == NULL)
memcpy(flow, buf + offset, sizeof(*flow));
if (RB_INSERT(iked_flows, &pol->pol_flows, flow)) {
free(flow);
struct iked_flow *flow, *flowtmp;
TAILQ_FOREACH_SAFE(flow, &sa->sa_flows, flow_entry, flowtmp) {
TAILQ_REMOVE(&sa->sa_flows, flow, flow_entry);
TAILQ_INSERT_TAIL(&nsa->sa_flows, flow,
flow->flow_ikesa = nsa;
flow->flow_local = &nsa->sa_local;
flow->flow_peer = &nsa->sa_peer;
struct iked_flow *flow, *saflow, *flowa, *flowb;
RB_FOREACH(flow, iked_flows, &sa->sa_policy->pol_flows) {
memcpy(flowa, flow, sizeof(*flow));
if (ikev2_cp_fixflow(sa, flow, flowa) == -1) {
memcpy(flowb, flowa, sizeof(*flow));
memcpy(&flowb->flow_src, &flow->flow_dst,
sizeof(flow->flow_dst));
memcpy(&flowb->flow_dst, &flow->flow_src,
sizeof(flow->flow_src));
if (ikev2_cp_fixflow(sa, flow, flowb) == -1) {
struct iked_flow *flow, *oflow;
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry) {
if (flow->flow_loaded) {
__func__, flow);
RB_REMOVE(iked_flows, &env->sc_activeflows, flow);
(void)pfkey_flow_delete(env, flow);
flow->flow_loaded = 0; /* we did RB_REMOVE */
if (pfkey_flow_add(env, flow) != 0) {
if ((oflow = RB_FIND(iked_flows, &env->sc_activeflows, flow))
__func__, oflow, flow);
RB_INSERT(iked_flows, &env->sc_activeflows, flow);
reload ? "re" : "", flow);
if (flow->flow_dir == IPSP_DIRECTION_OUT &&
flow->flow_prenat.addr_af != 0)
flow->flow_prenat.addr_mask);
if (flow->flow_dir == IPSP_DIRECTION_OUT) {
print_map(flow->flow_saproto, ikev2_saproto_map),
print_addr(&flow->flow_src.addr),
flow->flow_src.addr_mask,
flow->flow_prenat.addr_af != 0 ? "[": "",
flow->flow_prenat.addr_af != 0 ?
print_addr(&flow->flow_prenat.addr) : "",
flow->flow_prenat.addr_af != 0 ? "/" : "",
flow->flow_prenat.addr_af != 0 ? prenat_mask : "",
flow->flow_prenat.addr_af != 0 ? "]": "",
print_addr(&flow->flow_dst.addr),
flow->flow_dst.addr_mask,
flow->flow_ipproto,
struct iked_flow *flow;
flow = RB_FIND(iked_flows, &env->sc_activeflows, acquire);
if (!flow) {
if ((sa = flow->flow_ikesa) == NULL) {
flow->flow_saproto, 0) != 0)
ikev2_cp_fixflow(struct iked_sa *sa, struct iked_flow *flow,
return (ikev2_cp_fixaddr(sa, &flow->flow_dst,
return (ikev2_cp_fixaddr(sa, &flow->flow_dst,
return (ikev2_cp_fixaddr(sa, &flow->flow_src,
return (ikev2_cp_fixaddr(sa, &flow->flow_src,
struct iked_flow *flow, *oflow;
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry) {
if (flow->flow_loaded) {
RB_REMOVE(iked_flows, &env->sc_activeflows, flow);
(void)pfkey_flow_delete(env, flow);
flow->flow_loaded = 0;
if (pfkey_flow_add(env, flow) != 0)
log_debug("%s: failed to add flow %p", __func__, flow);
if (!flow->flow_loaded)
if ((oflow = RB_FIND(iked_flows, &env->sc_activeflows, flow))
__func__, oflow, flow);
RB_INSERT(iked_flows, &env->sc_activeflows, flow);
struct iked_flow *flow)
if (flow->flow_prenat.addr_af != 0)
flow->flow_prenat.addr_mask);
"%s: %p %s %s %s/%d -> %s/%d %s%s%s%s%s[%u]@%d (%s) @%p\n", msg, flow,
print_map(flow->flow_saproto, ikev2_saproto_map),
flow->flow_dir == IPSP_DIRECTION_IN ? "in" : "out",
print_addr(&flow->flow_src.addr),
flow->flow_src.addr_mask,
print_addr(&flow->flow_dst.addr),
flow->flow_dst.addr_mask,
flow->flow_prenat.addr_af != 0 ? "[": "",
flow->flow_prenat.addr_af != 0 ?
print_addr(&flow->flow_prenat.addr) : "",
flow->flow_prenat.addr_af != 0 ? "/" : "",
flow->flow_prenat.addr_af != 0 ? prenat_mask : "",
flow->flow_prenat.addr_af != 0 ? "] ": "",
flow->flow_ipproto,
flow->flow_rdomain,
flow->flow_loaded ? "L" : "",
flow->flow_ikesa);
struct iked_flow *flow;
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry) {
ikev2_info_flow(env, imsg, dolog, " sa_flows", flow);
RB_FOREACH(flow, iked_flows, &env->sc_activeflows) {
ikev2_info_flow(env, imsg, dolog, "iked_flows", flow);
struct iked_flow *flow, *ftmp;
RB_FOREACH_SAFE(flow, iked_flows, &pol.pol_flows, ftmp) {
RB_REMOVE(iked_flows, &pol.pol_flows, flow);
free(flow);
struct iked_flow *flow;
if ((flow = calloc(1, sizeof(struct iked_flow))) == NULL)
memcpy(&flow->flow_src.addr, &ipa->address,
flow->flow_src.addr_af = ipa->af;
flow->flow_src.addr_mask = ipa->mask;
flow->flow_src.addr_net = ipa->netaddress;
flow->flow_src.addr_port = ipa->port;
memcpy(&flow->flow_dst.addr, &ipb->address,
flow->flow_dst.addr_af = ipb->af;
flow->flow_dst.addr_mask = ipb->mask;
flow->flow_dst.addr_net = ipb->netaddress;
flow->flow_dst.addr_port = ipb->port;
memcpy(&flow->flow_prenat.addr, &ippn->address,
flow->flow_prenat.addr_af = ippn->af;
flow->flow_prenat.addr_mask = ippn->mask;
flow->flow_prenat.addr_net = ippn->netaddress;
flow->flow_prenat.addr_af = 0;
flow->flow_dir = IPSP_DIRECTION_OUT;
flow->flow_ipproto = proto;
flow->flow_saproto = pol->pol_saproto;
flow->flow_rdomain = pol->pol_rdomain;
if (RB_INSERT(iked_flows, &pol->pol_flows, flow) == NULL)
free(flow);
struct iked_flow *flow;
pfkey_flow_add(struct iked *env, struct iked_flow *flow)
if (flow->flow_loaded)
if (pfkey_map(pfkey_satype, flow->flow_saproto, &satype) == -1)
if (pfkey_flow(env, satype, SADB_X_ADDFLOW, flow) == -1)
flow->flow_loaded = 1;
pfkey_flow_delete(struct iked *env, struct iked_flow *flow)
if (!flow->flow_loaded)
if (pfkey_map(pfkey_satype, flow->flow_saproto, &satype) == -1)
if (pfkey_flow(env, satype, SADB_X_DELFLOW, flow) == -1)
flow->flow_loaded = 0;
TAILQ_FOREACH(flow, &sa->sa_flows, flow_entry) {
if (!flow->flow_loaded && couple)
(void)pfkey_flow_add(env, flow);
else if (flow->flow_loaded && !couple)
(void)pfkey_flow_delete(env, flow);
pfkey_flow(struct iked *env, uint8_t satype, uint8_t action, struct iked_flow *flow)
struct iked_flow flow;
bzero(&flow, sizeof(flow));
flow.flow_peer = &peer;
flow.flow_src.addr_af = ssrc->sa_family;
flow.flow_src.addr_port = htons(socket_getport(ssrc));
if ((slen = ssrc->sa_len) > sizeof(flow.flow_src.addr)) {
memcpy(&flow.flow_src.addr, ssrc, slen);
if (socket_af((struct sockaddr *)&flow.flow_src.addr,
flow.flow_src.addr_port) == -1) {
flow.flow_dst.addr_af = sdst->sa_family;
flow.flow_dst.addr_port = htons(socket_getport(sdst));
if ((slen = sdst->sa_len) > sizeof(flow.flow_dst.addr)) {
memcpy(&flow.flow_dst.addr, sdst, slen);
if (socket_af((struct sockaddr *)&flow.flow_dst.addr,
flow.flow_dst.addr_port) == -1) {
flow.flow_src.addr_mask =
if (flow.flow_src.addr_mask != 32)
flow.flow_src.addr_net = 1;
flow.flow_src.addr_mask =
if (flow.flow_src.addr_mask != 128)
flow.flow_src.addr_net = 1;
flow.flow_dst.addr_mask =
if (flow.flow_src.addr_mask != 32)
flow.flow_src.addr_net = 1;
flow.flow_dst.addr_mask =
if (flow.flow_src.addr_mask != 128)
flow.flow_src.addr_net = 1;
flow.flow_saproto = IKEV2_SAPROTO_AH;
flow_src = &flow->flow_src;
flow.flow_saproto = IKEV2_SAPROTO_ESP;
flow.flow_saproto = IKEV2_SAPROTO_IPCOMP;
flow_dst = &flow->flow_dst;
flow.flow_dir = sa_proto->sadb_protocol_direction;
flow.flow_rdomain = -1; /* XXX get from kernel */
flow.flow_dir == IPSP_DIRECTION_IN ? "in" : "out",
ret = ikev2_child_sa_acquire(env, &flow);
if (flow->flow_prenat.addr_af == flow_src->addr_af) {
if (flow->flow_dir == IPSP_DIRECTION_IN)
flow_dst = &flow->flow_prenat;
flow_src = &flow->flow_prenat;
if (action != SADB_X_DELFLOW && flow->flow_local != NULL) {
memcpy(&slocal, &flow->flow_local->addr, sizeof(slocal));
memcpy(&speer, &flow->flow_peer->addr, sizeof(speer));
sa_flowtype.sadb_protocol_direction = flow->flow_dir;
sa_protocol.sadb_protocol_proto = flow->flow_ipproto;
if (action != SADB_X_DELFLOW && flow->flow_local != NULL) {
sa_srcid = pfkey_id2ident(IKESA_SRCID(flow->flow_ikesa),
sa_dstid = pfkey_id2ident(IKESA_DSTID(flow->flow_ikesa),
if (flow->flow_rdomain >= 0) {
sa_rdomain.sadb_x_rdomain_dom1 = flow->flow_rdomain;
if (action != SADB_X_DELFLOW && flow->flow_local != NULL) {
if (flow->flow_rdomain >= 0) {
struct iked_flow *flow;
RB_FOREACH(flow, iked_flows, &pol->pol_flows) {
if (ts_insert_unique(&flow->flow_src, &pol->pol_tssrc,
flow->flow_ipproto) == 1)
if (ts_insert_unique(&flow->flow_dst, &pol->pol_tsdst,
flow->flow_ipproto) == 1)
struct iked_flow *flow, *flowtmp;
TAILQ_FOREACH_SAFE(flow, head, flow_entry, flowtmp) {
log_debug("%s: free %p", __func__, flow);
if (flow->flow_loaded)
RB_REMOVE(iked_flows, &env->sc_activeflows, flow);
TAILQ_REMOVE(head, flow, flow_entry);
(void)pfkey_flow_delete(env, flow);
flow_free(flow);
flow_free(struct iked_flow *flow)
free(flow);
RB_FOREACH(flow, iked_flows, &pol->pol_flows) {
print_verbose(" from %s", print_addr(&flow->flow_src.addr));
if (flow->flow_src.addr_af != AF_UNSPEC &&
flow->flow_src.addr_net)
print_verbose("/%d", flow->flow_src.addr_mask);
if (flow->flow_src.addr_port)
ntohs(flow->flow_src.addr_port));
print_verbose(" to %s", print_addr(&flow->flow_dst.addr));
if (flow->flow_dst.addr_af != AF_UNSPEC &&
flow->flow_dst.addr_net)
print_verbose("/%d", flow->flow_dst.addr_mask);
if (flow->flow_dst.addr_port)
ntohs(flow->flow_dst.addr_port));
struct iked_flow *flow;
struct pf_key_v2_msg *flow = 0, *ret = 0;
flow = pf_key_v2_msg_new(&msg, 0);
if (!flow)
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) sid,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) sid,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *)&flowtype, 0) == -1)
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) addr,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) addr,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) addr,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) addr,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *) addr,
if (pf_key_v2_msg_add(flow, (struct sadb_ext *)&tprotocol, 0) == -1)
ret = pf_key_v2_call(flow);
pf_key_v2_msg_free(flow);
flow = 0;
if (flow)
pf_key_v2_msg_free(flow);
u_int32_t flow = ip6->ip6_flow & IPV6_FLOWLABEL_MASK;
(ip6->ip6_vfc & IPV6_VERSION_MASK) >> 4, tc, (u_int32_t)ntohl(flow),
mvpp2_prs_flow_find(struct mvpp2_softc *sc, int flow)
if ((bits & MVPP2_PRS_FLOW_ID_MASK) == flow)
int flow;
flow = 0;
flow |= IFM_ETH_RXPAUSE;
flow |= IFM_ETH_TXPAUSE;
ifmr->ifm_active = IFM_ETHER | IFM_AUTO | media | flow;
uint32_t flow, threshold;
flow = 0;
flow |= MUE_FLOW_TX_FCEN | MUE_FLOW_PAUSE_TIME;
flow |= MUE_FLOW_RX_FCEN;
mue_csr_write(sc, MUE_FLOW, flow);
uint32_t flow;
flow = 0xffff0002;
flow = 0;
flow = 0;
err += smsc_write_reg(sc, SMSC_FLOW, flow);
int rate, data, flow;
flow = FTDI_SIO_RTS_CTS_HS;
flow = FTDI_SIO_XON_XOFF_HS;
flow = FTDI_SIO_DISABLE_FLOW_CTRL;
USETW2(req.wIndex, flow, portno);
struct flow *flows;
static inline struct flow *
struct flow *flow;
flow = classify_flow(fqc, m);
if (flow == NULL)
codel_enqueue(&flow->cd, now, m);
if (!flow->active) {
SIMPLEQ_INSERT_TAIL(&fqc->newq, flow, flowentry);
flow->deficit = fqc->quantum;
flow->active = 1;
flow->id, flow->deficit);
flow = &fqc->flows[i];
backlog = codel_backlog(&flow->cd);
KASSERT(flow != NULL);
ndrop = MIN(MAX(codel_qlength(&flow->cd) / 2, 1), 64);
m = codel_commit(&flow->cd, NULL);
i, ndrop, flow->id);
static inline struct flow *
struct flow *flow;
while ((flow = SIMPLEQ_FIRST(*fq)) != NULL) {
if (flow->deficit <= 0) {
flow->deficit += fqc->quantum;
SIMPLEQ_INSERT_TAIL(&fqc->oldq, flow,
flow->id, flow->deficit);
return (flow);
static inline struct flow *
next_flow(struct fqcodel *fqc, struct flow *flow, struct flowq **fq)
SIMPLEQ_INSERT_TAIL(&fqc->oldq, flow, flowentry);
flow->id, flow->deficit);
flow->active = 0;
flow->id, flow->deficit);
struct flow *flow;
for (flow = first_flow(fqc, &fq); flow != NULL;
flow = next_flow(fqc, flow, &fq)) {
m = codel_dequeue(&flow->cd, &fqc->cparams, now, &ml,
flow->deficit -= m->m_pkthdr.len;
flow->id, flow->deficit);
*cookiep = flow;
struct flow *flow = cookie;
(void)codel_commit(&flow->cd, m);
fqc->flows = mallocarray(fqc->nflows, sizeof(struct flow),
free(fqc->flows, M_DEVBUF, fqc->nflows * sizeof(struct flow));
SIMPLEQ_ENTRY(flow) flowentry;
SIMPLEQ_HEAD(flowq, flow);
unsigned int flow = 0;
flow = m->m_pkthdr.ph_flowid;
ifiq = ifp->if_iqs[flow % ifp->if_niqs];
uint16_t flow = 0;
flow = m->m_pkthdr.ph_flowid >> AGGR_FLOWID_SHIFT;
ifp0 = map->m_ifp0s[flow % AGGR_MAX_PORTS];
uint32_t flow;
flow = IPV6_VERSION << 24;
flow |= IFQ_PRIO2TOS(sc->sc_txhprio == IF_HDRPRIO_PACKET ?
htobem32(&ip6->ip6_flow, flow);
uint32_t flow;
flow = bemtoh32(&ip6->ip6_flow);
return (etherip_input(&key, m, flow >> 20, *offp, ns));
uint32_t flow;
flow = otos << 20;
flow |= m->m_pkthdr.ph_flowid;
ip6->ip6_flow = htonl(flow);
uint32_t flow;
flow = ntohl(ip6->ip6_flow);
rv = gif_input(&key, mp, offp, proto, af, flow >> 20, ns);
flow = bemtoh32(&ip6->ip6_flow);
if (gre_input_key(mp, offp, type, af, flow >> 20, &key, ns) == -1)
uint32_t flow;
flow = bemtoh32(&ip6->ip6_flow);
itos = flow >> 20;
CLR(flow, 0xff << 20);
SET(flow, itos << 20);
htobem32(&ip6->ip6_flow, flow);
uint32_t flow;
uint32_t flow = bemtoh32(&ip6->ip6_flow);
tos = flow >> 20;
uint32_t flow;
flow = bemtoh32(&ip6->ip6_flow);
tos = flow >> 20;
uint32_t flow;
flow = bemtoh32(&ip6->ip6_flow);
tos = flow >> 20;
uint32_t flow;
flow = bemtoh32(&ip6->ip6_flow);
tos = flow >> 20;
uint32_t flow = 0;
flow = m->m_pkthdr.ph_flowid;
flow ^= sc->sc_flow;
flow += MPLS_LABEL_RESERVED_MAX + 1;
shim |= htonl(flow << MPLS_LABEL_OFFSET) &
uint32_t flow;
flow = MPLS_SHIM2LABEL(shim->shim_label);
flow ^= sc->sc_flow;
m->m_pkthdr.ph_flowid = flow;
uint32_t flow = sc->sc_flow;
flow ^= m->m_pkthdr.ph_flowid;
shim->shim_label |= MPLS_LABEL2SHIM(flow) | exp | bos;
copy_flow_to_m(struct pflow_flow *flow, struct pflow_softc *sc)
sizeof(struct pflow_flow), flow, M_NOWAIT);
copy_flow_ipfix_4_to_m(void *flow, size_t size, struct pflow_softc *sc,
(sc->sc_count4_nat * size), size, flow, M_NOWAIT);
(sc->sc_count4 * size), size, flow, M_NOWAIT);
copy_flow_ipfix_6_to_m(struct pflow_ipfix_flow6 *flow, struct pflow_softc *sc)
(sc->sc_count6 * size), size, flow, M_NOWAIT);
int copy_flow_to_m(struct pflow_flow *flow, struct pflow_softc *sc);
int copy_flow_ipfix_4_to_m(void *flow, size_t size,
int copy_flow_ipfix_6_to_m(struct pflow_ipfix_flow6 *flow,
flow = ip6->ip6_flow & IPV6_FLOWLABEL_MASK;
SipHash24_Update(&ctx, &flow, sizeof(flow)); /* IPv6 flow label */
u_int32_t flow;
unsigned int flow = 0;
flow = m->m_pkthdr.ph_flowid;
ifiq = ifp->if_iqs[flow % ifp->if_niqs];
unsigned int flow = 0;
flow = m->m_pkthdr.ph_flowid;
return (flow % nqueues);
import_flow(struct sockaddr_encap *flow, struct sockaddr_encap *flowmask,
bzero(flow, sizeof(*flow));
flow->sen_family = flowmask->sen_family = PF_KEY;
flow->sen_len = flowmask->sen_len = SENT_LEN;
flow->sen_type = SENT_IP4;
flow->sen_direction = ftype->sadb_protocol_direction;
flow->sen_ip_src = src->sin.sin_addr;
flow->sen_ip_dst = dst->sin.sin_addr;
flow->sen_proto = transproto;
flow->sen_sport = src->sin.sin_port;
flow->sen_dport = dst->sin.sin_port;
flow->sen_type = SENT_IP6;
flow->sen_ip6_direction = ftype->sadb_protocol_direction;
flow->sen_ip6_src = src->sin6.sin6_addr;
flow->sen_ip6_dst = dst->sin6.sin6_addr;
flow->sen_ip6_proto = transproto;
flow->sen_ip6_sport = src->sin6.sin6_port;
flow->sen_ip6_dport = dst->sin6.sin6_port;
export_flow(void **p, u_int8_t ftype, struct sockaddr_encap *flow,
switch (flow->sen_type) {
sab->sadb_protocol_direction = flow->sen_direction;
sab->sadb_protocol_direction = flow->sen_ip6_direction;
switch (flow->sen_type) {
sab->sadb_protocol_proto = flow->sen_proto;
sab->sadb_protocol_proto = flow->sen_ip6_proto;
export_encap(p, flow, SADB_X_EXT_SRC_FLOW);
export_encap(p, flow, SADB_X_EXT_DST_FLOW);
r->flow.complen[type] = complen;
r->flow.components[type] = comp;
push_prefix(r, FLOWSPEC_TYPE_DEST, &r->flow.dst, r->flow.dstlen);
push_prefix(r, FLOWSPEC_TYPE_SOURCE, &r->flow.src, r->flow.srclen);
if (r->flow.components[i] != NULL)
len += r->flow.complen[i] + 1;
if (r->flow.components[i] != NULL) {
component_finish(i, r->flow.components[i],
r->flow.complen[i]);
memcpy(f->data + len, r->flow.components[i],
r->flow.complen[i]);
len += r->flow.complen[i];
complen = r->flow.complen[type];
comp = realloc(r->flow.components[type], complen + len + 1);
r->flow.complen[type] = complen;
r->flow.components[type] = comp;
if (parse_prefix(word, wordlen, &res.flow.src,
&res.flow.srclen)) {
if (res.aid != res.flow.src.aid)
if (parse_prefix(word, wordlen, &res.flow.dst,
&res.flow.dstlen)) {
if (res.aid != res.flow.dst.aid)
} flow;
f->flow, FLOWSPEC_SIZE + f->flow->len) == -1)
-1, f->flow, FLOWSPEC_SIZE + f->flow->len) == -1)
struct flowspec *flow;
struct flowspec *flow;
flow = malloc(FLOWSPEC_SIZE + len);
if (flow == NULL)
memset(flow, 0, FLOWSPEC_SIZE);
free(flow);
conf->flow = flow;
flow->len = len;
flow->aid = aid;
free(f->flow);
if (a->flow->aid < b->flow->aid)
if (a->flow->aid > b->flow->aid)
return flowspec_cmp(a->flow->data, a->flow->len,
b->flow->data, b->flow->len, a->flow->aid == AID_FLOWSPECv6);
flowspec_get_component(const uint8_t *flow, int flowlen, int type, int is_v6,
complen = flowspec_next_component(flow, flowlen, is_v6, &t);
flow += complen;
*buf = flow + 1;
flowspec_get_addr(const uint8_t *flow, int flowlen, int type, int is_v6,
rv = flowspec_get_component(flow, flowlen, type, is_v6,
f->flow->data[len++] = i;
memcpy(f->flow->data + len, ctx->components[i],
struct flowspec *f = fconf->flow;
uint8_t *flow;
len = pt_getflowspec(p->pt, &flow);
imsg_add(ibuf, flow, len) == -1)
uint8_t flow[0]; /* NLRI */
#define PT_FLOW_SIZE (offsetof(struct pt_entry_flow, flow))
flowspec_get_addr(pflow->flow, pflow->len - PT_FLOW_SIZE,
pt_getflowspec(struct pt_entry *pte, uint8_t **flow)
*flow = pflow->flow;
struct pt_entry_flow flow;
needle = (struct pt_entry *)&x.flow;
memcpy(((struct pt_entry_flow *)needle)->flow, f->data, f->len);
memcpy(((struct pt_entry_flow *)p)->flow, f->data, f->len);
return flowspec_cmp(af->flow, af->len - PT_FLOW_SIZE,
bf->flow, bf->len - PT_FLOW_SIZE,
if (ibuf_add(tmp, &pflow->flow, flowlen) == -1)
u_int16_t flow;
ntohs(gh->length), ntohs(gh->seqno), ntohs(gh->flow),
flow = ntohl(ip6->ip6_flow);
if (flow & 0x0ff00000)
printf(" [class 0x%x]", (flow & 0x0ff00000) >> 20);
if (flow & 0x000fffff)
printf(" [flowlabel 0x%x]", flow & 0x000fffff);
u_int flow;