src/server/util/io.c

Tue, 12 Sep 2023 18:08:11 +0200

author
Olaf Wintermann <olaf.wintermann@gmail.com>
date
Tue, 12 Sep 2023 18:08:11 +0200
changeset 511
a5a142fea2ae
parent 502
11ac3761c0e3
child 513
9a49c245a49c
permissions
-rw-r--r--

update uwproj

1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
1 /*
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
3 *
44
3da1f7b6847f added some error messages
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 41
diff changeset
4 * Copyright 2013 Olaf Wintermann. All rights reserved.
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
5 *
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
6 * Redistribution and use in source and binary forms, with or without
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
7 * modification, are permitted provided that the following conditions are met:
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
8 *
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
9 * 1. Redistributions of source code must retain the above copyright
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
10 * notice, this list of conditions and the following disclaimer.
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
11 *
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
12 * 2. Redistributions in binary form must reproduce the above copyright
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
13 * notice, this list of conditions and the following disclaimer in the
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
14 * documentation and/or other materials provided with the distribution.
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
15 *
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
26 * POSSIBILITY OF SUCH DAMAGE.
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
27 */
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
28
41
bb7a1f5a8b48 added Linux support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 32
diff changeset
29 #ifdef __gnu_linux__
bb7a1f5a8b48 added Linux support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 32
diff changeset
30 #define _GNU_SOURCE
bb7a1f5a8b48 added Linux support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 32
diff changeset
31 #endif
bb7a1f5a8b48 added Linux support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 32
diff changeset
32
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
33 #include <unistd.h>
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
34 #include <stdlib.h>
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
35
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
36 #ifdef XP_UNIX
4
998844b5ed25 Added some protocol functions
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 1
diff changeset
37 #include <sys/uio.h>
69
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
38 #include <sys/uio.h>
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
39 #endif
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
40
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
41 #ifdef XP_WIN32
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
42
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
43 #endif
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
44
126
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
45 #if defined(LINUX) || defined(SOLARIS)
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
46 #include <sys/sendfile.h>
126
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
47 #define WS_SENDFILE
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
48 #elif defined(BSD)
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
49 #if defined(__NetBSD__) || defined(__OpenBSD__)
112
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 110 111
diff changeset
50 #define net_sys_sendfile net_fallback_sendfile
126
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
51 #else
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
52 #define WS_SENDFILE
69
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
53 #endif
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
54 #endif
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
55
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
56 #ifdef WS_SENDFILE
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
57 #define NET_SYS_SENDFILE net_sys_sendfile
126
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
58 #else
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
59 #define NET_SYS_SENDFILE net_fallback_sendfile
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
60 #endif
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
61
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
62
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
63
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
64 #include "../daemon/vfs.h"
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
65 #include "io.h"
4
998844b5ed25 Added some protocol functions
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 1
diff changeset
66 #include "pool.h"
171
af7e2d80dee6 adds wrapper for close syscall with error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
67 #include "../daemon/netsite.h"
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
68 #include "../daemon/event.h"
415
d938228c382e switch from ucx 2 to 3
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 407
diff changeset
69 #include "cx/utils.h"
d938228c382e switch from ucx 2 to 3
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 407
diff changeset
70 #include <cx/printf.h>
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
71
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
72 IOStream native_io_funcs = {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
73 (io_write_f)net_sys_write,
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
74 (io_writev_f)net_sys_writev,
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
75 (io_read_f)net_sys_read,
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
76 (io_sendfile_f)NET_SYS_SENDFILE,
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
77 (io_close_f)net_sys_close,
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
78 NULL,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
79 (io_setmode_f)net_sys_setmode,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
80 (io_poll_f)net_sys_poll,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
81 0
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
82 };
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
83
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
84 IOStream http_io_funcs = {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
85 (io_write_f)net_http_write,
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
86 (io_writev_f)net_http_writev,
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
87 (io_read_f)net_http_read,
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
88 (io_sendfile_f)net_http_sendfile,
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
89 (io_close_f)net_http_close,
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
90 (io_finish_f)net_http_finish,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
91 (io_setmode_f)net_http_setmode,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
92 (io_poll_f)net_http_poll,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
93 0
8
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
94 };
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
95
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
96 IOStream ssl_io_funcs = {
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
97 (io_write_f)net_ssl_write,
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
98 (io_writev_f)net_ssl_writev,
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
99 (io_read_f)net_ssl_read,
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
100 NULL,
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
101 (io_close_f)net_ssl_close,
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
102 (io_finish_f)net_ssl_finish,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
103 (io_setmode_f)net_ssl_setmode,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
104 (io_poll_f)net_ssl_poll,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
105 0
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
106 };
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
107
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
108
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
109 /*
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
110 * Sysstream implementation
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
111 */
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
112
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
113 IOStream* Sysstream_new(pool_handle_t *pool, SYS_SOCKET fd) {
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
114 Sysstream *st = pool_malloc(pool, sizeof(Sysstream));
1
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
115 st->st = native_io_funcs;
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
116 st->fd = fd;
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
117 return (IOStream*)st;
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
118 }
3c066d52342d added source
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
diff changeset
119
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
120 #ifdef XP_UNIX
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
121 ssize_t net_sys_write(Sysstream *st, const void *buf, size_t nbytes) {
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
122 ssize_t r = write(st->fd, buf, nbytes);
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
123 st->st.io_errno = errno;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
124 return r;
8
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
125 }
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
126
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
127 ssize_t net_sys_writev(Sysstream *st, struct iovec *iovec, int iovcnt) {
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
128 ssize_t r = writev(st->fd, iovec, iovcnt);
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
129 st->st.io_errno = errno;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
130 return r;
64
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
131 }
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
132
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
133 ssize_t net_sys_read(Sysstream *st, void *buf, size_t nbytes) {
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
134 ssize_t r = read(st->fd, buf, nbytes);
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
135 st->st.io_errno = errno;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
136 return r;
8
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
137 }
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
138
126
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
139 #ifdef WS_SENDFILE
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
140 ssize_t net_sys_sendfile(Sysstream *st, sendfiledata *sfd) {
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
141 ssize_t ret = 0;
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
142 off_t fileoffset = sfd->offset;
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
143 if(sfd->fd->fd != -1) {
71
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
144 #ifdef BSD
69
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
145 struct iovec hdvec;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
146 hdvec.iov_base = (void*)sfd->header;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
147 hdvec.iov_len = sfd->hlen;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
148 struct iovec trvec;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
149 trvec.iov_base = (void*)sfd->trailer;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
150 trvec.iov_len = sfd->tlen;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
151 struct sf_hdtr hdtr;
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
152 hdtr.headers = &hdvec;
493
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
153 hdtr.hdr_cnt = sfd->hlen > 0 ? 1 : 0;
69
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
154 hdtr.trailers = &trvec;
493
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
155 hdtr.trl_cnt = sfd->tlen > 0 ? 1 : 0;
69
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
156
70
4e6e812c1d97 fixed some warnings
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 69
diff changeset
157 off_t len = sfd->len;
71
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
158 #ifdef OSX
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
159 ret = sendfile(sfd->fd->fd, st->fd, fileoffset, &len, &hdtr, 0);
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
160 #else // BSD
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
161 ret = sendfile(
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
162 sfd->fd->fd,
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
163 st->fd,
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
164 fileoffset,
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
165 sfd->len,
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
166 &hdtr,
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
167 NULL,
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
168 0);
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
169 #endif
493
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
170 if(ret == 0) {
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
171 ret = sfd->hlen + sfd->tlen + sfd->len;
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
172 }
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
173
71
069c152f6272 ucx update
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 70
diff changeset
174 #else // Solaris/Linux
104
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
175 if(sfd->header) {
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
176 ret += write(st->fd, sfd->header, sfd->hlen);
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
177 }
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
178 ret += sendfile(st->fd, sfd->fd->fd, &fileoffset, sfd->len);
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
179 if(sfd->trailer) {
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
180 ret += write(st->fd, sfd->trailer, sfd->tlen);
a8acbb12f27c implemented range requests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 82
diff changeset
181 }
69
4a10bc0ee80d compiles on os x
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 66
diff changeset
182 #endif
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
183 } else {
126
631aaa01b2b5 fixes chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 112
diff changeset
184 return net_fallback_sendfile((IOStream*)st, sfd);
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
185 }
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
186 st->st.io_errno = errno;
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
187 return ret;
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
188 }
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
189 #endif
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
190
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
191 void net_sys_close(Sysstream *st) {
171
af7e2d80dee6 adds wrapper for close syscall with error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
192 system_close(st->fd);
80
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
193 }
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
194
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
195 void net_sys_setmode(Sysstream *st, int mode) {
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
196 int flags;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
197 if (-1 == (flags = fcntl(st->fd, F_GETFL, 0))) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
198 flags = 0;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
199 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
200 if(mode == IO_MODE_BLOCKING) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
201 if (fcntl(st->fd, F_SETFL, flags & ~O_NONBLOCK) != 0) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
202 perror("fcntl");
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
203 // TODO: error
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
204 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
205 } else if(mode == IO_MODE_NONBLOCKING) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
206 if (fcntl(st->fd, F_SETFL, flags | O_NONBLOCK) != 0) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
207 perror("fcntl");
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
208 // TODO: error
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
209 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
210 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
211 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
212
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
213 int net_sys_poll(Sysstream *st, EventHandler *ev, int events, Event *cb) {
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
214 switch(events) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
215 default: return -1;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
216 case IO_POLL_NONE: return ev_remove_poll(ev, st->fd);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
217 case IO_POLL_IN: return ev_pollin(ev, st->fd, cb);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
218 case IO_POLL_OUT: return ev_pollout(ev, st->fd, cb);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
219 case IO_POLL_IN | IO_POLL_OUT: return -1; // TODO: implement
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
220 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
221 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
222
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
223 #elif defined(XP_WIN32)
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
224
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
225 ssize_t net_sys_write(Sysstream *st, void *buf, size_t nbytes) {
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
226 int ret = send(st->fd, buf, nbytes, 0);
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
227 if(ret == SOCKET_ERROR) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
228 return IO_ERROR;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
229 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
230 return ret;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
231 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
232
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
233 ssize_t net_sys_writev(Sysstream *st, struct iovec *iovec, int iovcnt) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
234 // TODO
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
235 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
236
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
237 ssize_t net_sys_read(Sysstream *st, void *buf, size_t nbytes) {
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
238 int ret = recv(st->fd, buf, nbytes, 0);
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
239 if(ret == SOCKET_ERROR) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
240 return IO_ERROR;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
241 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
242 return ret;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
243 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
244
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
245 ssize_t net_sys_sendfile(Sysstream *st, sendfiledata *sfd) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
246 // TODO
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
247 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
248
430
83560f32e7d5 refactor send_cgi into non-blocking SAF (wip)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 415
diff changeset
249 void net_sys_close(Sysstream *st) {
147
d050449c3b9e ported io.c and some headers to windows
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 142
diff changeset
250 closesocket(st->fd);
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
251 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
252
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
253 #endif
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
254
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
255
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
256 /*
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
257 * HttpStream implementation
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
258 */
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
259
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
260 IOStream* httpstream_new(pool_handle_t *pool, IOStream *fd) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
261 HttpStream *st = pool_malloc(pool, sizeof(HttpStream));
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
262 st->st = http_io_funcs;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
263 st->fd = fd;
415
d938228c382e switch from ucx 2 to 3
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 407
diff changeset
264 st->written = 0;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
265 st->max_read = 0;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
266 st->read = 0;
354
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
267 st->read_total = 0;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
268 st->readbuf = NULL;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
269 st->bufsize = 0;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
270 st->buflen = NULL;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
271 st->bufpos = NULL;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
272 st->chunk_buf_pos = 0;
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
273 st->current_chunk_length = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
274 st->current_chunk_pos = 0;
500
077aa138e8fb fix uninitialized memory in http stream, when chunked transfer encoding is used
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 498
diff changeset
275 st->current_trailer = 0;
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
276 st->write_chunk_buf_len = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
277 st->write_chunk_buf_pos = 0;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
278 st->chunked_enc = WS_FALSE;
354
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
279 st->read_eof = WS_TRUE;
361
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
280 st->write_eof = WS_FALSE;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
281 return (IOStream*)st;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
282 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
283
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
284 int httpstream_enable_chunked_read(IOStream *st, char *buffer, size_t bufsize, int *cursize, int *pos) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
285 if(st->read != (io_read_f)net_http_read) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
286 log_ereport(LOG_FAILURE, "%s", "httpstream_enable_chunked_read: IOStream is not an HttpStream");
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
287 return 1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
288 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
289 st->read = (io_read_f)net_http_read_chunked;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
290 HttpStream *http = (HttpStream*)st;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
291 http->max_read = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
292 http->read = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
293 http->readbuf = buffer;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
294 http->bufsize = bufsize;
336
fb75473fecca store HttpStream buflen as pointer (referencing NSAPISession cursize)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 335
diff changeset
295 http->buflen = cursize;
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
296 http->bufpos = pos;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
297 http->chunk_buf_pos = 0;
354
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
298 http->read_eof = WS_FALSE;
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
299 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
300 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
301
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
302 int httpstream_enable_chunked_write(IOStream *st) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
303 if(st->write != (io_write_f)net_http_write) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
304 log_ereport(LOG_FAILURE, "%s", "httpstream_enable_chunked_write: IOStream is not an HttpStream");
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
305 return 1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
306 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
307 HttpStream *http = (HttpStream*)st;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
308 http->chunked_enc = WS_TRUE;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
309 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
310 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
311
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
312 int httpstream_set_max_read(IOStream *st, int64_t maxread) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
313 if(st->write != (io_write_f)net_http_write) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
314 log_ereport(LOG_FAILURE, "%s", "httpstream_set_max_read: IOStream is not an HttpStream");
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
315 return 1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
316 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
317 HttpStream *http = (HttpStream*)st;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
318 http->max_read = maxread;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
319 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
320 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
321
354
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
322 WSBool httpstream_eof(IOStream *st) {
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
323 HttpStream *http = (HttpStream*)st;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
324 return http->read_eof;
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
325 }
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
326
407
78af44222463 close connection if content-length != number of bytes written
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 406
diff changeset
327 int64_t httpstream_written(IOStream *st) {
78af44222463 close connection if content-length != number of bytes written
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 406
diff changeset
328 HttpStream *http = (HttpStream*)st;
78af44222463 close connection if content-length != number of bytes written
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 406
diff changeset
329 return http->written;
78af44222463 close connection if content-length != number of bytes written
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 406
diff changeset
330 }
78af44222463 close connection if content-length != number of bytes written
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 406
diff changeset
331
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
332 /*
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
333 * iovec callback func
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
334 * returns number of payload bytes written (number of bytes returned back to the net_write caller)
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
335 */
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
336 typedef ssize_t(*writeop_finish_func)(HttpStream *st, char *base, size_t len, size_t written, void *udata);
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
337
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
338 static ssize_t httpstream_finish_prev_header(HttpStream *st, char *base, size_t len, size_t written, void *udata) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
339 st->write_chunk_buf_pos += written;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
340 if(st->write_chunk_buf_pos == st->write_chunk_buf_len) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
341 st->write_chunk_buf_len = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
342 st->write_chunk_buf_pos = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
343 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
344 return 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
345 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
346
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
347 static ssize_t httpstream_finish_data(HttpStream *st, char *base, size_t len, size_t written, void *udata) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
348 st->current_chunk_pos += written;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
349 if(st->current_chunk_pos == st->current_chunk_length) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
350 st->current_chunk_length = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
351 st->current_chunk_pos = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
352 st->current_trailer = 2;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
353 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
354 return written;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
355 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
356
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
357 static ssize_t httpstream_finish_new_header(HttpStream *st, char *base, size_t len, size_t written, void *udata) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
358 size_t *chunk_len = udata;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
359 st->current_chunk_length = *chunk_len;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
360 st->current_chunk_pos = 0; // new chunk started
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
361 if(written < len) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
362 st->write_chunk_buf_len = len-written;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
363 st->write_chunk_buf_pos = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
364 memcpy(st->write_chunk_buf + st->write_chunk_buf_pos, base+written, st->write_chunk_buf_len);
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
365 } else {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
366 st->write_chunk_buf_len = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
367 st->write_chunk_buf_pos = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
368 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
369 return 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
370 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
371
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
372 static ssize_t httpstream_finish_trailer(HttpStream *st, char *base, size_t len, size_t written, void *udata) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
373 st->current_trailer -= written;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
374 return 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
375 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
376
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
377 ssize_t net_http_write(HttpStream *st, const void *buf, size_t nbytes) {
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
378 st->st.io_errno = 0;
361
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
379 if(st->write_eof) return 0;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
380 IOStream *fd = st->fd;
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
381 if(!st->chunked_enc) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
382 ssize_t w = fd->write(fd, buf, nbytes);
406
e5d96f6b9306 store number of written bytes in the HttpStream
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 383
diff changeset
383 st->written += w > 0 ? w : 0;
e5d96f6b9306 store number of written bytes in the HttpStream
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 383
diff changeset
384 return w;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
385 } else {
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
386 struct iovec io[8];
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
387 writeop_finish_func io_finished[8];
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
388 void *io_finished_udata[8];
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
389 int iovec_len = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
390
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
391 char *str_crlf = "\r\n";
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
392
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
393 size_t prev_chunk_len = st->current_chunk_length;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
394 size_t new_chunk_len = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
395
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
396 // was the previous chunk header completely sent?
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
397 if(st->write_chunk_buf_len > 0) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
398 io[0].iov_base = &st->write_chunk_buf[st->write_chunk_buf_pos];
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
399 io[0].iov_len = st->write_chunk_buf_len - st->write_chunk_buf_pos;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
400 io_finished[0] = httpstream_finish_prev_header;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
401 io_finished_udata[0] = &prev_chunk_len;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
402 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
403 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
404
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
405 // was the previous chunk payload completely sent?
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
406 if(st->current_chunk_length != 0) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
407 size_t chunk_remaining = st->current_chunk_length - st->current_chunk_pos;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
408 size_t prev_nbytes = chunk_remaining > nbytes ? nbytes : chunk_remaining;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
409 io[iovec_len].iov_base = (char*)buf;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
410 io[iovec_len].iov_len = prev_nbytes;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
411 io_finished[iovec_len] = httpstream_finish_data;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
412 buf = ((char*)buf) + prev_nbytes;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
413 nbytes -= prev_nbytes;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
414 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
415
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
416 io[iovec_len].iov_base = str_crlf;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
417 io[iovec_len].iov_len = 2;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
418 io_finished[iovec_len] = httpstream_finish_trailer;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
419 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
420 } else if(st->current_trailer > 0) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
421 io[iovec_len].iov_base = str_crlf + 2 - st->current_trailer;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
422 io[iovec_len].iov_len = st->current_trailer;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
423 io_finished[iovec_len] = httpstream_finish_trailer;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
424 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
425 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
426
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
427 // TODO: on some plattforms iov_len is smaller than size_t
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
428 // if nbytes > INT_MAX, it should be devided into multiple
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
429 // iovec entries
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
430 char chunk_len[16];
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
431 if(nbytes > 0) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
432 new_chunk_len = nbytes;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
433 io[iovec_len].iov_base = chunk_len;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
434 io[iovec_len].iov_len = snprintf(chunk_len, 16, "%zx\r\n", nbytes);
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
435 io_finished[iovec_len] = httpstream_finish_new_header;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
436 io_finished_udata[iovec_len] = &new_chunk_len;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
437 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
438
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
439 io[iovec_len].iov_base = (char*)buf;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
440 io[iovec_len].iov_len = nbytes;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
441 io_finished[iovec_len] = httpstream_finish_data;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
442 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
443
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
444 io[iovec_len].iov_base = str_crlf;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
445 io[iovec_len].iov_len = 2;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
446 io_finished[iovec_len] = httpstream_finish_trailer;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
447 iovec_len++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
448 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
449
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
450 ssize_t wv = fd->writev(fd, io, iovec_len);
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
451 if(wv <= 0) {
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
452 st->st.io_errno = net_errno(st->fd);
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
453 return wv;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
454 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
455
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
456 ssize_t ret_w = 0;
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
457 int i = 0;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
458 while(wv > 0) {
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
459 char *base = io[i].iov_base;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
460 size_t len = io[i].iov_len;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
461 size_t wlen = wv > len ? len : wv;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
462 ret_w += io_finished[i](st, base, len, wlen, io_finished_udata[i]);
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
463 wv -= wlen;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
464 i++;
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
465 }
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
466
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
467 st->written += ret_w;
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
468 if(ret_w == 0) {
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
469 st->st.io_errno = EWOULDBLOCK; // not sure if this is really correct
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
470 ret_w = -1;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
471 }
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
472 return ret_w;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
473 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
474 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
475
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
476 ssize_t net_http_writev(HttpStream *st, struct iovec *iovec, int iovcnt) {
361
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
477 if(st->write_eof) return 0;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
478 IOStream *fd = st->fd;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
479 if(st->chunked_enc) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
480 struct iovec *io = calloc(iovcnt + 1, sizeof(struct iovec));
251
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
481 if(!io) {
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
482 return 0;
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
483 }
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
484 char chunk_len[16];
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
485 io[0].iov_base = chunk_len;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
486 size_t len = 0;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
487 for(int i=0;i<iovcnt;i++) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
488 len += iovec[i].iov_len;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
489 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
490 io[0].iov_len = snprintf(chunk_len, 16, "\r\n%zx\r\n", len);
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
491 memcpy(io + 1, iovec, iovcnt * sizeof(struct iovec));
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
492 ssize_t r = fd->writev(fd, io, iovcnt + 1);
251
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
493
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
494 ssize_t ret = r - io[0].iov_len;
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
495 free(io);
406
e5d96f6b9306 store number of written bytes in the HttpStream
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 383
diff changeset
496 st->written += ret;
251
f727a21497bb add basic PUT implementation and tests
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 235
diff changeset
497 return ret;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
498 } else {
406
e5d96f6b9306 store number of written bytes in the HttpStream
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 383
diff changeset
499 ssize_t w = fd->writev(fd, iovec, iovcnt);
e5d96f6b9306 store number of written bytes in the HttpStream
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 383
diff changeset
500 st->written += w;
e5d96f6b9306 store number of written bytes in the HttpStream
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 383
diff changeset
501 return w;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
502 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
503 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
504
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
505 ssize_t net_http_read(HttpStream *st, void *buf, size_t nbytes) {
332
6f82ede01e1c simplify request input buffer
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 251
diff changeset
506 if(st->read >= st->max_read) {
354
017eda1be105 add missing HttpStream initializations
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 336
diff changeset
507 st->read_eof = WS_TRUE;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
508 return 0;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
509 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
510 ssize_t r = st->fd->read(st->fd, buf, nbytes);
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
511 if(r < 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
512 st->st.io_errno = st->fd->io_errno;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
513 }
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
514 st->read += r;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
515 return r;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
516 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
517
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
518 #define BUF_UNNEEDED_DIFF 64
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
519 /*
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
520 * read from st->chunk_buf first, read from st->fd if perform_io is true
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
521 */
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
522 static ssize_t net_http_read_buffered(HttpStream *st, char *buf, size_t nbytes, WSBool read_data, WSBool *perform_io) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
523 ssize_t r = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
524
334
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
525 //memset(buf, 'x', nbytes);
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
526 //char *orig_buf = buf;
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
527
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
528 // copy available data from st->readbuf to buf
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
529 int pos = *st->bufpos;
336
fb75473fecca store HttpStream buflen as pointer (referencing NSAPISession cursize)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 335
diff changeset
530 size_t buf_available = *st->buflen - pos;
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
531 if(buf_available) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
532 size_t cplen = buf_available > nbytes ? nbytes : buf_available;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
533 if(read_data) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
534 // if we read data (and not a chunk header), we limit the
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
535 // amount of bytes we copy
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
536 size_t chunk_available = st->max_read - st->read;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
537 cplen = cplen > chunk_available ? chunk_available : cplen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
538 st->read += cplen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
539 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
540 memcpy(buf, st->readbuf + pos, cplen);
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
541 *st->bufpos += cplen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
542 r += cplen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
543 buf += cplen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
544 nbytes -= cplen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
545 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
546
335
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
547 // maybe perform IO and refill the read buffer
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
548 // if we read data (read_data == true), make sure not to perform IO,
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
549 // when a chunk is completed
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
550 //
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
551 // if we read a chunk header (read_data == false) it is very important
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
552 // to not perform IO, if we have previously copied data from readbuf
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
553 // this ensures we never override non-chunk-header data
334
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
554 if(*perform_io && ((read_data && nbytes > 0 && st->max_read - st->read) || (!read_data && r == 0))) {
336
fb75473fecca store HttpStream buflen as pointer (referencing NSAPISession cursize)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 335
diff changeset
555 if(*st->buflen - *st->bufpos > 0) {
334
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
556 printf("todo: fix, should not happen, remove later\n");
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
557 }
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
558 // fill buffer again
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
559 ssize_t rlen = st->fd->read(st->fd, st->readbuf, st->bufsize);
336
fb75473fecca store HttpStream buflen as pointer (referencing NSAPISession cursize)
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 335
diff changeset
560 *st->buflen = rlen;
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
561 *st->bufpos = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
562 *perform_io = WS_FALSE;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
563 if(rlen < 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
564 st->st.io_errno = st->fd->io_errno;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
565 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
566
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
567 if(rlen > 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
568 // call func again to get data from buffer (no IO will be performed)
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
569 r += net_http_read_buffered(st, buf, nbytes, read_data, perform_io);
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
570 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
571 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
572
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
573 return r;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
574 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
575
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
576
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
577 /*
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
578 * parses a chunk header
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
579 * the chunk length is stored in chunklen
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
580 * return: 0 if the data is incomplete
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
581 * -1 if an error occured
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
582 * >0 chunk header length
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
583 */
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
584 int http_stream_parse_chunk_header(char *str, int len, WSBool first, int64_t *chunklen) {
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
585 char *hdr_start = NULL;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
586 char *hdr_end = NULL;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
587 int i = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
588 if(first) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
589 hdr_start = str;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
590 } else {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
591 if(len < 3) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
592 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
593 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
594 if(str[0] == '\r' && str[1] == '\n') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
595 hdr_start = str+2;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
596 i = 2;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
597 } else if(str[0] == '\n') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
598 hdr_start = str+1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
599 i = 1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
600 } else {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
601 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
602 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
603 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
604
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
605 for(;i<len;i++) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
606 char c = str[i];
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
607 if(c == '\r' || c == '\n') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
608 hdr_end = str+i;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
609 break;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
610 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
611 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
612 if(!hdr_end || i == len) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
613 return 0; // incomplete
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
614 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
615
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
616 if(*hdr_end == '\r') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
617 // we also need '\n'
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
618 if(hdr_end[1] != '\n') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
619 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
620 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
621 i++; // '\n' found
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
622 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
623
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
624 // parse
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
625 char save_c = *hdr_end;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
626 *hdr_end = '\0';
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
627 char *end;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
628 int64_t clen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
629 errno = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
630 clen = strtoll(hdr_start, &end, 16);
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
631 *hdr_end = save_c;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
632 if(errno) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
633 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
634 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
635 i++;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
636
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
637 if(clen == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
638 // chunk length of 0 indicates the end
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
639 // an additional \r\n is required (we also accept \n)
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
640 if(i >= len) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
641 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
642 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
643 if(str[i] == '\n') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
644 i++;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
645 } else if(str[i] == '\r') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
646 if(++i >= len) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
647 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
648 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
649 if(str[i] == '\n') {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
650 i++;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
651 } else {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
652 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
653 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
654 } else {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
655 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
656 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
657 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
658
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
659 *chunklen = clen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
660 return i;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
661 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
662
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
663 ssize_t net_http_read_chunked(HttpStream *st, void *buf, size_t nbytes) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
664 if(st->read_eof) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
665 return 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
666 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
667
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
668 char *rbuf = buf; // buffer pos
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
669 size_t rd = 0; // number of bytes read
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
670 size_t rbuflen = nbytes; // number of bytes until end of buf
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
671 WSBool perform_io = WS_TRUE; // we do only 1 read before we abort
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
672 while(rd < nbytes && (perform_io || (st->max_read - st->read) > 0)) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
673 // how many bytes are available in the current chunk
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
674 size_t chunk_available = st->max_read - st->read;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
675 if(chunk_available > 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
676 ssize_t r = net_http_read_buffered(st, rbuf, rbuflen, TRUE, &perform_io);
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
677 if(r == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
678 break;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
679 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
680 rd += r;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
681 st->read_total += r;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
682 rbuf += r;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
683 rbuflen -= r;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
684 } else {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
685 int chunkbuf_avail = HTTP_STREAM_CBUF_SIZE - st->chunk_buf_pos;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
686 if(chunkbuf_avail == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
687 // for some reason HTTP_STREAM_CBUF_SIZE is not enough
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
688 // to store the chunk header
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
689 // this indicates that something has gone wrong (or this is an attack)
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
690 st->read_eof = WS_TRUE;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
691 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
692 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
693 // fill st->chunk_buf
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
694 ssize_t r = net_http_read_buffered(st, &st->chunk_buf[st->chunk_buf_pos], chunkbuf_avail, FALSE, &perform_io);
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
695 if(r == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
696 break;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
697 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
698 int chunkbuf_len = st->chunk_buf_pos + r;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
699 int64_t chunklen;
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
700 int ret = http_stream_parse_chunk_header(st->chunk_buf, chunkbuf_len, st->read_total > 0 ? FALSE : TRUE, &chunklen);
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
701 if(ret == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
702 // incomplete chunk header
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
703 st->chunk_buf_pos = chunkbuf_len;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
704 } else if(ret < 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
705 // error
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
706 st->read_eof = WS_TRUE;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
707 return -1;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
708 } else if(ret > 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
709 st->max_read = chunklen;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
710 st->read = 0;
335
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
711 int remaining_len = chunkbuf_len - ret;
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
712 if(remaining_len > 0) {
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
713 // we have read more into chunk_buf than the chunk_header
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
714 // it is save to just move bufpos back
5234c57b8759 code cleanup
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 334
diff changeset
715 *st->bufpos -= remaining_len;
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
716 }
334
a55491f66003 fix and simplify chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 333
diff changeset
717 //st->remaining_len = chunkbuf_len - ret;
333
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
718 st->chunk_buf_pos = 0;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
719
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
720 if(chunklen == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
721 st->read_eof = WS_TRUE;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
722 break;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
723 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
724 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
725 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
726
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
727 if(!perform_io && rd == 0) {
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
728 perform_io = WS_TRUE;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
729 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
730 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
731
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
732 return rd;
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
733 }
bb536d4bc174 first semi-functional implementation of chunked transfer encoding for request bodies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 332
diff changeset
734
361
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
735 ssize_t net_http_sendfile(HttpStream *st, sendfiledata *sfd) {
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
736 if(st->write_eof) return 0;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
737 ssize_t ret = 0;
112
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 110 111
diff changeset
738 // TODO: support chunked transfer encoding
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
739 if(st->fd->sendfile) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
740 ret = st->fd->sendfile(st->fd, sfd);
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
741 } else {
112
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 110 111
diff changeset
742 ret = net_fallback_sendfile((IOStream*)st, sfd);
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
743 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
744
493
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
745 st->written += ret > 0 ? ret : 0;
56cf890dd9ed fix net_sendfile not counting number of written bytes
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 430
diff changeset
746
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
747 return ret;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
748 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
749
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
750 void net_http_close(HttpStream *st) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
751 st->fd->close(st->fd);
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
752 }
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
753
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
754 void net_http_finish(HttpStream *st) {
361
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
755 if(st->chunked_enc && !st->write_eof) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
756 st->fd->write(st->fd, "0\r\n\r\n", 5);
80
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
757 }
361
570026d3a685 make sure the http stream is finished if headers are sent
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 354
diff changeset
758 st->write_eof = WS_TRUE;
80
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
759 }
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
760
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
761 void net_http_setmode(HttpStream *st, int mode) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
762 st->fd->setmode(st->fd, mode);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
763 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
764
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
765 int net_http_poll(HttpStream *st, EventHandler *ev, int events, Event *cb) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
766 return st->fd->poll(st->fd, ev, events, cb);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
767 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
768
8
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
769
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
770 /*
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
771 * SSLStream implementation
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
772 */
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
773
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
774 IOStream* sslstream_new(pool_handle_t *pool, SSL *ssl) {
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
775 SSLStream *st = pool_malloc(pool, sizeof(SSLStream));
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
776 st->st = ssl_io_funcs;
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
777 st->ssl = ssl;
133
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
778 st->error = 0;
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
779 return (IOStream*)st;
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
780 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
781
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
782 ssize_t net_ssl_write(SSLStream *st, const void *buf, size_t nbytes) {
133
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
783 int ret = SSL_write(st->ssl, buf, nbytes);
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
784 if(ret <= 0) {
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
785 st->error = SSL_get_error(st->ssl, ret);
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
786 if(st->error == SSL_ERROR_WANT_WRITE || st->error == SSL_ERROR_WANT_READ) {
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
787 st->st.io_errno = EWOULDBLOCK;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
788 } else {
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
789 st->st.io_errno = -1;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
790 }
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
791 ret = -1;
133
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
792 }
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
793 return ret;
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
794 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
795
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
796 ssize_t net_ssl_writev(SSLStream *st, struct iovec *iovec, int iovcnt) {
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
797 ssize_t r = 0;
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
798 for(int i=0;i<iovcnt;i++) {
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
799 int ret = SSL_write(st->ssl, iovec[i].iov_base, iovec[i].iov_len);
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
800 if(ret <= 0) {
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
801 if(r == 0) {
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
802 st->error = SSL_get_error(st->ssl, ret);
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
803 if(st->error == SSL_ERROR_WANT_WRITE || st->error == SSL_ERROR_WANT_READ) {
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
804 st->st.io_errno = EWOULDBLOCK;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
805 } else {
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
806 st->st.io_errno = -1;
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
807 }
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
808 }
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
809 break;
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
810 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
811 r += ret;
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
812 }
502
11ac3761c0e3 fix non-blocking CGI handler and non-blocking SSL-IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 500
diff changeset
813 return r == 0 ? -1 : r;
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
814 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
815
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
816 ssize_t net_ssl_read(SSLStream *st, void *buf, size_t nbytes) {
133
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
817 int ret = SSL_read(st->ssl, buf, nbytes);
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
818 if(ret <= 0) {
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
819 st->error = SSL_get_error(st->ssl, ret);
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
820 }
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
821 return ret;
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
822 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
823
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
824 void net_ssl_close(SSLStream *st) {
133
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
825 int ret = SSL_shutdown(st->ssl);
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
826 if(ret != 1) {
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
827 st->error = SSL_get_error(st->ssl, ret);
87b405d61f64 improves event handler and ssl error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 126
diff changeset
828 }
171
af7e2d80dee6 adds wrapper for close syscall with error handling
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
829 system_close(SSL_get_fd(st->ssl));
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
830 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
831
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
832 void net_ssl_finish(SSLStream *st) {
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
833
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
834 }
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
835
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
836 void net_ssl_setmode(SSLStream *st, int mode) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
837 int flags;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
838 if (-1 == (flags = fcntl(SSL_get_fd(st->ssl), F_GETFL, 0))) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
839 flags = 0;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
840 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
841 if(mode == IO_MODE_BLOCKING) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
842 if (fcntl(SSL_get_fd(st->ssl), F_SETFL, flags & ~O_NONBLOCK) != 0) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
843 perror("fcntl");
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
844 // TODO: error
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
845 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
846 } else if(mode == IO_MODE_NONBLOCKING) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
847 if (fcntl(SSL_get_fd(st->ssl), F_SETFL, flags | O_NONBLOCK) != 0) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
848 perror("fcntl");
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
849 // TODO: error
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
850 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
851 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
852 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
853
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
854 int net_ssl_poll(SSLStream *st, EventHandler *ev, int events, Event *cb) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
855 int fd = SSL_get_fd(st->ssl);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
856 switch(events) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
857 default: return -1;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
858 case IO_POLL_NONE: return ev_remove_poll(ev, fd);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
859 case IO_POLL_IN: return ev_pollin(ev, fd, cb);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
860 case IO_POLL_OUT: return ev_pollout(ev, fd, cb);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
861 case IO_POLL_IN | IO_POLL_OUT: return -1; // TODO: implement
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
862 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
863 }
106
b122f34ddc80 added minimal ssl support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 104
diff changeset
864
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
865 /* -------------------- public nsapi network functions -------------------- */
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
866
8
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
867 ssize_t net_read(SYS_NETFD fd, void *buf, size_t nbytes) {
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
868 ssize_t r = ((IOStream*)fd)->read(fd, buf, nbytes);
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
869 if(r == 0) {
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
870 return IO_EOF;
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
871 } else if(r < 0) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
872 ((IOStream*)fd)->io_errno = errno;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
873 return IO_ERROR;
8
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
874 }
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
875 return r;
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
876 }
f4d56bf9de40 Added request body reader
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 4
diff changeset
877
498
0d80f8a2b29f fix net_http_write when used with chunked transfer encoding and non-blocking IO
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 493
diff changeset
878 ssize_t net_write(SYS_NETFD fd, const void *buf, size_t nbytes) {
9
30e51941a673 Added mod_jk dependencies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 8
diff changeset
879 ssize_t r = ((IOStream*)fd)->write(fd, buf, nbytes);
30e51941a673 Added mod_jk dependencies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 8
diff changeset
880 if(r < 0) {
30e51941a673 Added mod_jk dependencies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 8
diff changeset
881 return IO_ERROR;
20
7b235fa88008 Some fixes for mod_jk
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 14
diff changeset
882 }
9
30e51941a673 Added mod_jk dependencies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 8
diff changeset
883 return r;
30e51941a673 Added mod_jk dependencies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 8
diff changeset
884 }
30e51941a673 Added mod_jk dependencies
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 8
diff changeset
885
64
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
886 ssize_t net_writev(SYS_NETFD fd, struct iovec *iovec, int iovcnt) {
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
887 ssize_t r = ((IOStream*)fd)->writev(fd, iovec, iovcnt);
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
888 if(r < 0) {
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
889 ((IOStream*)fd)->io_errno = errno;
64
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
890 return IO_ERROR;
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
891 }
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
892 return r;
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
893 }
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
894
23
a2c8fc23c90e Added basic authentication
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 20
diff changeset
895 ssize_t net_printf(SYS_NETFD fd, char *format, ...) {
a2c8fc23c90e Added basic authentication
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 20
diff changeset
896 va_list arg;
a2c8fc23c90e Added basic authentication
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 20
diff changeset
897 va_start(arg, format);
415
d938228c382e switch from ucx 2 to 3
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 407
diff changeset
898 cxmutstr buf = cx_vasprintf_a(cxDefaultAllocator, format, arg);
383
a5698877d14a fix net_printf not working with empty strings
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 361
diff changeset
899 ssize_t r = buf.length > 0 ? net_write(fd, buf.ptr, buf.length) : 0;
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
900 free(buf.ptr);
142
55298bc9ed28 adds new a pathcheck saf and improves content type matchin and improves content type matching
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 133
diff changeset
901 va_end(arg);
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
902 if(r < 0) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
903 ((IOStream*)fd)->io_errno = errno;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
904 }
64
c7f5b062e622 added net_writev
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 54
diff changeset
905 return r;
23
a2c8fc23c90e Added basic authentication
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 20
diff changeset
906 }
a2c8fc23c90e Added basic authentication
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 20
diff changeset
907
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
908 ssize_t net_sendfile(SYS_NETFD fd, sendfiledata *sfd) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
909 IOStream *out = fd;
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
910 if(out->sendfile && sfd->fd && sfd->fd->fd != -1) {
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
911 ssize_t r = out->sendfile(fd, sfd);
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
912 if(r < 0) {
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
913 out->io_errno = errno;
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
914 return IO_ERROR;
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
915 }
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
916 return r;
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
917 } else {
66
74babc0082b7 added authentication cache
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 65
diff changeset
918 // stream/file does not support sendfile
74babc0082b7 added authentication cache
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 65
diff changeset
919 // do regular copy
112
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 110 111
diff changeset
920 return net_fallback_sendfile(out, sfd);
54
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
921 }
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
922 }
3a1d5a52adfc new vfs api
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 46
diff changeset
923
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
924 // private
112
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 110 111
diff changeset
925 ssize_t net_fallback_sendfile(IOStream *fd, sendfiledata *sfd) {
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
926 char *buf = malloc(4096);
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
927 if(!buf) {
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
928 // TODO: out of memory error
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
929 return IO_ERROR;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
930 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
931 char *header = (char*)sfd->header;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
932 int hlen = sfd->hlen;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
933 char *trailer = (char*)sfd->trailer;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
934 int tlen = sfd->tlen;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
935 if(header == NULL) {
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
936 hlen = 0;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
937 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
938 if(trailer == NULL) {
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
939 tlen = 0;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
940 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
941
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
942 ssize_t r;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
943 while(hlen > 0) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
944 r = fd->write(fd, header, hlen);
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
945 header += r;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
946 hlen -= r;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
947 if(r <= 0) {
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
948 free(buf);
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
949 fd->io_errno = errno;
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
950 return IO_ERROR;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
951 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
952 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
953
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
954 if(system_lseek(sfd->fd, sfd->offset, SEEK_SET) == -1) {
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
955 free(buf);
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
956 fd->io_errno = errno;
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
957 return IO_ERROR;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
958 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
959
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
960 size_t length = sfd->len;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
961 while(length > 0) {
205
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
962 // TODO: remove
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
963 if(length > sfd->len) {
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
964 log_ereport(LOG_WARN, "net_fallback_sendfile: length > sfd->len: %zu > %zu", length, sfd->len);
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
965 free(buf);
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
966 return IO_ERROR;
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
967 }
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
968
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
969 if((r = system_fread(sfd->fd, buf, 4096)) <= 0) {
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
970 break;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
971 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
972 char *write_buf = buf;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
973 while(r > 0) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
974 ssize_t w = fd->write(fd, write_buf, r);
205
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
975 // TODO: remove
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
976 if(w > r) {
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
977 log_ereport(LOG_WARN, "net_fallback_sendfile: w > r, %zd > %zd", w, r);
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
978 w = 0;
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
979 }
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
980
203
7fe53d5d587c fix error handling in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 193
diff changeset
981 if(w <= 0) {
205
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
982 free(buf);
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
983 fd->io_errno = errno;
b8515afa450a improve error handling and add some debug code in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 203
diff changeset
984 return IO_ERROR;
203
7fe53d5d587c fix error handling in net_fallback_sendfile
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 193
diff changeset
985 }
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
986 r -= w;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
987 length -= w;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
988 write_buf += w;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
989 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
990 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
991 free(buf);
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
992 if(length > 0) {
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
993 fd->io_errno = errno;
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
994 return IO_ERROR;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
995 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
996
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
997 while(tlen > 0) {
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
998 r = fd->write(fd, trailer, tlen);
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
999 trailer += r;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1000 tlen -= r;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1001 if(r <= 0) {
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1002 fd->io_errno = errno;
111
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1003 return IO_ERROR;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1004 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1005 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1006
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1007 return sfd->hlen + sfd->len + sfd->tlen;
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1008 }
c93be34fde76 fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1009
82
740cfd9dd443 added some nsapi stuff
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 80
diff changeset
1010 int net_flush(SYS_NETFD sd) {
740cfd9dd443 added some nsapi stuff
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 80
diff changeset
1011 // TODO: implement
740cfd9dd443 added some nsapi stuff
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 80
diff changeset
1012 return 0;
4
998844b5ed25 Added some protocol functions
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 1
diff changeset
1013 }
32
ebba53de8b18 added solaris 10 support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 25
diff changeset
1014
80
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
1015 void net_close(SYS_NETFD fd) {
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
1016 ((IOStream*)fd)->close(fd);
32
ebba53de8b18 added solaris 10 support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 25
diff changeset
1017 }
ebba53de8b18 added solaris 10 support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 25
diff changeset
1018
172
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1019 int net_setnonblock(SYS_NETFD fd, int nonblock) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1020 ((IOStream*)fd)->setmode(
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1021 fd,
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1022 nonblock ? IO_MODE_NONBLOCKING : IO_MODE_BLOCKING);
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1023 return 0;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1024 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1025
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1026 int net_errno(SYS_NETFD fd) {
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1027 return ((IOStream*)fd)->io_errno;
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1028 }
5580517faafc adds public aio and poll api and asynchronous send_range function
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 147
diff changeset
1029
110
43a746e905f6 refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 106
diff changeset
1030 // private
80
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
1031 void net_finish(SYS_NETFD fd) {
0de4a90979e1 fixed chunked transfer encoding
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 71
diff changeset
1032 ((IOStream*)fd)->finish(fd);
32
ebba53de8b18 added solaris 10 support
Olaf Wintermann <olaf.wintermann@gmail.com>
parents: 25
diff changeset
1033 }

mercurial