►
From YouTube: IETF109-HACKATHONCLOSING-20201113-0500
Description
HACKATHONCLOSING meeting session at IETF109
2020/11/13 0500
https://datatracker.ietf.org/meeting/109/proceedings/
A
A
couple
introductory
slides
and
then
only
take,
maybe
five
minutes
or
so
and
then
after
that,
we'll
just
go
through
plan,
is
to
just
go
through
an
order.
If
anyone
has
a
need
to
present
at
a
time
different
than
the
time
there,
they
would
naturally
do
it.
You
could
kind
of,
let
me
know
in
the
chat,
and
we
can.
We
can
move
you
if
you're
or,
if
you're,
not
available
right.
When
your
slot
comes
up,
we
can
come
back
to
you,
but
the
overall
plan
would
be
just
to
go
through
them
in
order.
A
I
think
that'll
be
easiest
for
everyone
and
that
way
we'll
it's
always
easy
to
tell
which
one's
next
and
how
far
through
the
agenda
we.
A
A
So
we're
at
the
top
of
the
hour,
but
I
see
you
know
several
people
are
still
joining
so
we'll
give
it
two
three
minutes
at
least
and
then,
if
then
we
should
be
able
to
get
started.
A
A
A
A
A
People
who
join
late
will
always
be
able
to
catch
the
recording
okay,
so
welcome
back
to
well,
in
this
case
the
closing
session
of
the
the
hackathon.
Hopefully,
you
had
a
good
week,
and
this
is
our
opportunity
to
to
share
what
we
did.
A
First
of
all,
just
a
reminder
of
why
we're
here,
you
know
really
to
advance
the
pace
and
relevance
of
ietf
standards
and
also
to
just
put
more
focus
on
writing
code.
Bringing
in
you
know
and
kind
of
helping
developers
in
general
contribute
more
to
itf
get
more
involved
in
ietf.
A
Certainly,
writing
code
is
important
and
this
event
is
in
addition
to
working
on
existing
ietf
drafts.
Also,
a
big
part
of
it
is
kind
of
introducing
people
into
the
ietf
who
might
not
be
as
familiar
with
it,
but
give
them
the
ability
to
to
get
involved
and
in
a
way,
that's
comfortable
and
very
productive
for
them
and
oftentimes
that's
through
working
on
code.
More
so
than
just
reviewing
the
drafts
providing
comments.
A
So
a
reminder
of
the
the
ietf
note:
well,
basically,
everything
at
the
ietf
all
itf
contributions
fall
under
the
terms
of
the
note.
Well,
as
we
discussed
in
the
opening
the
the
code
that
you
work
on,
may
have
different
license
and
rules
around
its
use
and
what
you
need
to
do,
but
in
terms
of
the
presentations
that
you
give
here,
those
will
be
ietf
contributions
and
and
they
fall
under
the
terms
of
the
notewell.
So
if
you
haven't
familiarized
yourself
with
that,
I
suggest
you
do
that.
A
A
And
whether
you're
presenting
your
project
or
not
very
important
to
to
upload
it
to
the
to
the
wiki,
sorry
to
the
the
ietf
hackathon
github
org,
and
there
is
a
repo
there
for
ietf
109
project
presentations.
If
you
go
to
that,
there
are
some
instructions
about
how
to
do
that.
A
If
you
didn't
get
your
presentation
uploaded
in
time
for
the
closing
here,
you're
still
free
to
share
it
from
wherever
you
have
it
just
make
sure
that
you
get
it
uploaded
and
and
if
you
need
to
make
changes
after
the
presentation,
you
know
that
that's
fine
too.
A
A
Now
a
reminder:
these
presentations
are
they're
to
be
short,
just
quick
summaries
about
what
you
were
trying
to
solve
and
what
you
achieved,
and
you
really
like
to
learn
like
not
only
what
you
did
but
but
you
know
what
did
you
learn
from
it
and
perhaps
more
importantly,
in
some
cases,
what
did
you
find
out
or
figure
out
that
you
would
bring
back
to
the
working
group
in
terms
of
if
you
were,
for
example,
implementing
a
draft?
A
What
worked,
what
didn't,
what
was
challenging
good
feedback
you'd
be
bringing
back
into
your
working
group
would
be
great
to
share
here
and
then,
hopefully
you
have
the
ability
to
share
it
during
the
working
group
session
too,
you
have
some
agenda
time.
I
know
many
of
you
have
been
doing
that
and
that's
fantastic
also.
It's
it's
great
to
know
when
you
work
with
some
people
outside
of
the
typical
ietf
community,
perhaps
getting
involved
with
some
open
source
project.
A
That's
you
know
in
another
community,
perhaps
the
linux
foundation
or
with
apache,
or
something
like
that
and
you're
working
with
folks
from
that
community.
That's
good
to
know
also,
if
you
did
a
project
that
crossed
you,
know
ietf
boundaries
into
work,
that
another
sdo
is
doing
that.
That's
really
interesting
to
know
as
well.
A
A
So
here
I
am
on
just
the
hackathon
wiki
and
if
you
go
down
into
the
agenda,
you
can
see
for
the
closing
session,
there's
a
link
here
to
the
results,
presentation
schedule
and
when
I
click
on
that
that
has
all
the
presentations
that
we're
planning
on
having
and
as
I
mentioned
at
the
the
start
before
maybe
some
of
you
joined
the
plan
is
to
just
go
through
them
in
order
and
so
without
any
more
delay.
A
A
I'll
stop
sharing.
We
can
see
your
video
and,
if
you
request
to
share
the
screen
I'll
grant
that
and
you
can
share
your
presentation-
don't
hear
your
audio
yet.
A
B
B
B
B
B
B
B
After
we
compiled
the
p4
program,
we
can
get
the
mau
resource
occupation
directly.
There
are
two
processes
about
86,
namely
the
determining
and
the
injury.
The
maximum
number
of
the
related
interest
is
set
to
1024
and
the
table
shows
the
results
we
can
see.
All
the
mentioned.
Resources
are
occupied
less
than
1.5.
B
B
We
send
50
000
packs
in
total
in
each
experiment
and
get
the
results
and
all
the
results
are
shown
in
nanoseconds
from
this
table.
We
can
see
the
difference
between
the
average
processing.
Latency
of
these
experiments
are
about
only
6.6
nanoseconds.
This
difference
is
caused
by
the
processing
of
apn6
and
then
we
simply
analyze
the
results.
We
firstly
use
the
ks
test
to
prove
that
they
are
both
in
accordance
with
the
normal
distribution.
B
After
that
we
calculated
some
probabilities.
The
results
are
shown
in
these
two
tables.
For
example,
if
we
got
10
000
packets,
the
probability
of
that
their
average
length
increasing
is
less
than
1.80
percent
is
about
20,
but
if
we
see
the
average
increasing
is
less
than
1.82,
the
probability
is
one
hundred
percent.
B
If
we
get
one
packet,
the
probability
of
that
is
latency
increasing
is
less
than
one
point.
Eight
zero
percent
is
about
fifty
percent,
and
if
we
assume
the
increasing
is
two
percent,
the
probability
is
eighty-eight
percent.
We
can
draw
a
concluding
that
about
the
encapsulating
of
apa6id
option.
Its
latency
overhead
is
1.81
at
the
macro
level
and
2.4
percent,
at
the
micro
and
in
the
future
we
will
deploy
the
people
switch
on
cine
and
the
test
f8
and
apn6
on
it.
Cne
is
a
cross-domain
experimental
network
which
allows
us
to
do
some
better
experiments.
A
A
Okay,
so
next
up
yang
mediator.
C
A
D
D
D
D
D
The
ansible
we
use
as
controller
will
connect
to
mediator
with
a
plugin,
and
the
mediator
will
translate
the
message
and
return
it
back
to
expo.
The
expo
will
send
the
translated
configuration
to
the
devices
here
are
the
sample
messages
we
intercepted
from
the
project.
The
input
is
a
message
instantiated
from
ietfl
3nf
module.
D
Our
goal
is
to
generate
the
output
that
is
correspond
to
the
vendors
network
instance
model.
For
for
now,
we
have
developed
mediator
framework
which
provide
python
api
and
the
way
for
this
project.
We
part
developer
translation
scripts
between
ietf
elsewhere
and
model
and
render
native
yum
and
to
integrate
it
with
expo
we
developed
a
plug-in
and
last
we
have
successfully
delivered
the
configuration
which
is
instantiated
from
itf
model
to
the
render
devices
using
mediator
compared
to
the
traditional
ways
of
scripts.
D
Developing.
There
are
several
advantages
of
mediator.
The
python
api
mediator
offers
minimize
the
barrier
for
developing
and
mediator
also
can
offer
support
for
compact
scenarios
or
message.
Conversion
and
mediator
can
offer
a
script.
Template
will
help
developing
and
the
plugin
can
help
mediator
to
integrate
with
different
kind
of
controllers
and
the
loss
mediator
is
coupled
from
the
network
management
protocol,
which
have
enabled
a
flexible
deployment
from
this
hacksaw
way.
Learn
that
current
ways
of
developing
translation
scripts
are
inefficient,
so
the
goal
of
our
project
is
make
it
easier
and
faster
for
the
developing.
D
So
in
the
future
we
will
continue
working
on
this
project.
We
intend
to
implement
automatic
scripts
generation
and
also
we
will
do
more
tests
with
different
source
providers
and
here's
our
team
member
here
are
the
links
of
our
open
source
project
and
then
what
we
do.
If
you
are
interested,
you
can
pay
them
with
it
or
contact
us
while
email.
That's
all.
Thank
you.
A
A
Also
the
screen
share
had
started,
but
then
it
seemed
like
it
stopped.
Maybe
it's
a
matter
of
the
the
browser
not
being
granted.
A
Okay,
I
think
we
will
come
back
to
thomas.
Why
don't
we
move
on
to
dns
now.
A
E
So
we
dns
people
the
we
have
a
normally.
I
would
go
to
the
hackathon
room
and
see
all
my
fellow
dns
people
there
and
then
start
and
decide
on
what
what
kind
of
features
we
going
to
implement.
E
E
He
immediately
roy
solicited
that
or
asked
about
broker
broken
dns
zones,
so
we
could
have
some
sort
of
testing
environment
and
suggestions
were
offered
on
the
chat,
servers
and
a
implementation
of
a
authoritative
server.
That
would
return
the
option
on
where
to
report
the
or
filed
a
report
about
the
brokenness
of
a
name.
E
Was
created
and
also
a
test
server
that
would
show
the
reports
that
came
in
about
broken
dns
records,
and
so
this
was
done
so
there's
another
side.
You
also
need
resolvers
that
send
the
edns
option
to
the
authoritative
saying
I
will
I'm
willing
to
report
errors
to
the
report
server.
But
although
many
of
the
resolver
implementations
already
have
the
extended
dns
errors,
we
did
not
have
a
implementation
yet,
which
reported
to
a
specific
reporting
server.
E
E
So
another
hack
that
was
done
is
the
dns
zone,
dig
digest.
As
you
know,
the
dinasek
provides
integrity
and
out
authenticity
for
our
sets
for
completing
our
sets
zone.
Md
provides
integrity
and
authenticity
for
complete
sounds
so
a
secondary,
authoritative
server
can
be
sure
that
it
has
to
serve
the
complete
zone.
E
Finally,
a
lot
of
people
will
planning
to
work
on
the
new
catalog
zones
drafts
and
test
or
do
interoperability
testing,
but
we
didn't
get
to
this.
We
were
too
much
busy
with
communicating
and
interacting
about
the
the
first
hack
I
think,
but
a
lot
of
people
mentioned
that
I
still
intend
to
work
on
this
over
the
weekend
and
then
do
a
report
of
dns
catalog
zones.
E
So
what
we've
learned
is
that
I
it's
really
missed
the
in-person
hackathon,
because
you
know
it's
it's
better
to
have
ad
hoc
conversations
and
social
interaction
in
person
then,
but,
and
also
to
have
other
people
dedicated
on
working
on
the
hacks,
but
it
it
worked
out
quite
well.
I
think
the
way
we
did
it,
we
still
had
implementers
focus
on
new
ideas
and
standards
and
we
had
valuable
input.
I
think
during
this
week,
which
we
might
otherwise
would
have
taken
more
time,
or
at
least
we
would.
A
Okay,
well,
that's
great,
and
certainly
it's
it's
perfectly
fine
and
encouraged
to
continue
to
work
on
these
things
outside
of
the
week
of
the
hackathon.
So
I'm
glad
you're
planning
on
doing
that
and
and
yeah.
If
you
want
to
update
or
add
to
the
report,
you
have
on
the
uploaded
to
github
that'd
be
great.
A
A
So
y'all
we
see
your
your
screen
sharing,
but
we
also
need
your
audio
and
video
okay.
There
we
go
all
right.
Let's.
F
C
C
A
It's
maybe
perhaps
a
little
choppy
at
times,
but
didn't
seem
to
be
working.
F
F
Check
the
header,
compression
and
fragmentation
technology
being
developed
at
the
h1
working
group,
which
has
been
standardized
as
rfc
8724
and
last
april
and
as
usual,
we
want
to
improve
the
existing
code
base.
Do
some
cleanup
implement
some
options,
details
that
are
not
in
there
yet
and
also
improve
the
documentation.
F
So
we
make
it
easier
for
people
to
use
the
open
source
code
that
we
provide
and
also,
as
I'm,
going
to
show
you
develop
connectors
so
that
we
can
use
that
compression
technology
over
existing
networks
such
as
oron
or
sigfox
or
nb
iot
more
easily,
and
also
this
time
we
wanted
to
implement
a
few
features
of
the
drive
that
we
have
at
the
lp
one
worker
working
group.
F
G
F
To
make
sure
we
can
do
some
interrupt
testing
between
them
going
forward,
so
we
did
this
time.
So
I'm
not
expecting
you
to
read
the
fine
prints
on
the
block
diagram.
But
what
we
have
to
write
is
the
end
device
that
runs
on
an
embedded,
microprocessor
microcontroller
and
to
produce
the
application
reading
from
right
to
left
application
on
top
of
the
compression
fragmentation
layer.
Then
the
device
sends
the
payload
on
the
lp1
network
and
then
we
have.
F
F
G
F
Rest
interface
to
the
internet,
so
that's
one
thing
that
got
done
and
the
other
one
was
implementing
a
few
of
the
features
of
the
draft
I
just
mentioned
before,
which
relate
to
things
and
icmp,
v6,
error
messages,
and
so
the
like,
if
you
get
a
ping
from
the
internet
to
the
device
that
I
ipv6
is
enabled
through
the
use
of
check,
you
probably
don't
want
to
forward
the
ping
over
the
lp1,
which
is
severely
energy
constrained
and
time
on
air
constrained.
F
Just
to
give
you
a
slight
of
the
idea
of
what
we
want
to
do
and-
and
we
also
did
some
documentation
now-
we
have
a
user
guide-
that's
actually
usable,
which
is
better
than
it
was
before,
because
we
had
evolved
the
code
and
the
the
user
guide
didn't
match
that,
and
so
what
we
learned
we
we
loved
using
gather
the
town.
It
worked
great
again,
even
better
than
last
time
we
had
a
whiteboard
that
we
used.
F
F
F
F
F
A
Great
thanks
a
lot
for
for
that,
and
it
was
encouraging
to
see
that
in
here
that
the
gather
worked
well
for
you,
I'm
glad
it
did.
I
did
know,
there's
quite
a
few
people
using
it
throughout
the
course
of
the
hackathon,
so
hopefully
that
that
continues
to
improve
and
be
more
and
more
useful
for
us.
A
Okay.
Next
up,
we
have
quick.
H
H
In
this
academy,
our
goals
were
to
provide
tools
and
ideas
for
traffic
performance
monitoring,
especially
considering
the
hero
of
the
new
encrypted
transport
protocol
that
are
growing,
and
these
tools
and
idea
use
the
explicit
flow
measurement
techniques
that
are
some
are
some
techniques
that
employ
a
few
marking
leads
inside
the
other
of
each
packet,
and
these
are
done
for
expose
some
information
on
the
network
about
loss
and
delay,
and
in
this
way
we
can
we
can
achieve.
We
can
we
can
measure
traffic.
H
Another
goal
was
to
update
the
the
spindam
tool.
That
is
the
the
tool
developed
by
the
ericsson
guys.
That
is
really
useful
because
can
intercept
a
lot
of
kind
of
traffic,
icmp,
tcp,
quick
as
ctp
and
and
other
stuff.
H
H
H
H
These
are
some
slides
about
the
application.
As
you
can
see,
with
this
application,
we
can
intercept
all
the
traffic
flowing
in
in
and
out
from
an
android
mobile
phone.
We
can
track
the
application
we
can
track
the
connection
and
and
try
to
compute
some
information
from
from
the
data
that
are
exposed
on
wire.
H
These
are
real-time
mobile
traffic
monitoring,
and
what
we
noticed
was
that
placing
the
explicit
performance
observer
on
user
device
gives
many
advantages
in
terms
of
scalability,
of
course,
other
deployment
and
also
measures
precisions.
So
we
notice
that
measurements
are
more
precise
in
the
client,
because
we
can.
We
can
remove
the
application
delay
of
the
of
the
client
side
and
make
the
measurements
more
precise.
H
These
are
another
slide
that
that
gives
an
image
of
the
application
working
during
a
youtube
youtube
transmission.
As
you
can
see,
there's
the
there
are
some
information
about
the
connection.
In
this
case,
we
can
see
the
round
trip
time.
Measured
in
a
quick
connection
in
this
case
is
only
the
one
computed
exploiting
the
the
quick
handshake
packets.
H
In
fact,
you
can
see
there's
no
spin
bit
activated
in
this
connection
and
what
we
think
is
that
operators,
with
a
customer's
permission,
could
use
this
information
to
promptly
identify
network
problems
and
try
to
improve
their
overall,
the
overall
customer
experience
and
the
other
things
could
be
to
improve,
also
the
network
being
able
to
locate
that
part
of
network
the
area,
for
example,
in
mobile
speaking
of
mobile
network,
that
area
that
are
not
covered
well.
H
These
are
the
teams
members
that
took
part
during
the
zakaton.
There
are
some
guys
from
ericsson
from
huawei
and
and
some
other
guys
like
me
from
telecom
italia,
there's
also
the
the
kitab
of
spindam
that
you
can
see
to
take
all
the
information
about
about
the
the
software
used
to
to
make
the
this
app
working.
Thank
you.
A
I
Okay,
better
there
we
go
yep
great,
it's
all
yours,
okay,
yeah!
I
didn't
know
that
after
you
unmuted
me.
I
needed
to
unlock
myself
as
well
so
good
morning.
I'm
sorry,
but
6
am
means
no
video
for
me.
I
don't
want
to
scare
you.
This
team
is
the
asdf
team.
Getting
ready
for
for
sdf,
1.1
and
astf
is
is
a
new
working
group
that
was
just
formed
based
on
the
observation
that
data
models
for
iot
things
are
very
different
without
a
need
actually
for
this
difference.
I
I
So
we
did
get
a
new
working
group
setup
and
now
we
are
working
on
1.1
and
the
idea
is
that
we
don't
just
update
the
specification
language
in
on
paper,
but
we
actually
try
it
out.
So
this
is
what
this
hackathon
was
about
and
the
idea
was
to
go
through
the
open
issues
that
we
had
on
sdf
1.0
and
write
code.
That
exercises
the
changes
that
are
proposed
and
in
the
process
make
sure
that
the
the
about
200
models,
the
the
sdf
specs-
that
we
have
actually
can
be
updated
along
these
changes.
I
So
we
don't
just
want
to
to
agree
on
a
change
and
then
later
notice.
Oh
this.
This
is
hard
to
implement.
We
want
to
have
them
implemented
before
agreeing
on
them
and
as
as
a
little
side
activity,
we
had
a
look
at
the
jana's
yang
to
sdf
conversion
tool.
Unfortunately,
we
didn't
quite
spend
enough
time
on
that,
but
I
think
at
least
people
got
introduced
to
that
and
we
will
probably
pick
this
up
later
a
bit.
I
I
Now
we
came
up
with
a
convention
on
on
the
usage
of
of
queries
for
those
cross
model
references
and
discussed
how
how
models
transition
their
namespaces
while
they
progress
through
through
the
process
on
the
issue
of
of
aggregation
or
compound
types,
we
actually
found
that
we
can
kind
of
simplify
sdf
1.0
while
while
putting
in
this
aggregation-
and
we
tried
that
out-
and
it
looks
good
now-
we
just
have
to
finish
the
aggregation
discussion
and
we
probably
can
do
this
in
the
working
group
meeting
next
week.
I
So
we
will
still
have
work
to
be
done
today,
so
we
will
meet
in
in
the
afternoon
european
afternoon
today
and
and
try
to
wrap
up
that
work.
I
What
we
learned
we
organized
ourselves
ourselves
into
a
daily
one
hour
meeting
at
a
time
where,
where
most
people
are
awake
and
did
all
the
code,
writing
and
spec
bashing
in
between
those
one-hour
meetings,
so
we
didn't
set
up
additional
conference.
We
just
did
our
homework
and
sent
a
few
mail
messages
and
and
then
met
again
for
this
one
hour
slot.
Our
main
tool,
of
course,
is
git
and
github.
I
I
So
this
is
the
the
team
we
we
had
a
small
team
with
two
ietf
first
timers
and
you
can
find
more
at
1dm.org,
which
is
the
the
sdo
that
kind
of
kicked.
Oh,
it's
not
an
seo
the
liaison
organization
between
sdos
that
kicked
off
this
work
and
our
github
our
working
group
github
repository
where
the
issues
are
that
we
worked
on.
A
Okay,
well,
fantastic
seems
like
as
df
is
off
to
a
great
start.
I
think
so.
A
Nice
to
have
a
hackathon
at
your
your
first,
because
this
is
the
first
ietf
meeting.
I
think
that
that
working
group
and
the
networking
group
just
started
as
you
mentioned,
so
that's
yes,
okay!
Well!
Thank
you!
Carson.
A
G
G
There's
implementations
kicking
around
of
earlier
versions,
but
I
wanted
to
update
at
least
two
to
or
at
least
mine
and
someone
else
to
update
theirs
to
draft
itf
ntp,
roughtime
dash03
rough
time,
if
you're
not
familiar,
essentially
certificate
transparency
for
time,
so
in
applications
where
you
don't
necessarily
have
to
have
the
have
a
good
source
of
time
and
want
value
signatures
designed
to
get
a
close
enough
time
with
high
security
guarantees
to
enable
that
what
got
done
well,
we,
we
didn't,
really
have
a
sort
of
get
together
and
work
work
synchronously
on
it,
but
I
was
able
to
set
up
a
server
on
a
branch
of
cloudflares
right
works,
repository,
stand
it
up
and
jonathan
lindquist
wrote
a
client
and
we
interoperated
successfully.
G
So
that's
a
pretty
good
sign
that
the
draft
is
maturing
and
we
learned
quite
a
bit.
So
I
learned
I
run
freebsd
on
the
server.
I
put
the
thing
on
and
I
learned
that
the
timing
interfaces
that
we
need
because
rough
time
depends
on
my
ethnicity.
You
need
to
know
the
leap
second,
and
this
is
not
supported
in
posix,
so
we
need
an
extension
and
they're
different,
and
so
we
gotta
deal
with
that
issue.
G
Also,
there
was
some
confusion
about
the
modified
julian
date,
plus
my
microsecond.
Since
midnight
representation
we
use
in
rough
since
noon,
no
midnight
one
of
the
two
I'll
look
it
up
that
we
use
it's
somewhat
unusual
as
a
time
format.
Vms
fans
might
be
happier
with
it
and
what's
very
interesting
about
it,
is
none
unique.
A
Next
up,
we
have
bgp
monitoring,
protocol
and
yang
push
and
I've
granted
you
the
screen
great.
We
see
your
video.
A
J
So
I'm
thomas
from
swisscom,
representing
the
bmp
and
young
project,
this
time
on
vmp
we're
working
on
mainly
on
the
path
marking
and
there
are
policy
attribute
tracing
drafts,
how
they
work
together
with
the
vmp
localhip,
but
also
we
had
some
extensions
on
ipfix
to
get
the
bgp
without
distinguish
and
use
that
as
well
for
the
bmp
log
crypt
to
to
ipfix
forwarding
plane
correlation.
J
On
the
push
part
we
we
started
with
with
the
udp
no
differently
distributed,
notif
implementation.
J
So
this
is
basically
a
very
lightweight
way
of
collecting
yang
matrix
from
a
for
from
a
router,
especially
in
with
the
aim
to
directly
expose
the
matrix
from
network
processors
on
online
cart,
with
the
focus
on
on
accounting
data.
A
This
is
the
software
you
advance
slides.
I
don't
know
if
you
are,
I'm
sorry
we're
still
seeing
your
just
the
first
slide
or
something.
J
J
So
now
it
should
work,
so
you
should
see
the
second
page.
Yes,
okay
great,
so
these
were
the
the
bmp
drafts
these
for
the
young
push
part,
and
these
these
are
the
open
source
software
which
we
were
using
for
our
test
environment.
J
J
At
this
time,
we
added
also
other
vendors
into
the
network,
mainly
cisco,
ios
6,
or
tuning
protuners,
and
fr
routing
for
iphix
and
bmp,
and
we
were
working
also
on
the
basically
through
netconf
schema
to
get
the
entire
recursive
schema,
including
the
imports
convert
them
to
due
to
json
and
register
them
into
schema,
rich
history,
and
what
we
learned
from
the
lab
environment
is
that
in
order,
then,
for
the
next
step,
when
we
do
the
the
stress
tests
with
the
big
bmp
to
see
wherever
the
the
back
pressure
mechanism
within
the
bgp
bmp
process
is
working,
we
need
to
increase
our
scale
in
the
data
ingestion
at
the
at
the
time
series
data
database.
J
So
in
order
to
make
sure
that
we
are
able
to,
especially
in
these
high
peaks,
that
we
are
able
to
grab
the
data
within
a
very
short
period
of
time
on
the
data
collection
on
site
decoding
on
our
policy
attribute
testing
continued,
we
were
working
on
path,
marking
and
also
the
iphix
correlation
now
supports.
Also
the
ie19
develop
distinguished
attribute.
J
The
udp
notif
has
been
included
in
pmacc.
Now
it
should
be
without
coming
one
or
two
weeks
being
pushed
to
a
github.
J
This
is
an
example
of
our
policy
attribute
tracing,
so
here
you
can
see
for
on
an
ample
spe
out
of
other
given
in
basically
in
which
vf,
which
count
policy
at
which
attachment
point.
This
prefix
was
traversing.
J
We
were
performing
the
stress
tests
with
with
hundred
thousand
five
hundred
thousand
and
one
million
bgp
vpne
for
unicast
prefixes,
and
here
just
a
some
example.
J
J
On
we're
using
bioshock
the
d
sectors
to
basically
troubleshoot
the
data
collection,
so
thanks
to
alexis
and
uli
who
has
been
working
on
the
implementations
of
the
udp
notif
and
the
bmp
path
marking
the
sectors,
we
were
able
to
use
them
during
our
hackathon
and
we
are
still
currently
working
on
on
that
and
validating
them.
J
What
we've
learned
is
the
it's
our
fourth
hackathon,
so
team
collaboration
is
getting
better
by
the
hackathon
with
good
spirits.
Slack
helped
a
lot
to
to
get
to
keep
connected
through
the
different
time
zones,
but
yet
again,
no
beers
and
cocktails
after
thanks,
wait
and
yeah.
This
time
it
also
some
students
on
board,
from
inside
tom
and
axel
from
swisscom,
marco
and
also
kian
from
seng
thanks
a
lot.
A
Okay,
well
yeah.
Thank
you
for
that.
I
do
miss
many
aspects
of
the
in-person
hackathon,
but
I'm
glad
you're,
you
and
others
are
finding
this
online
format.
You
know
at
least
a
useful
substitute.
A
A
A
Okay,
justin,
if
you're
here
either
unmute
your
your
mic
or
screw
your
machine
share
your
screen
or
raise
your
hand
or
something
otherwise
we're
going
to
move
forward.
I'll.
Just
make
a
note
of
that.
We'll
come
back
to
to
that
one
of
it
and
tom
henderson
yep
great,
we'll
move
on
to.
K
K
Am
I
audible
yes,.
K
Okay,
I'm
tom
henderson,
I'm
with
the
ns3
project,
which
is
a
discrete
event,
network
simulator
and
we've
started
to
participate
in
the
ietf
hackathon.
So
for
the
last
few
sessions,
we've
been
focusing
on
ns3
models
for
the
l4s
architecture,
which
is
being
developed
in
the
transport
area
working
group.
But
for
this
hackathon
we
focused
more
on
a
few
other
tcp
related
models,
including
our
cubic
model,
bbr
v1
and
a
network
testing
tool
known
as
flins
and
in
general.
K
So
on
this
slide,
it
just
notes
a
few
of
the
rfcs
that
that
were
involved
in
in
these
models.
The
specific
things
that
our
team
sought
to
work
on
this
week
was
that
we
were
missing
support
for
easy
and
marking
in
our
cubic
model
and
overall
alignment
with
how
linux
implementation
performs.
In
that
regard,
we
have
a
bb
rv1
model
that
we've
been
working
on.
A
team
of
students
at
nitk.
K
We
did
implements
a
new
states
in
our
tcp
socket
model
that
implements
the
congestion
window
reduced
and
fast
recovery
phase
due
to
ecn
marking
that's
experienced
in
the
network
and
achieved
pretty
good
alignment
with
the
linux
implementation
and
the
url
to
that
all
of
our
code.
Trees
is
listed
on
this
slide.
K
We've
got
good
alignment
with
our
bbr
model,
with
test
bed
results
from
linux,
and
we
made
some
progress
figuring
out.
Some
discrepancies
that
existed
in
our
ns3
flint's
ru
l
test
suite
compared
to
the
what
we
were
observing
on
large
bandwidth
delay
product
links
when
we
used
linux
testbeds
for
a
comparison.
K
Lessons
learned
well,
I
guess
one
of
the
interesting
things
is
that
they're.
In
the
past
week,
the
tcpm
and
iccrg
groups
have
picked
up
some
discussion
on
possibly
revising
cubic
the
rfc
and
that
rfc
actually
is
missing
information
about
how
to
respond
to
ecm
marking.
K
So
that
might
be
a
piece
of
feedback
that
we
could
deliver
to
the
to
the
working
group
and
we'll
try
to
follow
up
on
that
and
then.
Finally,
these
are
the
five
people
who
participated
and
we
had
three
newcomers.
This
time.
A
Okay,
that's
great
yeah!
Thank
you
and,
and
good
luck
with
following
up
within
the
working
group.
I
hope
that
goes
well.
A
Okay,
next
up
paul,
I
guess
you
have
a
couple
presentations,
i2nsf
and
also
ipwave.
L
Hello,
charles,
can
you
hear
me?
Yes,
I
can
okay,
good
okay,
great
hello.
My
name
is
jam
porja
from
skku,
so
this
time,
as
you
can
see
on
my
team,
get
together
in
some
conference
room
and
we're
working
for
on
screen
is.
A
Not
not
yet
we
don't
see
your
screen,
it
says
it
says
it's
being
shared,
but
it
hasn't
popped
up
yet.
A
L
L
Okay,
you
can
see
my
screen
right:
okay,
great
there.
We
go
that
looks
good,
okay,
okay,
great,
so
my
team
is
itunes
framework
project.
My
name
is
jim
porjang
from
skku.
L
This
is
the
poster,
so
we
have
two
professors,
two
researchers
from
actually
and
also
we
have
a
five
student
skku
liberty,
university
in
united
states
and
also
swingshield
university
and
kenya
kang
national
university.
L
So,
basically,
at
this
time
my
our
iconic
working
group
trying
to
extend
the
framework
for
security
management
automation.
So
basically
we
have
itunes
user
for
the
decibel.
The
deliver
high
level
policy
and
also
security
control
translate
the
policy
into
low-level
policy
import
security
services
on
top
of
nato
security
functions,
such
as
the
firewall
represent,
etc.
L
This
time
we
implemented
the
itunes
apple
analyzer
to
monitor
the
activity
of
nsf.
Also,
we
detect
security
attack,
so
we
implemented
a
monitoring
interface
using
last
comp,
and
then
we
collect
monitoring
data
such
as
cpu
ucgs
and
also
disk
ucz,
and
also
traffic
incoming
outgoing
statistics
gathered,
so
either
analyzer
will
analyze
for
that
kind
of
activity.
L
So
we
have
four
interfaces
previously
we
implemented
also.
We
we
showed
the
probe
concept.
Lateration,
consumer
phasing
and
analysis
phase
interfaces.
This
time
we
implemented
the
monitoring
interface
okay,
so
we
implemented
two
draft.
Additionally,
another
monitoring
data
model
also
script
management.
Automation
for
itunes,
f
data
analysis.
So
this
is
the
network
topology.
L
L
In
addition
to
that,
we
implemented
the
nsf
monitoring
interface
to
measure
the
performance
of
cpu
memory
disk
interfaces.
This
is
the
our
component
left
hand
side.
This
one
is
a
web
based
ito,
nsf
user,
specified,
time-based
web
filter
line,
site
security,
controller
and
the
data
developers
management
system
dms.
L
L
Okay,
so
what
we
learned,
we
realized
the
feasibility
of
nsf
monitoring
via
last.com
or
netcom
for
security
management.
Next
time,
we'll
continue
to
support
monitoring
interface
using
netcomp.
L
Also,
we
will
enhance
security
policy,
translator
for
automatic
setting
and
mapping
between
high-level
young
model
and
role-level
young
model,
and
finally,
we
also
implement
a
new
interface
such
as
application
interface
from
analyzer
to
security,
controller,
to
enforce
new
security
policy
or
augmentation
of
skills
policy.
L
Okay,
this
is
open
source
project
guitar.
This
is
a
video
demonstration,
so
this
one
week
my
student
and
other
collaborator
from
archery
and
also
sunshield
university,
congo,
national
university
of
students,
we
gathered
and
we
work
together
and
we
make
it
okay.
Thank
you
for
your
attention.
L
A
I
guess
I
was
muted,
didn't
realize
it:
okay,
yeah!
Thank
you
very
much
so
that
covered
both
no.
L
L
So
this
is
the
poster
for
this
project.
We
have
two
professors
me
and
professor
young
kim
from
sunshield
university,
and
also
we
have
three
universities,
sku
student
and
social
national
associate
university
and
gyeongbo
national
university
student
okay.
L
So
previously
we
demonstrated
the
ipwa
basic
protocols,
itf
106
the
hackathon
project.
Last
year,
in
singapore
we
demonstrated
the
ipv6
packet
transmission
over
to
ogb,
enabled
wi-fi
modules
in
vehicular
networks.
L
L
So
this
hackathon
we
try
to
support
context,
aware
navigation
protocol
over
ip
wave.
This
is,
is
the
draft
so
right
hand
side
you
can
see.
Currently
we
are
trying
to
implement
the
linux.
Okay
extension
for
ipv6
enable
discovery
for
the
robot
ubuntu
linux
corner.
So
this
model
is
iron.
Lover
takes
around
now
right.
Now
we
yeah
it
doesn't
support
the
movement
of
robot,
but
next
month
we
try
to
enable
our
code
on
on
top
of
this
robot,
so
basically
context
aware
navigation
protocol
case
you
can
see.
L
This
is
a
highway
scenario.
Some
beaker
hit
some
obstacle
and
following
vehicle
observed,
and
then
this
v1
detected
this
dangerous
situation
and
disseminate
this
emergency
context.
Message
to
neighbor
speakers,
so
basically
ipwave
contacts,
our
navigation
protocol.
We
using
ipods
enable
discovery,
messages
to
contain
corporation
context,
messaging
and
emergence
context
message
for
driving
condition.
L
So
this
is
the
message
format
for
speaker
or
mobility
information
option
one
of
neighbor
discovery
option
in
I-5006,
so
it
supports
ccm,
ecm,
ecm,
emergency
context,
message
or
corporation
message.
L
So
we
set
up
the
environment
using
two
laptops
having
ubuntu
linux.
Also,
we
use
the
srs
wi-fi
the
module
for
l211
ocd
mode,
okay.
L
So
this
time
we
try
to
implemented
the
level
discovery
for
context,
aware
navigation
protocol,
but
there
was
some
problem
and
issues,
so
we
fixed
some
uncompiling
an
issue,
but
we
tried
to
implement
the
generation
of
vehicle
mobility.
Information
option
also
deliver
and
process
at
visible
site.
So
next
time
hackathon
will
try
to
demonstrate
on
top
of
a
local
car
for
context,
aware
navigator
protocol.
L
So
this
is
the
open
source
project.
We
continue,
making
our
ip
wave
based
context,
aware
navigation
protocol,
so
I
think,
next
month
our
community
can
access
this
website
to
get
our
implementation.
L
So
this
is
our
team
work,
so
in
the
same
way,
we
work
this
week
in
the
conference
room
so
left-hand
side,
the
participants
and
team
members,
and
we
work
together
with
the
itunes,
sf
and
pmw
teams.
Thank
you
for
your
attention.
A
M
M
And
you'll
hear
me
sure:
can
awesome,
let's
see
if
we
can
get
my
screen
to.
M
M
Okay,
pretty
good
three,
all
right
so
hi
everyone,
I'm
paula,
tropsky,
I'm
representing
the
mud
group
here,
so
the
project
we
worked
on
was
titled
mud,
mud
pd
and
such
it'll
make
a
little
more
sense
in
a
second.
M
So
mud
is
the
manufacturer
usage
description,
it's
rfc
8520
and
this
mud
essentially
focuses
on
device
intent,
creating
allow
lists
defining
what
hosts
can
communicate
with
a
device
through
defined
protocols
and
ports.
M
We
also
were
aiming
to
integrate
muddy,
which
is
a
python
command
line
tool
to
help
with
formatting
mod
files.
So
we
want
to
integrate
money
into
mud,
pd
itself
and
we
wanted
to
add
some
updates
to
mud
pd
tool
to
improve
the
usability
from
the
feedback
that
we
would
get.
M
So
what
we
got
done
was
that
we
we
actually
identified
a
bug
with
the
current
mod
file
generation
wizard,
which
is
probably
the
best
place,
to
find
a
bug
since
we're
already
working
to
replace
that
current
mud
file
generation
wizard,
so
we're
actually
replacing
that
with
muddy,
which
is
actually
a
tool
that
was
developed
at
the
ietf
105
hackathon,
based
on
a
tool
that
was
already
it
was
created
before
that.
So
we
also
ended
up
discussing
an
option
field
in
the
pcapng
file
format.
M
This
was
primarily
to
see
if
we
can
provide
machine,
readable,
contextual
information
about
the
mud
file
itself
or
sorry
about
the
packet
capture
itself,
because
right
now
we
had
planned
to
embed
basically
embedding
p
jason
into
the
comment
field.
So
we
were
looking
for
a
more
elegant
solution
than
that,
and
then
we
developed
a
bunch
of
new
code
which
can
be
found
at
the
github
there.
The
usnist.gov
pd
project
there
so
to
wrap
things
up.
M
We
these
for
the
the
members
of
the
team
this
this
hackathon,
we
definitely
kind
of
wish.
We
could
have
been
there,
been
all
together
in
person.
It
definitely
helps
with
having
the
ad-hoc
conversations
and
discussions
and
figuring
out
bugs
just
hands-on
versus
trying
to
remotely
solve
issues.
So
that's
that's
mudpd.
A
Okay!
Well
thanks
for
that,
I'm
glad
you
guys
were
able
to
get
some
stuff
done,
even
if
it
wasn't,
it
wasn't
optimal,
set
up
for.
J
N
Hello,
I'm
young
in
iii,
internet
practice,
term
research
center
in
the
south
korea.
Today
I
will
present
about
the
result
of
the
hackathon
109
about
the
containerizing
infrastructure
benchmarking.
N
So,
basically,
our
goal
is
that
what
kinds
of
resources
are
packed
to
the
containers
networking?
So
we
have
the
one
draft.
You
can
see
the
our
draft
with
this
link
and
the
we
have
the
two
core
of
the
our
draft.
First
one
is
a
hackathon.
The
first
one
is
implementing
real
container
infrastructure
with
the
various
network
models
and
second
one
is
verifying
the
performance
based
on
our
draft.
N
So
last
time
we
also
joined
one
years
ago,
so
we
joined
the
itf
ecosome
106
in
singapore
and
at
that
time
we
tested
that
token
performance
with
the
dpdk
and
the
kante
bpp
so
and
then
the
one
of
the
goal
of
the
that
back,
then,
is
the
figure
out
the
figure
out
the
skill
scheduler,
really
a
pack
to
the
networking
components
or
not.
So
you
can
see
the
result
with
our
threat
and
at
this
time
we
we
also
make
the
test
bed
with
the
slib
and
tpdk
you're.
N
Also
one
of
the
user
space
model,
but
it's
a
pass-through
model
so
base.
According
to
our
draft,
we
mentioned
that
the
huge
page
will
be
attacked
to
the
the
talking
pokemon,
so
we
want
to
figure
out
the
the
relationship
between
a
correlation
between
the
huge
page
with
and
the
networking
performance
with
the
user-based
space-based
model.
N
So
in
this
second
echo
song,
we
set
up
our
test
band
like
this,
so
we
we
use
the
three
server,
the
one
is
for
the
master
and
another
one
is
for
the
local
node
for
the
container
and
the
last
one
is
for
the
the
package
generator.
So
we
use
the
t-rex
generator
to
make
the
packet
and
e4
to
the
vocal
node
and
back
get
back
the
packet
and
and
they
figured
out
the
pokemons
at
the
direct
generator.
N
So
we
followed
this
data
path
and
we
we
modify
the
huge
pages
and
test
their
talking
performance
with
an
sriv
dpdk
networking
architectures.
N
So
in
this
second
song,
we
we
got
this
the
graph.
We
think
that
the
future
page
does
not
affect
to
the
networking
performance,
because,
basically,
when
you
test
it,
we
the
one
of
the
maximum
size
of
the
mtu,
is
a.
N
1518,
so
I
think
is,
is
it's
enough
for
the
huge
pages,
but
we
need
more
testing
to
figure
out
the
relationship
between
the
application
and
the
huge
pages
too,
and
we
also
got
the
many
errors
because
of
the
memory
and
the
future
page
setup,
because
it's
a
little
bit
complicated.
So
it's
not
easy
to
change
it
several
times.
N
So
also
one
of
the
our
reasons
and
the
next
second
song,
we
will
try
to
figure
out
the
the
talking
model,
the
corner-based
networking
models
such
as
ebpf,
and
we
are
so
until
now
we
we
tested
with
the
north
south
traffic,
but
next
time
we
are
trying
to
use
east
western
traffic
pattern
and
the
test
with
the
container
talking
model.
A
O
Okay
cool,
so
what
was
our
plan
plan
was
to
implement
it
the
entity
at
the
station
token,
which
has
now
reached
zero?
Four,
I
wanted
to
check
the
state
of
the
spec
in
terms
of
implementability.
O
What
was
missing
was
what
needs
fixing
etc,
and
the
attack
strategy
was
a
50
50
split
by
attestation
claim
between
me
and
sergey,
so
we
go
in
parallel,
include
and
test,
and
then
we
get
together
to
review
the
code.
We
merge
the
code
and
then
iterate
and
that's
very
convenient,
because
these
are
decision.
Claims
are
basically
pieces
of
cddl
that
you
can
really
implement
in
isolation
and
then
have
an
integration
point
which
is
convenient
at
a
later
point
in
time.
O
What
got
done
is
a
full
implementation
of
the
draft
in
17
prs
and
around
thousand
four
hundred
lines
of
goquot,
including
52
tests
which
are
table
driven,
so
the
the
test
cases
that
are
much
more
than
that
and
implementation
is
on
github
at
the
url
that
you
can
see
there.
Isn't
it
apart
from
cooling
like
that,
we
had
some
design
discussion
around
the
api
ergonomics
for
dealing
with
profiles.
O
That
is
things
that
expand
the
semantics
of
of
of
eat
and
of
the
heat
format,
and
we
started
some
discussion
around
that
and
we.
O
It
in
the
opening
on
github,
so
you
want
to
participate
in
the
discussion
there
you
go.
There
was
no
interrupt
this
time
because
the
other,
the
only
other
implementation
that
we
know
of
it
was
not
around
and
the
demo
is
this
fantastic
screenshot
from
my
laptop,
which
shows
the
test
being
around
the
game
against
the
codebeans
showing
a
fantastic
84.8
coverage.
It's
not
great,
but
anyway,
what
we
learned
is
that
the
draft
in
its
form,
is
actually
implementable
without
too
much
pain.
O
O
O
The
intent
is,
is
to
provide
at
the
station
verification
components
that
one
can
assemble
to
build
a
complete
the
decision
verifier
and
the
verifier
is
one
fundamental
role
in
the
raz
architecture.
O
So,
logically,
we're
starting
from
the
grounds
up
building
the
building
blocks
at
this
time,
and-
and
this
includes
other
standard
standards
and
sdos
apart
from
the
atf,
where
we're
crossing
the
tcg
and
iso
boundaries
here
and
we
started
with
it.
Actually,
we
started
with
crossweed
a
week
ago,
and
that
was
also
a
good
way
to
to
to
provide
feedback
to
the
cosmic
daughters
and
the
second
working
group
and
nothing
if
you're
interested
in
attestation.
O
Please
go
to
the
verizon
page
and
and
look
for
the
presentation
material
there,
and
another
thing
is
that
we
want
to
make
this
first
of
a
series
of
hackathons
to
be
used
as
a
sing
point
for
the
verizon
project.
So,
if
you're
interested
next
time,
you
can
organize
a
bigger
table
and
bring
your
own
ideas
and
whatnot,
I
think
that's
it.
Thank
you
and
sorry
for
before.
A
A
Was
there
is
there
anyone
else
here
on
behalf
of
justin
who
would
be
able
to
present
the
ipv6
iom.
A
A
So
there's
actually
a
draft
that
that
I
put
together
and
michael
already
reviewed
and
gave
me
some
some
comments.
I
didn't
share
it
here
with
the
hackathon
list
after
I
posted,
because
I
didn't
want
to
kind
of
distract
from
people
working
on
their
projects,
but
but
if
you
do
have
some
time
now,
you
know
I'd
appreciate.
A
G
A
A
How
we
can
you
know,
do
a
better
job
with
online
meetings
in
general
and
the
hackathon
being
kind
of
one
example
of
something
that
that
needs
to
be
tailored
to
you
know
perhaps
run
a
little
bit
differently,
as
many
of
you
have
seen
when
it's
in
an
online
format,
but
the
draft
actually
is
meant
to
cover
both
cover
the
hackathon
in
general
and
to
capture
the
things
that
that
barry
and
I
have
in
our
head
from
having
run
the
hackathon
over
a
number
of
years
and
to
get
that
down
on
paper
in
a
draft
to
kind
of
talk
about
aspects
of
the
hackathon
and
how
to
run
them
in
person
and
then
also
online.
A
A
To
the
slide,
so
we
finished
up
with
the
presentations
before
we
leave.
I
do
want
to
say
thanks
again
to
to
icann.
Icann
has
been
a
financial
sponsor
for
the
hackathon.
The
last
several
they've
already
signed
up
to
sponsor
the
next
hackathon
at
ietf.
110
devnet
continues
to
be
a
supporter
of
the
hackathon,
and
you
know
we
still
welcome
additional
sponsors
of
the
hackathon,
so
you
know
the
more
the
merrier
it's.
We
really
appreciate
people
helping
us
keep
this
event
going
and
keeping
it
free
and
open
to
everyone.
A
So
at
ihf
110
we
already
know
it's
going
to
be
an
online
meeting.
We
know
we'll
do
the
hackathon
to
a
large
extent
very
similar
to
what
we
did
this
time
around
using
you
know,
probably
very
similar
tools,
of
course,
we'll
try
to
make
incremental
improvements,
and,
oh
sorry,
justin,
I
see
you
you
just
joined
if
you
want
to
you're,
welcome
to
present.
A
P
P
So
can
you
see
my
slides?
Yes
sure?
Can
sorry,
okay,
thank
you
so
hi
everyone,
our
team,
was
working
on
the
ipv6
iem
project
and
on
the
agenda.
We
wanted
to
improve
the
kernel
implementation
and
actually,
we
already
have
sent
a
patch
up
stream
a
few
months
ago,
and
it
still
needs
a
little
bit
of
work
to
get
accepted.
But
it's
definitely
on
the
right
track.
P
Also,
we
wanted
to
update
the
vpp
implementation
for
ium
because
it
was
based
on
a
very
old
version
of
the
draft,
and
this
task
was
already
a
work
in
progress
before
the
hackathon
and
both
the
kernel
and
vpp
implementations
are
based
on
the
following
draft,
so
the
ium
ipv6
options
and
the
iem
data
and,
of
course,
on
last
version
for
both
of
them,
and
so
after
that
we
wanted
to
test
the
interrupt
between
the
kernel
and
vpp,
and
we
also
wanted
to
implement
a
new
draft
that
could
allow
us
to
insert
and
remove
extension,
headers
and
options
in
flight,
which
is
currently
forbidden
by
the
rfc
8200,
and
we
think
that
it
could
be
valuable
for
iom
and
solve
some
problems.
P
So
what
got
done?
We
had
no
time
to
test
the
interrupt,
and
anyway,
the
vpp
implementation
still
needs
some
work
to
do
so,
all
in
all
implementations,
so
both
for
the
kernel
and
vpp
are
going
well
and
the
implementation
on
the
new
draft
was
up
and
running
and
it
looks
quite
promising,
and
so
here
are
a
few
results
from
the
attribution
option.
This
is
the
new
draft.
P
So
basically
we
have
a
bunch
of
options
here
and
each
options
that
were
inserted
by
a
node
on
the
path
is
linked
to
an
attribution
option,
and
here
we
want
to
remove
this
option,
which
is
at
the
top
of
the
stack.
So
it's
a
load
and
you
can
see
on
the
right
that
this
part
has
been
removed
and
the
padding
and
alignment
is
being
taken
into
account.
P
So
what
we
learn?
Actually
we
have
the
ipv6
encapsulation
solution
which
is
compliant
with
the
rfc8200,
but
it
also
brings
several
problems.
The
first
one
is:
how
do
you
choose
the
destination
address,
so
the
address
of
the
exit
of
the
tunnel
for
iom,
because
you
you
can
configure
it
statically,
but
you
never
know
if
the
routing
changes
or
whatever.
So
it's
hard
to
determine
this
address
easily.
P
Since
you
do
encapsulation,
you
also
have
to
do
an
anonymous
encapsulation
and
that
could
potentially
create
a
security
hole,
because
you
have
to
to
check
that
this
encapsulation
is
something
you
want
and
also
you're,
not
sure
that
the
the
modified
packet
will
take
the
same
pass
as
the
original
one.
So
those
three
reasons
make
it
the
ipv6
encapsulation
solution
hard
to
implement.
P
A
H
A
So
with
that,
I'm
just
going
to
jump
back
to
to
this
kind
of
as
a
bit
of
a
closing
slide,
but
actually
you
know,
for
I
hope
many
of
you
will
will
join
us
for
the
next
hackathon.
There
will
be
some
questions
related
to
the
hackathon
in
the
overall
ietf
109
survey.
That
goes
out.
It'd
be
great.
If
you
could
provide
feedback
there
and
you
know
feedback
as
to
ideas
and
ways
we
can.
A
You
know
what
maybe
didn't
go
as
well,
that
we
can
do
better
for
for
110
or
new
things
for
us
to
try
very
interested
to
hear
that
we
have
some
time
now
if
anyone
has
any
any
thoughts.
A
A
A
Too,
okay
well.
Well,
thank
all
of
you
for
participating
in
the
hackathon
and
and
for
putting
together
the
presentations
and
sharing
them.
I
think
it
would
be
a
very
valuable
and
thanks
to
the
folks
from
the
techo
helping
me
out
along
the
way,
as
we
were
trying
to
get
all
this
working.
A
I
think
it
worked
out
pretty
well
so
yeah
rest
up
over
the
weekend
and
hope
your
ietf
week
goes
very
well
also
thanks
again
everyone
good
night
or
enjoy
the
rest
of
your
day,
depending
on
where
you're
at.