Subject: binary labels

From: "Matt Crawford" <[email-masked]>
Date: Wed, 05 May 1999 14:08:15 -0500

I was hunting for the status of binary labels and found the IESG
push-back on EDNS0, consisting of two points:

> 1. Given that DNS is a "core Internet protocol" and that this is a
> significant change, and the potential impact on the Internet if this 
> thing fails to interoperate, I wonder if this specification should be 
> approved as Experimental (per RFC 2026 section 4.1.1) until there are 
> demonstrated interoperable implementations.  
> 
> And has at least one client implementation of EDNS0 been tested for 
> interoperability with a large number of the deployed DNS servers?
> 
> 
> 2. In section 4.6:
> 
> 
>    VERSION         Indicates the implementation level of whoever sets it.
>                    Full conformance with this specification is indicated by
>                    version ``0.''  Note that both requestors and responders
>                    should set this to the highest level they implement,
>                    that responders should send back RCODE=BADVERS and that
>                    requestors should be prepared to probe using lower
>                    version numbers if they receive an RCODE=BADVERS.
> 
> 
> This doesn't sound right to me.   If the client sets the version number
> on the request to the highest level it implements, and the server 
> implements a higher version number, what's the point in having the
> server return data that the client cannot use?  
> 
> I suggest that this should read:
> 
> Requestors should set VERSION to the highest level they implement.
> Responders should, if possible, respond using the same EDNS
> version as the requestor.   If the responder does not support
> the version used by the requestor, the responder MAY return a
> response with a lower version than supplied by the requestor,
> setting RCODE=BADVERS in the response.  Since this still 
> leaves open the possibility that the responder will return a 
> version not supported by the requestor, a requestor which 
> supports multiple EDNS versions should be prepared to reissue
> the request with a lower version than the responder returned, 
> if the responder returns RCODE=BADVERS.

The second point is easily addressed -- I think the text just needs a
small clarification to make the intent clear to the reader.  I
believe the intent was (or if not, should have been) that a server
supporting a higher version than the client's requested version is to
process the request according to the rules applicable to the client's
version, but fill in the version field to show the client that higher
versions exist.  If the server cannot process the client's lower
version (perhaps it's a really really old client), the server still
shows its highest supported version, but returns RCODE=BADVERS.

The simplest way to express this clearly, I think, would be to change
the cited paragraph to:

   VERSION         Indicates the implementation level of whoever sets it.
                   Full conformance with this specification is indicated by
                   version ``0.''  Note that both requestors and responders
                   should set this to the highest level they implement,
                   that responders must process each request according to
                   the rules associated with the request's VERWSION, or
                   send back RCODE=BADVERS if unable to do so, and that
                   requestors should be prepared to probe using lower
                   version numbers if they receive an RCODE=BADVERS and a
                   responder VERSION lower than that in their request.

But how about the first item?  Are we all demoralized at the
apparent impasse?  The discussion fizzled out just over a month ago,
and then on April 9, Randy wrote

    along the vein of progress, i vaguely think think that edns0 made it
    through the iesg this week.  truth is thomas will remember better than
    i, as he is our ad and i was concentrating on other i-ds.

But as of April 29, EDNS0 is still listed as "under discussion."

				Matt

---

From: Robert Elz <[email-masked]>
Date: Thu, 06 May 1999 15:58:15 +1000

Date:        Wed, 05 May 1999 14:08:15 -0500
    From:        "Matt Crawford" <[email-masked]>
    Message-ID:  <[email-masked]>

  | > I suggest that this should read:

  | The simplest way to express this clearly, I think, would be to change
  | the cited paragraph to:
  | 
  |    VERSION         Indicates the implementation level of whoever sets it.
  |                    Full conformance with this specification is indicated by
  |                    version ``0.''  Note that both requestors and responders
  |                    should set this to the highest level they implement,
  |                    that responders must process each request according to
  |                    the rules associated with the request's VERWSION, or
  |                    send back RCODE=BADVERS if unable to do so, and that
  |                    requestors should be prepared to probe using lower
  |                    version numbers if they receive an RCODE=BADVERS and a
  |                    responder VERSION lower than that in their request.

This wording looks reasonable to me.   If there are no objections, can the
edns0 doc editor please incorporate wording like this and issue a new draft
asap, so we can get done with edns0.

  | But how about the first item?

I believe that the IESG (or the part of it which seemed to take that stand)
have been convinced to drop this, and have understood that edns0 is needed
as a PS soon.   If we can get a new draft with the above wording fix, and
resubmit it to the IESG for ballot, it is likely to be approved.   That the
WG still desires to progress this doc as PS was my very strong impression from
the earlier discussions.

kre

---

From: [email-masked] (Andreas Gustafsson)
Date: Thu, 6 May 1999 12:49:42 +0300 (EEST)

>|                    responder VERSION lower than that in their request.

I find the wording "probe using lower version numbers" confusing.  To
me "probing" sounds like a process where you search for a supported
version by sending multiple requests with decreasing version numbers
until you get RCODE != BADVERS.

Since the reply has a VERSION field, there should be no need to ever
send more than two requests.  The first one may fail with
RCODE=BADVERS, but when sending the second one, the correct version to
use is already known.  Because the second request does not have the
purpose of determining the responder's version, it seems inappropriate
to call it a "probe".

I would prefer this wording:

   " ... and that if requestors receive an RCODE=BADVERS and a
   responder VERSION lower than that in their request, they should
   retry using the responder's version".

-- 
Andreas Gustafsson, [email-masked]