►
Description
curl is adding support for Rust components. In this talk, Daniel will explain why and how it will work. We will also find out how this impacts curl and its further usage. Daniel will also share learnings from the journey so far.
About Daniel Stenberg
Daniel Stenberg created curl and was involved in the working groups for HTTP/2 and QUIC (HTTP/3) with the IETF.
Daniel on Twitter: https://twitter.com/bagder
A
Thank
you.
Let's
dive
in,
I
have
a
lot
to
say
so.
Have
won't
bore
you
to
death,
I
hope
so.
Yes,
I'm
I'm
daniel
I've
started
the
car
project.
Actually,
we
are
turning
24
years
old
soon
and
I
started
working
with
http
and
cl
client-side
http
actually
already
before
that.
So
I've
I've
done
my
share
of
http
and
stuff
like
that.
Nowadays
I
work
for
wolf
ssl
and
I
do
curl
support.
A
We're
counting
86
different
operating
systems
that
curl
has
run
on
and,
and
I
think
it's
22
different
cp
architectures,
so
it's
literally
running
everywhere,
thanks
to
it
being
in
c,
and
while
we're
now
talking
about
doing
things
more
components,
parts
back
ends
in
in
rust.
The
c
code
will
remain
a
build
option
for
all
the
different
things
there
and
I'm
going
to
show
you
how
it
works.
A
So
primarily
here
that
we're
talking
about,
and
when
I
talk
about
curl,
I
didn't
really
get
into
it
here,
but
curl.
You
know
most
many
people
see
curl
as
a
command
line
tool
like
you
can
type
curl
and
url
and
he'll
get
the
url
for
you
and
and
through
out
all
the
garbage
in
your
terminal,
but
or
upload
it
or
any
handles
26
different
url
scheme
protocols,
but
primarily
curl
is
the
library
lib
curl
right
and
for
lib
curl.
It
is
very
important
to
do
stuff
in
a
stable
way.
A
A
I
mean
a
stable
api
that
you
we
don't
break,
we
don't
break
the
api
ever
we
haven't
changed
it
for
over
15
years,
at
least,
and
that
means
that
you
can
bring
your
code
actually
the
same
libcard
using
code
to
a
lot
of
different
platforms
and
it
just
works
there
and
if
you've
written
your
code
and
you
bring
it
on
even
when
you
upgrade
lib
curl,
it
will
still
remain
working
exactly
like
it
did
before,
because
we
don't
break
the
api.
We
don't
change
the
behavior
if
you
built
it
with
the
same
stuff.
A
It'll
work
the
same
way
so
basically
the
api
and
the
api.
That's
the
front
there.
I
call
it
armored
here
and
that's
the
front
that
we
don't
tamper
with
right.
We
provide
that
api
and
api,
but
behind
that
we
can
do
whatever
we
want
and
of
course
all
of
this
has
sort
of
the
the
the
stability,
the
availability
and
the
age
of
curl
and
limb.
Curl
has
made
it
into
somewhere
around
10
billion
installations
worldwide.
Today,
maybe
more,
it's
really
hard
to
estimate
accurately.
A
But
of
course
we
have
also
had
our
share
of
vulnerabilities
in
the
project
and
in
lib,
curl
and
estimations,
or
rather
calculations
done
by
me,
says
that
roughly
50
of
the
past
vulnerabilities
have
been
due
to
what
I
call
c
mistakes.
Those
are,
you
know
the
obvious
ones
that
is,
they
are
you
know,
buffer
overflows
or
things
like
new
pointer
mistakes,
stuff
that
are
clearly
things
that
are
related
to
the
c
language.
A
A
Besides
considering
memory
safe
languages,
we
can
do
other
things
to
to
reduce
the
risk
going
forward
and,
of
course,
I
think
my
prediction
of
the
future
is,
of
course,
that
we
are
going
to
do
even
more
we're
going
to
have
more
internet,
more
internet,
connected
devices
and
more
curl
in
those
internet
connected
devices.
So
I
think
we're
only
going
to
grow
in
in
terms
of
usage,
and
you
know
the
risk
vulnerabilities
might
impose
on
us
on
the
future.
A
Okay,
that's
a
little
bit
so
in
curl
and
lib
curl.
We
have
this
concept,
we
call
back
ends
and
backend
is
the
term.
We
use
it's
basically
a
selectable
alternative
implementation
when
we
select
those
backends
at
build
time,
so
you
build
curl
with
a
bunch
of
selectable
alternatives
and
backhands.
Then
you
can
then
select
them
or
you
can
deselect
them
because
you
can
select.
A
Maybe
maybe
I
don't
want
this
particular
support
at
all,
so
I
don't
have
to
have
any
let's
say
ssh
support,
then
I
don't
pick
any
ssh
backend
and
some
of
the
backends
are
platform
dependent,
so
we
can
use
platform-specific
libraries,
for
example.
If
you
run
on
a
particular
operating
system,
we
might
use
that
operating
systems
tls
support.
For
example,
we
can
build
with
s
channel
on
windows
to
use
the,
which
is
the
crypto
ssl
library.
That
windows
provides
that's
only
available
in
windows.
A
So,
on
other
platforms,
we
can
select
that
and
a
lot
of
those
backends
then
use
third-party
libraries
that
are
libraries
that
provide
things
that
that
we
unauthor
right.
So
we
can
actually
today
support
a
lot
of
different
third-party
libraries.
So
when
you
build
curl,
you
select
from
a
plethora
of
different
available
components
and
everything
that
creates
one
lib
curl,
that
you
then
use
and
ship.
So
all
of
these
can
then
differ
in
features,
licensing
and
very
much
in
maturity.
A
Some
of
them
are
very
old.
Some
of
them
are
very
new
and
of
course,
then
these
different
back-ends
or
actually
the
third-party
libraries
behind
them.
Then
it
can
be
done
in
in
any
language.
It
doesn't
matter
to
lib
curl,
really
where
it
doesn't
have
to
matter,
at
least
and
because
we
have
these
layers
and
we
have
the
internal
apis
that
they're
not
exposed
externally.
As
long
as
we
provide
a
stable
api
in
api,
we
can.
A
We
have
the
liberty
and
freedom
to
change
the
internals
right,
so
we
can
swap
out
stuff
internally
replace
it
with
something
else.
As
long
as
we
maintain
the
api
and
abi-
and
that
is
what
we're
trying
to
do
so,
basically
the
opportunity-
what
we're
providing
here
is
this.
If
you
look
at
this
third,
like
I
call
it
the
third
party
world
map
this,
it
says
february,
so
I'm
a
little
ahead
of
my
time,
but
all
the
greens
boxes
here
are
different
third-party
libraries
that
libcurl
can
be
built,
get
built
to
use.
A
They
are
35
different
ones
and
they
mostly
can
select
them
on
and
off.
You
can't
have
all
of
them,
because
some
of
them
are
mutually
exclusive,
but
there's
a
lot
of
them
to
select
and
we
have
then,
as
you
saw
them
different
boxes
so
there.
Where
are
the
many
different
flavors
of
backers?
Basically,
you
can
select
different
backends
for
idn.
That's
international
domain
names.
A
A
But
let
me
show
you
how
it
works,
so
we
I,
this
is
actually
work
sponsored
by
isrg
and
there's
their
prosima
project,
which
is
a
project
that
isrg
is
running
to
provide
more
a
memory,
safe
alternative
for
different
projects.
So
anyway,
this
is
how
the
lib
crawl
system
works.
So
there's
a
library,
api
and
there's
you
know
generic
stuff
for
doing
trans
network
transfers,
since
libcur
can
do
network
networking
using,
as
I
said,
a
lot
of
different
protocols.
A
So
there's
a
lot
of
generic
stuff
for
doing
networking
that
aren't
necessarily
related
to
http,
but
so
there's
you
know
you
have
to
create
and
reuse
connections,
there's
a
transfer
engine
that
basically
handles
data
transfers
up
and
down
and
all
metadata
and
then
well
fiddling
with
protocols
in
different
ways
and
then
there's
specific
implementations
for
specific
protocols.
So
the
http
implementation
is
this
big
green
box,
and
this
is
how
how
it
used
to
work.
A
A
But
you
know
http
is
a
lot
of
things.
Sap
is
a
fairly
complicated
protocol.
I
would
say
fairly
exactly
very
complicated
there's
and
there
are
a
lot
of
different
things
involved
when
doing
http
like
authentication.
You
have
to
create
headers
to
to
in
the
in
request
to
send
there's
a
lot
of
proxy
specific
things.
A
So
there's
a
lot
of
there's
probably
more
than
this,
but
at
least
these,
and
if
we
then
so
when
we
brought
hyper,
which
is
then
the
rust
alternative
here,
brought
hyper
into
the
mix,
let's
support
hyper
as
an
alternative,
an
alternative
hp
implementation
in
curl.
So
let's
do
that.
But
of
course
hyper
is
very
transmission
focused,
so
it
hyper
doesn't
actually
support
everything
we
need
for
http.
A
A
All
of
that
that
all
of
those
things
in
hp
that
hyper
doesn't
support
for
us,
like
authentication
and
proxy
stuff,
and
we
I
made
that
into
a
generic
part
of
lib
curl
hp
code
and
then
split
out
the
different
things
that
hyper
can
do.
So
we
can,
instead
of
using
the
native
code
to
parse
transfer
headers
and
to
handle
the
transmission
we
switch
to
use
the
hyper
code
instead.
So
basically,
that's
the
little
you
know
go
that
way.
Go
that
way.
That's
the
fork
in
the
road
internally.
A
So
when
you
build
curl,
you
can
build
with
hyper
or
you
can
build
with
native
code
and
it
will
go
the
either
other
way
at
run.
Time
done
easy
pc.
So
when
you
want
to
build
curl
with
hyper,
you
just
run
configure
with
a
different
option
and
it'll
use
hyper.
Then,
instead
of
the
native
code,
so
then
that
makes
it
well
make
it
has
the
high
level
exactly
what
I
just
said.
A
This
particular
image
I'll
show
you,
because
it
will
come
back
to
the
extended
version
of
this
because
at
the
same
time
that's
how
we
did
it.
That's
how
I
split
out
the
http
one-
and
I
did
this
mostly
last
year,
this
I'll
get
back
to
the
status
it's
not
completed
yet,
but
there
are
other
rust,
based
components
or
back
ends
in
curl.
Then
russell's
been
one.
A
So
we
support
a
lot
of
different
tls
back-ends
in
curls,
so
you
can
select
which
of
the
different
tls
options
you
want
to
go
with
when
you
build
curl
and
since
well.
I
think
it's
pretty
much
a
year
ago
now
we
can
build
curl
with
russell's
as
well
well
or
as
an
one
alternative,
and
we
do
this,
of
course,
by
russell's
providing
a
c
api
by
their
russell's
ffi
component.
A
So
basically,
I
just
have
to
make
sure
that
and-
and
this
is
how
we
do
all
this
support
right
so
for
the
support
for
all
these
different
rust
components
are
pro-
are
supported
by
the
rust
components,
providing
a
c
api
or
a
c
api
binding
to
their
rust
library.
And
then
in
the
russell's
case,
it's
called
russell's
ffi
and
we
of
course,
already
supported
a
lot
of
different
tls
libraries,
so
adding
support
for
another
one
like
russell's.
A
That
was
actually
fairly
easy,
and
it
was
especially
easy
for
me
because
I
didn't
write
it,
so
it
was
jacob
of
well
he's
one
of
the
head
guys
at
russell's
right,
so
he
he
wrote
most
of
that.
So
it
was
just
adding
support
for
another
tls
library
into
curl.
We
I,
as
a
user
or
as
a
contributor
to
curl,
writing
curl
code
here.
We
don't
really
have
to
care
about
that
being
russell's.
A
Well,
sorry,
that
being
rust
in
in
the
back
or
or
somewhere
along
the
way,
because
all
we
see
when
we
write
called,
we
see
the
c
api,
so
we
interface
with
that.
So
for
us
it
looks
exactly
like
any
other
library,
a
third
rust
written
library
that
we
support
is
quiche,
maybe
not
as
familiar
to
everyone.
A
Quiche
is
http
3
and
quick
library,
and
yes,
we
support
multiple
http,
3
and
quick
libraries
as
well,
so
you
can
select
which
backend
to
use
when
you
build
curl
and-
and
in
this
case
we're
actually
even
more
sort
of
complicated
here,
because
they're
all
experimental,
because
quick
and
http
3
are
all
experimentally
supported
in
curls.
You
actually
they're,
never
enabled
by
default.
A
A
We
currently
interfaces
that
c
api
and
that,
in
turn
then
uses
that
library
written
in
rust
and,
as
I
said,
we
call
already
built
and
support
different,
quick
libraries,
so
we
just
made
sure
that
we
could
interface,
this
particular
library
as
well.
This
was
actually
the
first
quick
library
curl
supported,
and
then
you
have
to
enable
it
at
build
time
and
then
it
just
works.
A
So
this
makes
it
work
like
this.
So
here
here
we're
back
to
this
image.
I
wanted
to
show
you
about
libkar
backhands,
because
you
know
I
told
you
about.
We
have
seven
different
flavors
if
you
will
of
back
ends,
so
all
of
those
are
hidden
behind
the
internal
api.
So
if
again
here,
if
you're
the
application
in
in
the
upper
yellow
cloud
here,
that's
the
application
using
the
library,
and
so
the
library
provides
that
public
api
the
stable
api
that
we
don't
change
the
api.
Is
there
forever?
So
that's!
A
That's
rock
solid
right,
but
all
these
little
orange
boxes
here
they
are
providing
an
internal
api
and
we
can
change
that
api
doesn't
have
to
be
stable,
it's
not
so
we
can
sort
of.
We
can
play
around
with
it
as
much
as
we
want
and
change
it
and
advance
it
and
grow
it
when
we
want
to.
But
behind
those
orange
boxes
are
different
in
many
cases,
different
third-party
libraries
that
then
actually
provide
the
the
real
power
and
those
can
very
well
be
written
in
rust.
A
Of
course,
and
then
you
see
there
are
a
lot
of
different
things,
but
we
can
just
look
at
this,
so
these
three
different
sort
of
exits.
Then,
if
we
look
at
the
left,
that's
the
http
3
api
and
we
have
on
the
top
right.
That's
the
http
api
and
under
that
that's
the
tls
api.
So
there
are
different
rust
alternatives
for
those
three,
which
then
of
course
implies
that
there
are
no
rust
alternatives
for
those
other
four
backend
options.
A
But
but
of
course
this
is
all
based
on.
You
know,
history
and
availability
and
what
people
have
done
and
not
done,
of
course,
and
maturity.
A
lot
of
these
are
are
old
things
that
have
just
been
around
since
forever.
So
I
guess
there
haven't
been
a
real
option
or
or
opportunity
for
anyone
to
provide
rust
alternatives
for
those.
A
So
that
is
how
we
are
getting
rust
components
into
this
very
old
project.
That
is
on
a
lot
of
places,
but
of
course
getting
all
this
working
hasn't
been
well,
it
has
actually,
it
hasn't,
been
very
complicated
sort
of
from
the
greater
point
of
view,
but
but
I
have
there
are
and
have
been
some
challenges,
and
maybe
maybe
some
other
I'm
I'm
talking
about
three
different
backends
here,
all
written
and
russ.
A
So
I've
split
it
out
here
on
and
I
want
to
talk
about
specific
back-ends,
of
course,
one
of
the
challenges,
of
course,
being
the
first
user
of
something
like
the
hip
hype.
Actually,
when
I
contacted
the
hyper
guys
and
sean
macarthur,
then
in
particular
I
asked
them
wow
house
how's
your
c
api.
How
can
I
use
your
library
and
he
said
well,
we
will
make
one
for
you,
so
I
I
I
don't
know
if
I'm
still
the
only
user
of
it.
I
I
really
hope.
A
A
It
means
that
well,
I'm
early
and
the
api
certainly
didn't
have
everything
that
we
wanted,
and
I
had
to
sort
of
ask
for
things
and
it
was
a
fairly
complicated
story
to
actually
figure
out
how
it
works,
because
yeah
heather's
only
no
c
documentation
so
reading
the
headers
trying
to
understand
how
the
api
is
working.
That
was
actually
pretty
complicated.
It's
still
pretty
complicated.
A
If
you
want
to
use
this
api
because
it's
from
from
an
old
I
mean
you
know,
as
I
implied
with
what
I've
said
already-
I'm
an
old
c
user
api
user
since
decades
and
I'm
sort
of
accustomed
and
used
to
how
to
do
things
and
how
to
access
apis,
and
I
think,
rust,
sort
of
encourages
a
way
of
thinking
on
a
way
of
doing
things.
That
sort
of
makes
the
api
maybe
not
appear
in
a
sort
of
how
we
are
used
to
have
apis
for
c
programs
and
c
libraries.
A
So
it's
a
little
bit
of
an
unusual
thing,
I'm
not
sure
if
that's
rust
or
hyper,
but
anyway,
this
api
at
least
surprised
me.
In
my
in
my
in
many
ways,
I
had
to
sort
of
learn
how
it
actually
works
and
it
took
some
serious
getting
used
to
from
my
point
of
view
so
yeah
and
splitting
that
http,
as
I
said,
talked
about
before
splitting
up
http
in
an
upper
layer
and
a
low
layer.
A
I
hadn't
really
had
that
in
my
mind
before
so
it
took
some
thinking
and
there
are
also
some
still
some
challenges
in
in
hyper
not
doing
and
considering
http
the
same
way
as
sleep
girl
native
does,
but
we're
getting
there
right
and
and
it's
it's
a
journey
to
make
sure
that
you
know
carl
has
is
an
old
beast.
It
will.
It
has
its
ways
and
it's
been
doing
things
just
because
we
did
it
that
way.
Back
in
the
day.
I
can't
even
remember
why
we
did
some
of
those.
A
A
I
could
say
that
when
we
have
these
number
of
layers
of
different
systems
in
place
and
in
particular
when
we
have
for
me
as
a
total
rookie
and
I'm
sitting
here
at
the
rust
presentation
right,
but
I'm
not
a
rust
guy-
I
don't
know
rust
at
all.
I've
sort
of
I
can
maybe
read
some
of
it,
but
most
of
it
it
just
flies
over
my
head.
So
I'm
not
a
ros
guys
and
when
it
comes
to
memory
leaks
and
this
unusual
api.
A
But
but
the
fact
that
is
in
the
end,
that
the
fact
that
it
is
rust
in
the
back
there.
It's
mostly
seamless
and
we
usually
don't
have
to
care
as
long
as
sort
of
everything
works,
and
I
mean
that's
the
post,
that's
how
it's
supposed
to
be
and
then
hitting
and
going
forward
then
into
russell's
being
another
separate,
rust
component
and
of
course,
all
of
these
different
back-ends
and
components.
You
can
select
them
they're
sort
of
individually
selected.
A
So
you
can
select
a
build
curl
with
all
of
these
three
different
rust
components
at
once,
or
just
one
or
two,
and
that
was
also
a
problem
in
the
beginning
too,
because
there
were
some
global
symbols
that
collided,
but
anyway,
we're
still
again
here
we're
early
users
of
the
russell's
ffi,
which
is
the
c.
Then
the
c
front,
end
to
russell's
and
again
being
an
early
user
is
difficult
because
recognize
the
pattern
here,
headers
only
in
those
c
docs,
so
figuring
out
exactly
how
this
works
is
not
exactly
straightforward.
A
All
the
time
so
yeah
I
can
read
the
rust
documentation
but
mapping
the
rast
documentation
to
the
c
world
is
not
always
you
know
straightforward,
but
in
this
case
not
this
work
was
mostly
done
by
others.
So
this
was
certainly
easier
for
me
because
I
didn't
do
most
of
this
work.
It
was
mostly
done
by
jacob
and
others
so
easier
and
the
tls
back-end
situation
in
curl
was
already
mature.
Actually,
at
this
time
we
already
supported
13
different
tls
back-ends,
so
this
became
the
14th.
A
So
it
was
mostly
you
know,
adding
another
one
in
an
already
very
established
way,
how
to
add,
tls
back
and
so
straightforward
could
hook
it
in
into
the
test
suite.
We
could
go
and
get
it
going
very
quickly,
but
this
I
didn't
say
that
well,
the
the
the
russell's
is
not
yet
feature
complete,
not
the
back
and
in
curl,
and
I'm
and
I'll
get
back
to
some
detail,
while
russell's
isn't
feature
complete
in
the
library
either
and
always
then
the
third
rust
component
teach
and
again
early
user
quiche.
A
I
don't
know
if
we're
the
only
if
we
were
the
first
user
of
the
library
outside
of
this
is
done
by
cloudflare
by
alessandro
and
lucas
there
and
this
familiar
pattern.
You
know
headers
only
no
c
code,
so
sorry,
no
c
documentation,
so
a
little
bit
hard
to
understand
how
to
use
it.
Sometimes,
and
adding
adding
in
this
world,
we
have
a
message
that
situation
and
this
is
this-
isn't
really
default
or
quiche.
A
This
is
the
photo
quick
in
general
because
quick,
let's
not
get
into
that,
but
you
cannot
use
any
partic,
just
any
tls
library
for
this.
So
there's
a
special
situation
for
tls
when
using
quick
and
that,
of
course,
sort
of
taints
quiche
a
little
bit
or
the
situation
with
keys
to
build
with
keys
and
stuff
like
that
and
kish
also
is
not
and
or
has
not
been
feature
complete.
So
it
like
all
these
other
three,
it's
a
it's
a
back
and
forth.
A
You
know
implementing
supporting
curl,
going
back
to
the
developers
of
the
project,
submitting
features,
submitting
issues
and
sort
of
back
and
forth
to
hand
in
hand
go
forward
to
make
sure
that
they
provide
the
features
we
need
to
do
the
things
so
that
we
can
provide
everything
in
curl
exactly
so
then
using
rust
in
general.
Of
course,
it's
it's
a
it's
a
for
me.
It's
sort
of
a
wake-up
call.
A
Oh
sorry,
I
have
to
do
rust
up,
update
and
cargo
update
all
the
time
and
I
have
to,
but
I
have
to
say
that
it's
really
a
suitable
language.
It
works
really
great
for
for
in
for
this,
in
this
case,
to
just
replace
the
components
one
by
one
or
or
provide
alternatives,
provide
alternative
components,
one
by
one
in
a
project
like
curl,
even
if
it
has
existed
since
forever.
We
can.
This
is
a
pretty
smooth
ride
actually
or
as
smooth
as
you
can
get.
A
I
guess,
even
if
there
are
some
bumps
along
the
road,
but
the
bumps
I
mean
no
matter
what,
when
in
in,
even
if
they,
these
components
have
been
written
in
other
languages,
there
would
have
been
bumps
and
there
haven't
been
any
larger
or
com
really
complicated
things.
And,
of
course
the
parts
of
it
is
because
I'm
personally,
I'm
I'm
leading
the
current
project
and
I'm
a
total
rust
rookie.
A
A
This
is
experimental,
just
consider
that
when
you
go
forward
and
it
it
handles
http
one,
and
it
should
be
two
really
nice,
and
if
you
do
this,
if
you
enable
it
in
your
build
and
you
run
curl
with
it
as
a
back
end,
you
mostly
won't
notice
it
it'll,
just
transparently
work,
exactly
like
curl
does
and
leap.
Curl
does
as
well
for
a
lot
of
features
like
even
for
atp
and
https
proxies,
and
the
hp
requests
are
identical,
so
you
won't
spot
it
even
if
you're
watching
it
over
the
wire.
A
A
Where
I
think
well,
then
I
said:
there's
roughly
800
test
cases
for
http.
I
think
there
are
a
little
bit
more.
I
think.
Right
now
we
have
24
test
cases
that
are
disabled
when
hyper
is
used
and
all
of
those
24
are
subject
for
you
know
addressing
one
by
one:
it's
a
bit
of
a
work.
It'll.
Take
some
time
but
we're
slowly
getting
there.
A
So
russell's
done
it's
also
experimental,
not
in
but
less
experimental
and
more
opt-in,
but
so,
since
that's
a
tls
backend
and
for
tls
back-ends
people
have
always
well
since
a
very
long
time
been
able
to
select
tls
back
as
a
build
time.
So
here
you
just
have
to
at
will
select
the
russell's
to
build
with
when
you
build
curl.
So
it's
a
an
opt-in.
You
have
to
make
that
decision
and
for
russell's
we
have.
Then
it's
actually
12
test
cases
which
is
half
of
the
24
in
hyper.
A
So
it's
even
closer
to
feature
perfect.
There
are
some
things,
not
I
don't
remember
right
now,
but
there
are
some
things
that
isn't
really
implemented
in
russell's.
Yet
I
think
it's
related
to
some
connection
thing
which
makes
some,
for
example,
ftp
tls
doesn't
work
at
all
right
and
then
there's
this
feature
thing
in
russell's
that
doesn't
work
yet
so
they
can't
verify
iep
addresses
in
server
certification
search
server
certificates.
I
believe
I
still,
I
think,
that's
still
the
case.
A
It
can't
verify
that,
if
I,
I
think
so,
I
think
that's
okay
and
for
quiche,
that's
also
experimental
and
obtained
and,
as
I
said,
for
cash,
we
have
this
tls
case.
Tell
us
mass
or
problem
so
it'll
take
a
while
until
we
have,
we
will
enable
http
3
by
default
anyway
in
curl,
and
we
don't
have
an
hp3
tests
yet
in
curl
either,
partly
because
of
this
tls
situation
and
well,
quick
in
http
3
are
still
early
in
general
and
in
the
ecosystem
of
http
and
open
source.
A
It's
still
in
a
little
bit
shaky
ground,
so
we
have.
I
think
we
have
more
time
before
we
sort
of
feel
that
we
have
to
be
there,
so
in
general,
about
rust,
it
works
really.
Well.
You
can
enable
all
these
three
components
today
and
go
with
it
and
you
probably
won't
spot
any
problems
with
it
and,
of
course
this
depends
entirely
on
the
c
apis.
A
A
One
thing
in
rust,
of
course,
is
that
you
can
still
not
get
it
to
handle
out
of
memory
errors
in
a
fine
way.
I
say
fine,
because
panic
is
not
the
fine
way
to
download
you
know
if
you,
if
you
provide
a
library
for
an
application,
the
the
library
should
never
panic
or
abort,
because
that's
not
the
decision
for
the
library,
the
application
that
uses
the
library
should
select
if
it
should
abort
or
not,
the
library
should
return
an
error.
A
A
It
should
never
panic
and
in
rust
right
now,
you
can
still
not
prevent
it
from
panicking
when
it
runs
out
of
memory,
which
I
think
users
of
libraries
for
some
at
least
in
many
situations,
will
not
appreciate,
and
of
course,
you
can
help
to
make
this
better,
because
this
is
the
state
right
now
the
status.
We
always
need
more
help
in
the
current
project
and,
as
you
can
see
here,
there
are
rust
and
there
are
c
apis
to
those
rust
libraries
to
to
work
on
and
there's
adaptions
in
curl
than
to
use
these
libraries.
A
So
there's
there's
a
lot
of
different
areas
that
you
know
you
can
just
join
in
and
help
them.
You
will
be
appreciated
in
in
any
of
those
areas.
I
I
guarantee
you
so
coming
up
next,
then
in
curl
and
rust
first,
of
course,
short
term,
hopefully
short
term,
I
don't
know
really
to
make
sure
all
test
cases
succeed.
A
So
there
are
well
maybe
36
test
cases
to
fix
them.
I
think
some
of
them
will
be
problematic.
Some
of
them
will
be
easy.
So,
in
the
ideal
case
it
we
will
work
on
this
and
it
will
be
we
we
can
get
there
in
a
month
or
two
or
three
or
who
knows
it
depends
a
little
bit
how
much
time
we
an
effort
we
can
spend
on
it
and
then
verify
a
few
of
the
leap.
A
Curl
api
corner
cases
that
we
still
maybe
not
haven't
really
settled,
but
otherwise,
otherwise
we
are
already
there
and
then
or
already
now.
Maybe
we
can
encourage
users
and
developers
to
actually
use
these
rust
back-ends.
You
know
to
exercise
those
and
to
really
try
them
out
in
in
the
real
world
and
see
what
we
have
missed
or
forgotten,
because
I
have
this
experience
when
I
say
things
are
experimental
in
curl,
people
tend
to
not
really
use
it,
so
yeah
they're
really
experimental,
because
nobody
has
used
them.
A
Possibly
I
will
start
providing
some
binary
bills
for
this,
to
sort
of
ease
that
testing
and
experimenting,
but,
but
also
it's
also
a
tough
job
to
provide
binary
builds,
and
we
have
so
many
different
platforms
that
we
support,
and
hopefully
someone
else
than
me
will
help
out
and
provide
binary
bills.
You
know
maybe
docker
images,
so
I
get
this
question
then
for
someone
when
will
someone
at
when
or
will
someone
enable
these
back-ends
by
default?
A
For
example,
there
could
be
linux
distributions
operating
systems
that
then
select
or
decide
to
use
these
rust
back-ends
by
default
instead
of
the
other
back-ends
and
when
they
build
that
ship
curl
for
their
operating
systems
or
platforms
or
whatever,
and
I
don't
have
any
real
insight
into
how
the
thinking
is
going
there
or
if
anyone
is
actually
thinking
or
planning
about
that
yet.
But
I
think
once
we
have
come
to
that
level
of
everything
being
you
know
not
experimental
anymore.
All
the
test
cases
are
going
through
and
everything
is
green.
A
Distributions,
for
example,
if
they
want
to-
I
don't
I
don't-
I
provide
all
the
options
they
have
to
make
the
decisions
and
going
forward.
There
could
be
more
rust
components.
I've
talked
to
isrg
about
that
as
well
and
made
some
proposals,
so
maybe
we'll
we'll
see
what
happens
down
the
road,
but,
of
course
this.
This
is
a
this
is
open
for
everyone
or
anyone.
A
If
I
showed
you
that
sort
of
how
we
do
different
back-ends
in
curl
and
a
lot
of
those
can
be
done
in
rust
instead
and
the
effect
of
that,
then
being
that
the
final
binary
that
actually
runs
a
lot
of
networking
stuff
would
be
more
rust
and
then
more
memory,
safe,
less
c
code
based
stuff
in
executing,
which
ideally
hopefully
probably
makes
things
a
little
bit
better
and
maybe
a
little
less
vulnerable
going
forward.
So
yeah,
more
backend
flavors
that
mean
we.
We
could
also
introduce
new
things
right.
A
A
So
there's
really
nothing
in
the
way
we
just
march
on-
and
you
know,
we've
been
doing
this
for
a
while,
and
we
can
continue
doing
this
for
as
long
as
we
want
we
just
mod
on.
We
keep
the
api
and
api
and
we
just
get
more
call
going
forward
with
your
help,
of
course,
with
everyone's
help.
This
is
fun
and
I
think
that's
about
what
I
wanted
to
say
today.
I
hope
you
haven't
all
fallen
asleep
and
I'm
ready
for
some
questions.