Changeset 9a09212 in mainline

Timestamp:

2017-12-04T20:22:45Z (6 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

82d515e9

Parents:

0fb1755

Message:

Libhttp should not mix error codes and number of bytes transferred.

Location:

uspace

Files:

• app/download/main.c (modified) (1 diff)
• lib/http/include/http/receive-buffer.h (modified) (2 diffs)
• lib/http/src/headers.c (modified) (1 diff)
• lib/http/src/http.c (modified) (1 diff)
• lib/http/src/receive-buffer.c (modified) (8 diffs)
• lib/http/src/response.c (modified) (3 diffs)

uspace/app/download/main.c

@@ -224 +224 @@
                 }
                 
-                int body_size;
-                while ((body_size = recv_buffer(&http->recv_buffer, buf, buf_size)) > 0) {
+                size_t body_size;
+                while ((rc = recv_buffer(&http->recv_buffer, buf, buf_size, &body_size)) == EOK && body_size > 0) {
                         fwrite(buf, 1, body_size, ofile != NULL ? ofile : stdout);
                 }

uspace/lib/http/include/http/receive-buffer.h

@@ -46 +46 @@
  * @param buf buffer to store the data
  * @param buf_size buffer size
- * @return number of bytes received or negative error code
+ * @param nrecv number of bytes actually received
+ * @return EOK on success or error code
  */
-typedef ssize_t (*receive_func_t)(void *, void *, size_t);
+typedef int (*receive_func_t)(void *, void *, size_t, size_t *);
 
 typedef struct {
@@ -81 +82 @@
     receive_buffer_mark_t *, char **);
 extern int recv_char(receive_buffer_t *, char *, bool);
-extern ssize_t recv_buffer(receive_buffer_t *, char *, size_t);
-extern ssize_t recv_discard(receive_buffer_t *, char);
-extern ssize_t recv_discard_str(receive_buffer_t *, const char *);
-extern ssize_t recv_while(receive_buffer_t *, char_class_func_t);
-extern ssize_t recv_eol(receive_buffer_t *);
-extern ssize_t recv_line(receive_buffer_t *, char *, size_t);
+extern int recv_buffer(receive_buffer_t *, char *, size_t, size_t *);
+extern int recv_discard(receive_buffer_t *, char, size_t *);
+extern int recv_discard_str(receive_buffer_t *, const char *, size_t *);
+extern int recv_while(receive_buffer_t *, char_class_func_t);
+extern int recv_eol(receive_buffer_t *, size_t *);
+extern int recv_line(receive_buffer_t *, char *, size_t, size_t *);
 
 #endif

uspace/lib/http/src/headers.c

@@ -146 +146 @@
                         continue;
                 
-                rc = recv_discard(rb, (c == '\r' ? '\n' : '\r'));
-                if (rc < 0)
+                size_t nrecv;
+                rc = recv_discard(rb, (c == '\r' ? '\n' : '\r'), &nrecv);
+                if (rc != EOK)
                         return rc;
                 

uspace/lib/http/src/http.c

@@ -47 +47 @@
 #include <http/receive-buffer.h>
 
-static ssize_t http_receive(void *client_data, void *buf, size_t buf_size)
+static int http_receive(void *client_data, void *buf, size_t buf_size,
+    size_t *nrecv)
 {
         http_t *http = client_data;
-        size_t nrecv;
-        int rc;
 
-        rc = tcp_conn_recv_wait(http->conn, buf, buf_size, &nrecv);
-        if (rc != EOK)
-                return rc;
-
-        return nrecv;
+        return tcp_conn_recv_wait(http->conn, buf, buf_size, nrecv);
 }
 

uspace/lib/http/src/receive-buffer.c

@@ -61 +61 @@
 }
 
-static ssize_t dummy_receive(void *unused, void *buf, size_t buf_size)
-{
-        return 0;
+static int dummy_receive(void *unused, void *buf, size_t buf_size,
+    size_t *nrecv)
+{
+        *nrecv = 0;
+        return EOK;
 }
 
@@ -167 +169 @@
                 }
                 
-                ssize_t rc = rb->receive(rb->client_data, rb->buffer + rb->in, free);
-                if (rc <= 0)
+                size_t nrecv;
+                int rc = rb->receive(rb->client_data, rb->buffer + rb->in, free, &nrecv);
+                if (rc != EOK)
                         return rc;
                 
-                rb->in = rc;
+                rb->in = nrecv;
         }
         
@@ -180 +183 @@
 }
 
