Remove RTR request session vs negotiated session check

I complained about this on sidrops:
https://mailarchive.ietf.org/arch/msg/sidrops/IqvFzvZcSkBN_9gQAwUKAJtIRko/

The hack was too horrid, so I decided to remove it, at least for this
release.

The request session is now only compared to the cache session.
Fort does not care whether the client sustains a constant session.
As long as it's a valid cached session, it's fine. It can ask for many
sessions if it wants.

In practice, all this means is the Corrupt Data is switched for a
Cache Reset.

Whatever. The client will be none the wiser, and the end result will be
the same (a new Cache Request).

diff --git a/src/rtr/pdu_handler.c b/src/rtr/pdu_handler.c
index a02b077a3e74a5f79a30515d4a8f0932f202dc5b..40b3dddb2896f5c60fe9025d5ed61357e4a47e90 100644 (file)
--- a/src/rtr/pdu_handler.c
+++ b/src/rtr/pdu_handler.c
@@ -273,8 +273,6 @@ handle_reset_query_pdu(struct rtr_request *request)
                goto internal_error;
        }
 
-       pdustream_set_session(request->stream, rtr.session);
-
        error = send_cache_response_pdu(stream.fd, stream.ver, rtr.session);
        if (error)
                return error;
@@ -501,7 +499,6 @@ int
 handle_serial_query_pdu(struct rtr_request *request)
 {
        struct rtr_metadata rtr;
-       uint16_t stream_session;
        serial_t oserial, nserial;
        struct rtr_stream stream;
        int error;
@@ -521,13 +518,6 @@ handle_serial_query_pdu(struct rtr_request *request)
        default:     goto internal_error;
        }
 
-       /* Request session vs negotiated session */
-       if (pdustream_get_session(request->stream, &stream_session, rtr.session))
-               if (request->pdu.obj.sq.session_id != stream_session)
-                       return err_pdu_send_corrupt_data(stream.fd, stream.ver,
-                           &request->pdu.raw, "Session ID doesn't match.");
-
-       /* Request session vs existing cache session */
        if (request->pdu.obj.sq.session_id != rtr.session)
                return send_cache_reset_pdu(stream.fd, stream.ver);
 

diff --git a/src/rtr/pdu_stream.c b/src/rtr/pdu_stream.c
index e1b050241ed03749e4bd66f2aacc4df454d1850e..ef6e9b88f11c72537370fc91a03740cb7efab235 100644 (file)
--- a/src/rtr/pdu_stream.c
+++ b/src/rtr/pdu_stream.c
@@ -32,20 +32,6 @@ struct pdu_stream {
        /* buffer's active bytes */
        unsigned char *start;
        unsigned char *end;
-
-       /*
-        * Negotiated session.
-        * We need this mess because the RTR RFCs specify that, if the client
-        * changes the session out of nowhere, we have to respond a Corrupt Data
-        * Error PDU instead of the usual Cache Reset.
-        * The routine that decides the session is the Reset Query handler, but
-        * the PDU stream is the only structure that can remember it, and it
-        * lives in a separate thread.
-        * FML.
-        */
-       pthread_mutex_t session_lock;
-       bool session_set;
-       uint16_t session;
 };
 
 struct pdu_header {
@@ -62,19 +48,12 @@ struct pdu_header {
 struct pdu_stream *pdustream_create(int fd, char const *addr)
 {
        struct pdu_stream *result;
-       int error;
 
        result = pmalloc(sizeof(struct pdu_stream));
        result->fd = fd;
        strcpy(result->addr, addr);
        result->rtr_version = -1;
 
-       error = pthread_mutex_init(&result->session_lock, NULL);
-       if (error)
-               pr_crit("pthread_mutex_init() failed: %s", strerror(error));
-       result->session_set = false;
-       result->session = 0;
-
        result->start = result->buffer;
        result->end = result->buffer;
 
@@ -85,7 +64,6 @@ void
 pdustream_destroy(struct pdu_stream **_stream)
 {
        struct pdu_stream *stream = *_stream;
-       pthread_mutex_destroy(&stream->session_lock);
        close(stream->fd);
        free(stream);
 }
@@ -632,34 +610,6 @@ pdustream_version(struct pdu_stream *stream)
        return stream->rtr_version;
 }
 
-bool
-pdustream_get_session(struct pdu_stream *stream, uint16_t *session, uint16_t proposal)
-{
-       bool set;
-
-       mutex_lock(&stream->session_lock);
-       if (stream->session_set) {
-               set = true;
-               *session = stream->session;
-       } else {
-               set = false;
-               stream->session_set = true;
-               stream->session = proposal;
-       }
-       mutex_unlock(&stream->session_lock);
-
-       return set;
-}
-
-void
-pdustream_set_session(struct pdu_stream *stream, uint16_t session)
-{
-       mutex_lock(&stream->session_lock);
-       stream->session_set = true;
-       stream->session = session;
-       mutex_unlock(&stream->session_lock);
-}
-
 void
 rtreq_destroy(struct rtr_request *request)
 {

diff --git a/src/rtr/pdu_stream.h b/src/rtr/pdu_stream.h
index 1f6b5005b02d7610976b1c4b40757dca6db4a83c..1e7dd84fd1ba82c76cc9fa8e2b91d66022a8d201 100644 (file)
--- a/src/rtr/pdu_stream.h
+++ b/src/rtr/pdu_stream.h
@@ -43,9 +43,6 @@ int pdustream_fd(struct pdu_stream *);
 char const *pdustream_addr(struct pdu_stream *);
 int pdustream_version(struct pdu_stream *);
 
-bool pdustream_get_session(struct pdu_stream *, uint16_t *, uint16_t);
-void pdustream_set_session(struct pdu_stream *, uint16_t);
-
 void rtreq_destroy(struct rtr_request *);
 
 #endif /* SRC_RTR_PDU_STREAM_H_ */