MINOR: h1: make h1_skip_chunk_crlf() not depend on b_ptr() anymore

It now takes offsets relative to the buffer's head. It's up to the
callers to add this offset which corresponds to the buffer's output
size.

diff --git a/include/proto/h1.h b/include/proto/h1.h
index 05d187740919cd5b69fe3e571118b807079c16a3..d8b90cb23db53d315f180c927ed0b38be7a23dd4 100644 (file)
--- a/include/proto/h1.h
+++ b/include/proto/h1.h
@@ -143,16 +143,16 @@ static inline const char *h1_msg_state_str(enum h1_state msg_state)
 /* This function may be called only in HTTP_MSG_CHUNK_CRLF. It reads the CRLF or
  * a possible LF alone at the end of a chunk. The caller should adjust msg->next
  * in order to include this part into the next forwarding phase.  Note that the
- * caller must ensure that ->p points to the first byte to parse.  It returns
- * the number of bytes parsed on success, so the caller can set msg_state to
- * HTTP_MSG_CHUNK_SIZE. If not enough data are available, the function does not
+ * caller must ensure that head+start points to the first byte to parse.  It
+ * returns the number of bytes parsed on success, so the caller can set msg_state
+ * to HTTP_MSG_CHUNK_SIZE. If not enough data are available, the function does not
  * change anything and returns zero. Otherwise it returns a negative value
  * indicating the error positionn relative to <stop>. Note: this function is
  * designed to parse wrapped CRLF at the end of the buffer.
  */
 static inline int h1_skip_chunk_crlf(const struct buffer *buf, int start, int stop)
 {
-       const char *ptr = b_ptr(buf, start);
+       const char *ptr = b_peek(buf, start);
        int bytes = 1;
 
        /* NB: we'll check data availabilty at the end. It's not a
@@ -162,15 +162,15 @@ static inline int h1_skip_chunk_crlf(const struct buffer *buf, int start, int st
        if (*ptr == '\r') {
                bytes++;
                ptr++;
-               if (ptr >= buf->data + buf->size)
+               if (ptr >= b_wrap(buf))
                        ptr = buf->data;
        }
 
        if (bytes > stop - start)
                return 0;
 
-       if (*ptr != '\n')
-               return -buffer_count(buf, ptr, b_ptr(buf, stop));
+       if (*ptr != '\n') // negative position to stop
+               return ptr - __b_peek(buf, stop);
 
        return bytes;
 }

diff --git a/src/mux_h2.c b/src/mux_h2.c
index 33c25d3e8928353e61feaa44d1a9a3b045a59db6..98c97d8bbba6972a03efe21d7656ffe0c63ce556 100644 (file)
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -3179,8 +3179,7 @@ static size_t h2s_frt_make_resp_data(struct h2s *h2s, struct buffer *buf, size_t
                break;
        default:          /* te:chunked : parse chunks */
                if (h1m->state == HTTP_MSG_CHUNK_CRLF) {
-                       // FIXME: this one still uses the old buffer API and ignores <ofs>
-                       ret = h1_skip_chunk_crlf(buf, -max, 0);
+                       ret = h1_skip_chunk_crlf(buf, ofs, ofs + max);
                        if (!ret)
                                goto end;
 

diff --git a/src/proto_http.c b/src/proto_http.c
index 5d7fc988add519477ed0a0a99043552cb4a03761..3904b634a0232c503e9a51f9ad25cb1f0c331eac 100644 (file)
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -6353,7 +6353,7 @@ http_msg_forward_chunked_body(struct stream *s, struct http_msg *msg)
 
                case HTTP_MSG_CHUNK_CRLF:
                        /* we want the CRLF after the data */
-                       ret = h1_skip_chunk_crlf(chn->buf, msg->next, chn->buf->i);
+                       ret = h1_skip_chunk_crlf(chn->buf, co_data(chn) + msg->next, b_data(chn->buf));
                        if (ret == 0)
                                goto missing_data_or_waiting;
                        if (ret < 0) {