regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

27

static struct aspath *build_aspath(const uint32_t *, uint32_t, int);

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

442

struct aspath *a;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

445

a = build_aspath(aspath_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

450

print_aspath(aspath_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

458

print_aspath(aspath_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

46

const uint32_t *aspath;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

467

a = build_aspath(aspath_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

472

print_aspath(aspath_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

481

print_aspath(aspath_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

494

struct aspath *a;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

498

a = build_aspath(aspa_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

507

print_aspath(aspa_testset[i].aspath,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

52

const uint32_t *aspath;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

555

static struct aspath *

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

558

struct aspath *aspath;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

570

aspath = malloc(ASPATH_HEADER_SIZE + len);

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

571

if (aspath == NULL)

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

574

aspath->len = len;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

575

aspath->ascnt = asncnt; /* lie but nothing cares */

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

576

aspath->source_as = 0;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

579

return aspath;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

582

aspath->source_as = asns[asncnt - 1];

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

584

aspath->source_as = asns[0];

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

586

aspath->data[0] = AS_SEQUENCE;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

587

aspath->data[1] = asncnt;

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

594

memcpy(aspath->data + 2 + sizeof(as) * i, &as,

regress/usr.sbin/bgpd/unittests/rde_aspa_test.c

598

return aspath;

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

106

.p = { .re = &dummy_re, .aspath = &asp[0], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

109

.p = { .re = &dummy_re, .aspath = &asp[1], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

112

.p = { .re = &dummy_re, .aspath = &asp[2], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

115

.p = { .re = &dummy_re, .aspath = &asp[0], .peer = &peer1, .nhflags = 0, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

118

.p = { .re = &dummy_re, .aspath = &asp[3], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

121

.p = { .re = &dummy_re, .aspath = &asp[4], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

124

.p = { .re = &dummy_re, .aspath = &asp[5], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

126

.p = { .re = &dummy_re, .aspath = &asp[6], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

129

.p = { .re = &dummy_re, .aspath = &asp[7], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

132

.p = { .re = &dummy_re, .aspath = &asp[0], .peer = &peer1_i, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

135

.p = { .re = &dummy_re, .aspath = &asp[8], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

139

.p = { .re = &dummy_re, .aspath = &asp[0], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T2, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

142

.p = { .re = &dummy_re, .aspath = &asp[0], .peer = &peer2, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

146

.p = { .re = &dummy_re, .aspath = &asp[0], .peer = &peer1_a4, .nhflags = NEXTHOP_VALID, .lastchange = T1, } },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

150

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

151

{ .aspath = &asdata[0].a, .med = 150, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

152

{ .aspath = &asdata[2].a, .med = 75, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

153

{ .aspath = &asdata[2].a, .med = 125, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

154

{ .aspath = &asdata[1].a, .med = 110, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

155

{ .aspath = &asdata[1].a, .med = 90, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

166

{ .re = &dummy_re, .aspath = &med_asp[0], .peer = &peer2, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

168

{ .re = &dummy_re, .aspath = &med_asp[1], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

170

{ .re = &dummy_re, .aspath = &med_asp[2], .peer = &peer3, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

172

{ .re = &dummy_re, .aspath = &med_asp[3], .peer = &peer1_a4, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

175

{ .re = &dummy_re, .aspath = &med_asp[5], .peer = &peer3, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

177

{ .re = &dummy_re, .aspath = &med_asp[4], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

184

{ .re = &dummy_re, .aspath = &asp[0], .peer = &peer2, .nhflags = NEXTHOP_VALID, .lastchange = T1, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

186

{ .re = &dummy_re, .aspath = &asp[0], .peer = &peer1, .nhflags = NEXTHOP_VALID, .lastchange = T2, };

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

66

struct aspath a;

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

81

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_IGP, .weight = 1000 },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

83

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_IGP, .flags=F_ATTR_PARSE_ERR },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

84

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_IGP, .flags=F_ATTR_LOOP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

86

{ .aspath = &asdata[0].a, .med = 100, .lpref = 50, .origin = ORIGIN_IGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

88

{ .aspath = &asdata[1].a, .med = 100, .lpref = 100, .origin = ORIGIN_IGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

90

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_EGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

91

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_INCOMPLETE },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

93

{ .aspath = &asdata[0].a, .med = 200, .lpref = 100, .origin = ORIGIN_IGP },

regress/usr.sbin/bgpd/unittests/rde_decide_test.c

95

{ .aspath = &asdata[0].a, .med = 100, .lpref = 100, .origin = ORIGIN_IGP, .weight = 100 },

usr.sbin/bgpctl/bgpctl.c

1291

!match_aspath(mre->aspath, mre->aspath_len, &req->as))

usr.sbin/bgpctl/bgpctl.c

1294

ibuf_from_buffer(&ibuf, mre->aspath, mre->aspath_len);

usr.sbin/bgpctl/bgpctl.c

1359

!match_aspath(mre->aspath, mre->aspath_len, &req->as))

usr.sbin/bgpctl/bgpctl.c

1374

imsg_add(msg, mre->aspath, mre->aspath_len) == -1)

usr.sbin/bgpctl/mrtparser.c

671

if ((re->aspath = malloc(alen)) == NULL)

usr.sbin/bgpctl/mrtparser.c

673

if (ibuf_get(&abuf, re->aspath, alen) == -1)

usr.sbin/bgpctl/mrtparser.c

676

re->aspath = mrt_aspath_inflate(&abuf,

usr.sbin/bgpctl/mrtparser.c

678

if (re->aspath == NULL)

usr.sbin/bgpctl/mrtparser.c

752

free(re->aspath);

usr.sbin/bgpctl/mrtparser.c

754

if ((re->aspath = malloc(alen)) == NULL)

usr.sbin/bgpctl/mrtparser.c

756

if (ibuf_get(&abuf, re->aspath, alen) == -1)

usr.sbin/bgpctl/mrtparser.c

803

free(r->entries[i].aspath);

usr.sbin/bgpctl/mrtparser.h

40

void *aspath;

usr.sbin/bgpctl/output.c

1008

if (aspath_asprint(&aspath, asbuf) == -1)

usr.sbin/bgpctl/output.c

1010

if (strlen(aspath) > 0)

usr.sbin/bgpctl/output.c

1011

printf("%s ", aspath);

usr.sbin/bgpctl/output.c

1012

free(aspath);

usr.sbin/bgpctl/output.c

1021

char *aspath, *s;

usr.sbin/bgpctl/output.c

1027

if (aspath_asprint(&aspath, asbuf) == -1)

usr.sbin/bgpctl/output.c

1029

if (strlen(aspath) > 0)

usr.sbin/bgpctl/output.c

1030

printf(" %s%c", aspath, EOL0(flag0));

usr.sbin/bgpctl/output.c

1031

free(aspath);

usr.sbin/bgpctl/output.c

1054

show_rib(struct ctl_show_rib *r, struct ibuf *aspath, struct parse_result *res)

usr.sbin/bgpctl/output.c

1057

show_rib_detail(r, aspath, res->flags);

usr.sbin/bgpctl/output.c

1059

show_rib_brief(r, aspath);

usr.sbin/bgpctl/output.c

780

char *aspath;

usr.sbin/bgpctl/output.c

833

if (aspath_asprint(&aspath, &asbuf) == -1)

usr.sbin/bgpctl/output.c

835

printf("%s", aspath);

usr.sbin/bgpctl/output.c

836

free(aspath);

usr.sbin/bgpctl/output.c

998

char *p, *aspath;

usr.sbin/bgpctl/output_json.c

593

char *aspath;

usr.sbin/bgpctl/output_json.c

655

if (aspath_asprint(&aspath, &asbuf) == -1)

usr.sbin/bgpctl/output_json.c

657

json_do_string("aspath", aspath);

usr.sbin/bgpctl/output_json.c

658

free(aspath);

usr.sbin/bgpctl/output_json.c

826

char *aspath;

usr.sbin/bgpctl/output_json.c

834

if (aspath_asprint(&aspath, asbuf) == -1)

usr.sbin/bgpctl/output_json.c

836

json_do_string("aspath", aspath);

usr.sbin/bgpctl/output_json.c

837

free(aspath);

usr.sbin/bgpd/mrt.c

236

plen = aspath_length(a->aspath);

usr.sbin/bgpd/mrt.c

237

pdata = aspath_dump(a->aspath);

usr.sbin/bgpd/mrt.c

339

pdata = aspath_prepend(a->aspath, rde_local_as(), 0, &plen);

usr.sbin/bgpd/rde.c

1034

asp = &state.aspath;

usr.sbin/bgpd/rde.c

1035

asp->aspath = aspath_get(NULL, 0);

usr.sbin/bgpd/rde.c

1528

if ((subtype = rde_attr_missing(&state.aspath, peer->conf.ebgp,

usr.sbin/bgpd/rde.c

1537

rde_as4byte_fixup(peer, &state.aspath);

usr.sbin/bgpd/rde.c

1540

if (state.aspath.flags & F_ATTR_ASPATH &&

usr.sbin/bgpd/rde.c

1542

fas = aspath_neighbor(state.aspath.aspath);

usr.sbin/bgpd/rde.c

1555

if (state.aspath.flags & F_ATTR_ASPATH &&

usr.sbin/bgpd/rde.c

1558

!aspath_loopfree(state.aspath.aspath, peer->conf.local_as))

usr.sbin/bgpd/rde.c

1559

state.aspath.flags |= F_ATTR_LOOP;

usr.sbin/bgpd/rde.c

1561

rde_reflector(peer, &state.aspath);

usr.sbin/bgpd/rde.c

1564

if (state.aspath.flags & F_ATTR_ASPATH && peer->conf.ebgp) {

usr.sbin/bgpd/rde.c

1565

aspa_validation(rde_aspa, state.aspath.aspath,

usr.sbin/bgpd/rde.c

1566

&state.aspath.aspa_state);

usr.sbin/bgpd/rde.c

1567

state.aspath.aspa_generation = rde_aspa_generation;

usr.sbin/bgpd/rde.c

1627

if ((state.aspath.flags & ~F_ATTR_MP_UNREACH) == 0 &&

usr.sbin/bgpd/rde.c

1713

if ((state.aspath.flags & ~F_ATTR_MP_UNREACH) == 0)

usr.sbin/bgpd/rde.c

1728

if ((state.aspath.flags & F_ATTR_OTC) == 0) {

usr.sbin/bgpd/rde.c

1735

if (attr_optadd(&state.aspath,

usr.sbin/bgpd/rde.c

1742

state.aspath.flags |= F_ATTR_OTC;

usr.sbin/bgpd/rde.c

1795

if ((state.aspath.flags & F_ATTR_OTC) == 0) {

usr.sbin/bgpd/rde.c

1802

if (attr_optadd(&state.aspath,

usr.sbin/bgpd/rde.c

1810

state.aspath.flags |= F_ATTR_OTC;

usr.sbin/bgpd/rde.c

1818

state.aspath.flags &= ~F_ATTR_OTC_LEAK;

usr.sbin/bgpd/rde.c

1990

aspath_origin(in->aspath.aspath));

usr.sbin/bgpd/rde.c

1991

aspa_state = rde_aspa_validity(peer, &in->aspath, prefix->aid);

usr.sbin/bgpd/rde.c

2009

if (in->aspath.flags & F_ATTR_PARSE_ERR)

usr.sbin/bgpd/rde.c

2079

struct rde_aspath *a = &state->aspath;

usr.sbin/bgpd/rde.c

2174

a->aspath = aspath_get(ibuf_data(&tmpbuf), ibuf_size(&tmpbuf));

usr.sbin/bgpd/rde.c

2508

if (attr_optadd(&state->aspath, flags, type, ibuf_data(buf),

usr.sbin/bgpd/rde.c

2835

fas = aspath_neighbor(asp->aspath);

usr.sbin/bgpd/rde.c

3003

aslen = aspath_length(asp->aspath);

usr.sbin/bgpd/rde.c

3009

imsg_add(wbuf, aspath_dump(asp->aspath), aslen) == -1)

usr.sbin/bgpd/rde.c

3051

asp = attrs->aspath;

usr.sbin/bgpd/rde.c

3082

aslen = aspath_length(asp->aspath);

usr.sbin/bgpd/rde.c

3088

imsg_add(wbuf, aspath_dump(asp->aspath), aslen) == -1)

usr.sbin/bgpd/rde.c

3161

!aspath_match(asp->aspath, &req->as, 0))

usr.sbin/bgpd/rde.c

3180

struct rde_aspath *asp = attrs->aspath;

usr.sbin/bgpd/rde.c

3191

!aspath_match(asp->aspath, &req->as, 0))

usr.sbin/bgpd/rde.c

4428

&prefix, pt->prefixlen, aspath_origin(asp->aspath));

usr.sbin/bgpd/rde.c

4436

aspa_validation(rde_aspa, asp->aspath,

usr.sbin/bgpd/rde.c

4745

aspath_origin(state->aspath.aspath));

usr.sbin/bgpd/rde.c

570

asp = &netconf_state.aspath;

usr.sbin/bgpd/rde.c

571

asp->aspath = aspath_get(NULL, 0);

usr.sbin/bgpd/rde.c

588

asp = &netconf_state.aspath;

usr.sbin/bgpd/rde.c

595

aspath_put(asp->aspath);

usr.sbin/bgpd/rde.c

596

asp->aspath = aspath_get(ibuf_data(&ibuf),

usr.sbin/bgpd/rde.c

688

asp = &netconf_state.aspath;

usr.sbin/bgpd/rde.c

689

asp->aspath = aspath_get(NULL, 0);

usr.sbin/bgpd/rde.c

986

asp = &state.aspath;

usr.sbin/bgpd/rde.c

987

asp->aspath = aspath_get(NULL, 0);

usr.sbin/bgpd/rde.h

134

#define ASPATH_HEADER_SIZE (offsetof(struct aspath, data))

usr.sbin/bgpd/rde.h

227

struct aspath *aspath;

usr.sbin/bgpd/rde.h

293

struct rde_aspath *aspath;

usr.sbin/bgpd/rde.h

332

struct rde_aspath *aspath;

usr.sbin/bgpd/rde.h

359

struct rde_aspath aspath;

usr.sbin/bgpd/rde.h

472

struct aspath *aspath_get(const void *, uint16_t);

usr.sbin/bgpd/rde.h

473

struct aspath *aspath_copy(struct aspath *);

usr.sbin/bgpd/rde.h

474

void aspath_put(struct aspath *);

usr.sbin/bgpd/rde.h

477

uint32_t aspath_neighbor(struct aspath *);

usr.sbin/bgpd/rde.h

478

int aspath_loopfree(struct aspath *, uint32_t);

usr.sbin/bgpd/rde.h

479

int aspath_compare(const struct aspath *, const struct aspath *);

usr.sbin/bgpd/rde.h

480

int aspath_match(struct aspath *, struct filter_as *, uint32_t);

usr.sbin/bgpd/rde.h

481

u_char *aspath_prepend(struct aspath *, uint32_t, int, uint16_t *);

usr.sbin/bgpd/rde.h

482

u_char *aspath_override(struct aspath *, uint32_t, uint32_t,

usr.sbin/bgpd/rde.h

484

int aspath_lenmatch(struct aspath *, enum aslen_spec, u_int);

usr.sbin/bgpd/rde.h

487

aspath_dump(struct aspath *aspath)

usr.sbin/bgpd/rde.h

489

return (aspath->data);

usr.sbin/bgpd/rde.h

493

aspath_length(struct aspath *aspath)

usr.sbin/bgpd/rde.h

495

return (aspath->len);

usr.sbin/bgpd/rde.h

499

aspath_origin(struct aspath *aspath)

usr.sbin/bgpd/rde.h

501

return (aspath->source_as);

usr.sbin/bgpd/rde.h

706

return (p->aspath);

usr.sbin/bgpd/rde.h

830

void aspa_validation(struct rde_aspa *, struct aspath *,

usr.sbin/bgpd/rde_adjout.c

282

h = ch_qhash64(attrkey, (uintptr_t)a->aspath);

usr.sbin/bgpd/rde_adjout.c

291

if (a->aspath == b->aspath &&

usr.sbin/bgpd/rde_adjout.c

321

a->aspath = path_ref(asp);

usr.sbin/bgpd/rde_adjout.c

346

path_unref(a->aspath);

usr.sbin/bgpd/rde_adjout.c

347

a->aspath = NULL;

usr.sbin/bgpd/rde_adjout.c

381

asp = path_getcache(&state->aspath);

usr.sbin/bgpd/rde_adjout.c

388

needle.aspath = asp;

usr.sbin/bgpd/rde_adjout.c

544

path_equal(&state->aspath, attrs->aspath)) {

usr.sbin/bgpd/rde_aspa.c

169

aspa_check_aspath(struct rde_aspa *ra, struct aspath *a, struct aspa_state *s)

usr.sbin/bgpd/rde_aspa.c

305

aspa_validation(struct rde_aspa *ra, struct aspath *a,

usr.sbin/bgpd/rde_attr.c

366

aspath_compare(const struct aspath *a1, const struct aspath *a2)

usr.sbin/bgpd/rde_attr.c

382

struct aspath *

usr.sbin/bgpd/rde_attr.c

385

struct aspath *aspath;

usr.sbin/bgpd/rde_attr.c

387

aspath = malloc(ASPATH_HEADER_SIZE + len);

usr.sbin/bgpd/rde_attr.c

388

if (aspath == NULL)

usr.sbin/bgpd/rde_attr.c

394

aspath->len = len;

usr.sbin/bgpd/rde_attr.c

395

aspath->ascnt = aspath_count(data, len);

usr.sbin/bgpd/rde_attr.c

396

aspath->source_as = aspath_extract_origin(data, len);

usr.sbin/bgpd/rde_attr.c

398

memcpy(aspath->data, data, len);

usr.sbin/bgpd/rde_attr.c

400

return (aspath);

usr.sbin/bgpd/rde_attr.c

403

struct aspath *

usr.sbin/bgpd/rde_attr.c

404

aspath_copy(struct aspath *a)

usr.sbin/bgpd/rde_attr.c

406

struct aspath *aspath;

usr.sbin/bgpd/rde_attr.c

408

aspath = malloc(ASPATH_HEADER_SIZE + a->len);

usr.sbin/bgpd/rde_attr.c

409

if (aspath == NULL)

usr.sbin/bgpd/rde_attr.c

415

memcpy(aspath, a, ASPATH_HEADER_SIZE + a->len);

usr.sbin/bgpd/rde_attr.c

417

return (aspath);

usr.sbin/bgpd/rde_attr.c

421

aspath_put(struct aspath *aspath)

usr.sbin/bgpd/rde_attr.c

423

if (aspath == NULL)

usr.sbin/bgpd/rde_attr.c

427

rdemem.aspath_size -= ASPATH_HEADER_SIZE + aspath->len;

usr.sbin/bgpd/rde_attr.c

428

free(aspath);

usr.sbin/bgpd/rde_attr.c

594

if (ascnt > a->aspath->ascnt) {

usr.sbin/bgpd/rde_attr.c

602

cnt = a->aspath->ascnt - ascnt;

usr.sbin/bgpd/rde_attr.c

604

if (attr->len > aspath_length(a->aspath)) {

usr.sbin/bgpd/rde_attr.c

609

if ((out = ibuf_open(aspath_length(a->aspath))) == NULL)

usr.sbin/bgpd/rde_attr.c

612

ibuf_from_buffer(&in, aspath_dump(a->aspath), aspath_length(a->aspath));

usr.sbin/bgpd/rde_attr.c

621

aspath_put(a->aspath);

usr.sbin/bgpd/rde_attr.c

622

a->aspath = aspath_get(ibuf_data(out), ibuf_size(out));

usr.sbin/bgpd/rde_attr.c

629

aspath_neighbor(struct aspath *aspath)

usr.sbin/bgpd/rde_attr.c

636

if (aspath->len == 0 ||

usr.sbin/bgpd/rde_attr.c

637

aspath->data[0] != AS_SEQUENCE)

usr.sbin/bgpd/rde_attr.c

639

return (aspath_extract(aspath->data, 0));

usr.sbin/bgpd/rde_attr.c

703

aspath_loopfree(struct aspath *aspath, uint32_t myAS)

usr.sbin/bgpd/rde_attr.c

709

seg = aspath->data;

usr.sbin/bgpd/rde_attr.c

710

for (len = aspath->len; len > 0; len -= seg_size, seg += seg_size) {

usr.sbin/bgpd/rde_attr.c

764

aspath_match(struct aspath *aspath, struct filter_as *f, uint32_t neighas)

usr.sbin/bgpd/rde_attr.c

773

if (aspath_length(aspath) == 0)

usr.sbin/bgpd/rde_attr.c

781

as = aspath_neighbor(aspath);

usr.sbin/bgpd/rde_attr.c

788

seg = aspath->data;

usr.sbin/bgpd/rde_attr.c

789

len = aspath->len;

usr.sbin/bgpd/rde_attr.c

836

aspath_prepend(struct aspath *asp, uint32_t as, int quantum, uint16_t *len)

usr.sbin/bgpd/rde_attr.c

918

aspath_override(struct aspath *asp, uint32_t neighbor_as, uint32_t local_as,

usr.sbin/bgpd/rde_attr.c

960

aspath_lenmatch(struct aspath *a, enum aslen_spec type, u_int aslen)

usr.sbin/bgpd/rde_decide.c

166

if (asp1->aspath->ascnt < asp2->aspath->ascnt)

usr.sbin/bgpd/rde_decide.c

168

if (asp1->aspath->ascnt > asp2->aspath->ascnt)

usr.sbin/bgpd/rde_decide.c

185

aspath_neighbor(asp1->aspath) == aspath_neighbor(asp2->aspath)) {

usr.sbin/bgpd/rde_filter.c

101

if (state->aspath.lpref <

usr.sbin/bgpd/rde_filter.c

103

state->aspath.lpref = 0;

usr.sbin/bgpd/rde_filter.c

105

state->aspath.lpref +=

usr.sbin/bgpd/rde_filter.c

110

state->aspath.flags |= F_ATTR_MED | F_ATTR_MED_ANNOUNCE;

usr.sbin/bgpd/rde_filter.c

1108

if (state->aspath.flags & F_ATTR_PARSE_ERR)

usr.sbin/bgpd/rde_filter.c

111

state->aspath.med = set->action.metric;

usr.sbin/bgpd/rde_filter.c

114

state->aspath.flags |= F_ATTR_MED | F_ATTR_MED_ANNOUNCE;

usr.sbin/bgpd/rde_filter.c

116

if (state->aspath.med >

usr.sbin/bgpd/rde_filter.c

1168

if (state->aspath.flags & F_ATTR_PARSE_ERR)

usr.sbin/bgpd/rde_filter.c

118

state->aspath.med = UINT_MAX;

usr.sbin/bgpd/rde_filter.c

120

state->aspath.med +=

usr.sbin/bgpd/rde_filter.c

123

if (state->aspath.med <

usr.sbin/bgpd/rde_filter.c

125

state->aspath.med = 0;

usr.sbin/bgpd/rde_filter.c

127

state->aspath.med +=

usr.sbin/bgpd/rde_filter.c

132

state->aspath.weight = set->action.metric;

usr.sbin/bgpd/rde_filter.c

136

if (state->aspath.weight >

usr.sbin/bgpd/rde_filter.c

138

state->aspath.weight = UINT_MAX;

usr.sbin/bgpd/rde_filter.c

140

state->aspath.weight +=

usr.sbin/bgpd/rde_filter.c

143

if (state->aspath.weight <

usr.sbin/bgpd/rde_filter.c

145

state->aspath.weight = 0;

usr.sbin/bgpd/rde_filter.c

147

state->aspath.weight +=

usr.sbin/bgpd/rde_filter.c

154

np = aspath_prepend(state->aspath.aspath, prep_as,

usr.sbin/bgpd/rde_filter.c

156

aspath_put(state->aspath.aspath);

usr.sbin/bgpd/rde_filter.c

157

state->aspath.aspath = aspath_get(np, nl);

usr.sbin/bgpd/rde_filter.c

165

np = aspath_prepend(state->aspath.aspath, prep_as,

usr.sbin/bgpd/rde_filter.c

167

aspath_put(state->aspath.aspath);

usr.sbin/bgpd/rde_filter.c

168

state->aspath.aspath = aspath_get(np, nl);

usr.sbin/bgpd/rde_filter.c

174

np = aspath_override(state->aspath.aspath,

usr.sbin/bgpd/rde_filter.c

176

aspath_put(state->aspath.aspath);

usr.sbin/bgpd/rde_filter.c

177

state->aspath.aspath = aspath_get(np, nl);

usr.sbin/bgpd/rde_filter.c

197

pftable_unref(state->aspath.pftableid);

usr.sbin/bgpd/rde_filter.c

198

state->aspath.pftableid = pftable_ref(set->action.id);

usr.sbin/bgpd/rde_filter.c

201

rtlabel_unref(state->aspath.rtlabelid);

usr.sbin/bgpd/rde_filter.c

202

state->aspath.rtlabelid = rtlabel_ref(set->action.id);

usr.sbin/bgpd/rde_filter.c

205

state->aspath.origin = set->action.origin;

usr.sbin/bgpd/rde_filter.c

264

struct rde_aspath *asp = &state->aspath;

usr.sbin/bgpd/rde_filter.c

278

if (aspath_match(asp->aspath, &match->as,

usr.sbin/bgpd/rde_filter.c

284

if (aspath_lenmatch(asp->aspath, match->aslen.type,

usr.sbin/bgpd/rde_filter.c

344

aspath_origin(asp->aspath)) != ROA_VALID)

usr.sbin/bgpd/rde_filter.c

590

path_prep(&state->aspath);

usr.sbin/bgpd/rde_filter.c

601

path_copy(&state->aspath, asp);

usr.sbin/bgpd/rde_filter.c

625

rde_filterstate_set(state, &src->aspath, &src->communities,

usr.sbin/bgpd/rde_filter.c

645

path_clean(&state->aspath);

usr.sbin/bgpd/rde_filter.c

90

state->aspath.lpref = set->action.metric;

usr.sbin/bgpd/rde_filter.c

94

if (state->aspath.lpref >

usr.sbin/bgpd/rde_filter.c

96

state->aspath.lpref = UINT_MAX;

usr.sbin/bgpd/rde_filter.c

98

state->aspath.lpref +=

usr.sbin/bgpd/rde_rib.c

1065

if (p->aspath && p->aspath->pftableid)

usr.sbin/bgpd/rde_rib.c

1066

rde_pftable_del(p->aspath->pftableid, p);

usr.sbin/bgpd/rde_rib.c

1122

nasp = &state->aspath;

usr.sbin/bgpd/rde_rib.c

1225

p->aspath = path_ref(asp);

usr.sbin/bgpd/rde_rib.c

1256

path_unref(p->aspath);

usr.sbin/bgpd/rde_rib.c

1257

p->aspath = NULL;

usr.sbin/bgpd/rde_rib.c

687

SipHash24_Update(&ctx, aspath_dump(p->aspath),

usr.sbin/bgpd/rde_rib.c

688

aspath_length(p->aspath));

usr.sbin/bgpd/rde_rib.c

722

if (aspath_compare(a->aspath, b->aspath) != 0)

usr.sbin/bgpd/rde_rib.c

763

path_getcache(struct rde_aspath *aspath)

usr.sbin/bgpd/rde_rib.c

767

aspath->hash = path_calc_hash(aspath);

usr.sbin/bgpd/rde_rib.c

768

if ((asp = CH_FIND(path_tree, &pathtable, aspath)) == NULL) {

usr.sbin/bgpd/rde_rib.c

770

asp = path_copy(path_get(), aspath);

usr.sbin/bgpd/rde_rib.c

815

dst->aspath = aspath_copy(src->aspath);

usr.sbin/bgpd/rde_rib.c

869

aspath_put(asp->aspath);

usr.sbin/bgpd/rde_rib.c

870

asp->aspath = NULL;

usr.sbin/bgpd/rde_rib.c

938

struct rde_aspath *asp, *nasp = &state->aspath;

usr.sbin/bgpd/rde_update.c

1202

if (up_generate_attr(buf, peer, pa->attrs->aspath,

usr.sbin/bgpd/rde_update.c

128

if (state->aspath.flags & F_ATTR_OTC)

usr.sbin/bgpd/rde_update.c

137

if ((state->aspath.flags & F_ATTR_OTC) == 0) {

usr.sbin/bgpd/rde_update.c

141

if (attr_optadd(&state->aspath,

usr.sbin/bgpd/rde_update.c

146

state->aspath.flags |= F_ATTR_OTC;

usr.sbin/bgpd/rde_update.c

437

asp = &state.aspath;

usr.sbin/bgpd/rde_update.c

438

asp->aspath = aspath_get(NULL, 0);

usr.sbin/bgpd/rde_update.c

586

np = aspath_prepend(state->aspath.aspath, prep_as, 1, &nl);

usr.sbin/bgpd/rde_update.c

587

aspath_put(state->aspath.aspath);

usr.sbin/bgpd/rde_update.c

588

state->aspath.aspath = aspath_get(np, nl);

usr.sbin/bgpd/rde_update.c

637

plen = aspath_length(asp->aspath);

usr.sbin/bgpd/rde_update.c

638

pdata = aspath_dump(asp->aspath);

usr.sbin/bgpd/rde_update.c

710

plen = aspath_length(asp->aspath);

usr.sbin/bgpd/rde_update.c

711

pdata = aspath_dump(asp->aspath);