-ssize_t recv_buffer(receive_buffer_t *rb, char *buf, size_t buf_size)
-{
-        /* Flush any buffered data*/
+int recv_buffer(receive_buffer_t *rb, char *buf, size_t buf_size,
+    size_t *nrecv)
+{
+        /* Flush any buffered data */
         if (rb->out != rb->in) {
                 size_t size = min(rb->in - rb->out, buf_size);
                 memcpy(buf, rb->buffer + rb->out, size);
                 rb->out += size;
-                return size;
-        }
-        
-        return rb->receive(rb->client_data, buf, buf_size);
+                *nrecv = size;
+                return EOK;
+        }
+        
+        return rb->receive(rb->client_data, buf, buf_size, nrecv);
 }
 
 /** Receive a character and if it is c, discard it from input buffer
- * @return number of characters discarded (0 or 1) or negative error code
- */
-ssize_t recv_discard(receive_buffer_t *rb, char discard)
+ * @param ndisc Place to store number of characters discarded
+ * @return EOK or error code
+ */
+int recv_discard(receive_buffer_t *rb, char discard, size_t *ndisc)
 {
         char c = 0;
@@ -202 +208 @@
         if (rc != EOK)
                 return rc;
-        if (c != discard)
-                return 0;
+        if (c != discard) {
+                *ndisc = 0;
+                return EOK;
+        }
         rc = recv_char(rb, &c, true);
         if (rc != EOK)
                 return rc;
-        return 1;
+        *ndisc = 1;
+        return EOK;
 }
 
 /** Receive a prefix of constant string discard and return number of bytes read
- * @return number of characters discarded or negative error code
- */
-ssize_t recv_discard_str(receive_buffer_t *rb, const char *discard)
+ * @param ndisc Place to store number of characters discarded
+ * @return EOK or error code
+ */
+int recv_discard_str(receive_buffer_t *rb, const char *discard, size_t *ndisc)
 {
         size_t discarded = 0;
         while (*discard) {
-                ssize_t rc = recv_discard(rb, *discard);
-                if (rc < 0)
-                        return rc;
-                if (rc == 0)
+                size_t nd;
+                int rc = recv_discard(rb, *discard, &nd);
+                if (rc != EOK)
+                        return rc;
+                if (nd == 0)
                         break;
-                discarded++;
+                discarded += nd;
                 discard++;
         }
-        return discarded;
-}
-
-ssize_t recv_while(receive_buffer_t *rb, char_class_func_t class)
-{
-        size_t received = 0;
-        
+
+        *ndisc = discarded;
+        return EOK;
+}
+
+int recv_while(receive_buffer_t *rb, char_class_func_t class)
+{
         while (true) {
                 char c = 0;
@@ -244 +255 @@
                 if (rc != EOK)
                         return rc;
-                
-                received++;
-        }
-        
-        return received;
+        }
+        
+        return EOK;
 }
 
 /** Receive an end of line, either CR, LF, CRLF or LFCR
  *
- * @return number of bytes read (0 if no newline is present in the stream)
- *         or negative error code
- */
-ssize_t recv_eol(receive_buffer_t *rb)
+ * @param nrecv Place to store number of bytes received (zero if
+ *              no newline is present in the stream)
+ * @return EOK on success or error code
+ */
+int recv_eol(receive_buffer_t *rb, size_t *nrecv)
 {
         char c = 0;
@@ -263 +273 @@
                 return rc;
         
-        if (c != '\r' && c != '\n')
-                return 0;
+        if (c != '\r' && c != '\n') {
+                *nrecv = 0;
+                return EOK;
+        }
         
         rc = recv_char(rb, &c, true);
@@ -270 +282 @@
                 return rc;
         
-        ssize_t rc2 = recv_discard(rb, (c == '\r' ? '\n' : '\r'));
-        if (rc2 < 0)
-                return rc2;
-        
-        return 1 + rc2;
+        size_t nr;
+        rc = recv_discard(rb, (c == '\r' ? '\n' : '\r'), &nr);
+        if (rc != EOK)
+                return rc;
+        
+        *nrecv = 1 + nr;
+        return EOK;
 }
 
 /* Receive a single line */
-ssize_t recv_line(receive_buffer_t *rb, char *line, size_t size)
+int recv_line(receive_buffer_t *rb, char *line, size_t size, size_t *nrecv)
 {
         size_t written = 0;
+        size_t nr;
         
         while (written < size) {
@@ -288 +303 @@
                         return rc;
                 if (c == '\n') {
-                        recv_discard(rb, '\r');
+                        rc = recv_discard(rb, '\r', &nr);
+                        if (rc != EOK)
+                                return rc;
+
                         line[written++] = 0;
-                        return written;
+                        *nrecv = written;
+                        return EOK;
                 }
                 else if (c == '\r') {
-                        recv_discard(rb, '\n');
+                        rc = recv_discard(rb, '\n', &nr);
+                        if (rc != EOK)
+                                return rc;
                         line[written++] = 0;
-                        return written;
+                        *nrecv = written;
+                        return EOK;
                 }
                 line[written++] = c;

uspace/lib/http/src/response.c

@@ -96 +96 @@
 static int expect(receive_buffer_t *rb, const char *expect)
 {
-        int rc = recv_discard_str(rb, expect);
-        if (rc < 0)
-                return rc;
-        if ((size_t) rc < str_length(expect))
+        size_t ndisc;
+        int rc = recv_discard_str(rb, expect, &ndisc);
+        if (rc != EOK)
+                return rc;
+        if (ndisc < str_length(expect))
                 return HTTP_EPARSE;
         return EOK;
@@ -168 +169 @@
         recv_unmark(rb, &msg_end);
         
-        rc = recv_eol(rb);
-        if (rc == 0)
+        size_t nrecv;
+        rc = recv_eol(rb, &nrecv);
+        if (rc == EOK && nrecv == 0)
                 rc = HTTP_EPARSE;
-        if (rc < 0) {
+        if (rc != EOK) {
                 free(message);
                 return rc;
@@ -204 +206 @@
                 goto error;
         
-        rc = recv_eol(rb);
-        if (rc == 0)
+        size_t nrecv;
+        rc = recv_eol(rb, &nrecv);
+        if (rc == EOK && nrecv == 0)
                 rc = HTTP_EPARSE;
-        if (rc < 0)
+        if (rc != EOK)
                 goto error;