Tue, 12 Sep 2023 18:08:11 +0200
update uwproj
1 | 1 | /* |
2 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. | |
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 | 5 | * |
6 | * Redistribution and use in source and binary forms, with or without | |
7 | * modification, are permitted provided that the following conditions are met: | |
8 | * | |
9 | * 1. Redistributions of source code must retain the above copyright | |
10 | * notice, this list of conditions and the following disclaimer. | |
11 | * | |
12 | * 2. Redistributions in binary form must reproduce the above copyright | |
13 | * notice, this list of conditions and the following disclaimer in the | |
14 | * documentation and/or other materials provided with the distribution. | |
15 | * | |
16 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
17 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
18 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
19 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE | |
20 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
21 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
22 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
23 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
24 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
25 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
26 | * POSSIBILITY OF SUCH DAMAGE. | |
27 | */ | |
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 | 33 | #include <unistd.h> |
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 | 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 | 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 | 64 | #include "../daemon/vfs.h" |
1 | 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 | 71 | |
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 | 82 | }; |
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 | 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 | 115 | st->st = native_io_funcs; |
116 | st->fd = fd; | |
117 | return (IOStream*)st; | |
118 | } | |
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 | 141 | ssize_t ret = 0; |
142 | off_t fileoffset = sfd->offset; | |
143 | if(sfd->fd->fd != -1) { | |
71 | 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 | 158 | #ifdef OSX |
159 | ret = sendfile(sfd->fd->fd, st->fd, fileoffset, &len, &hdtr, 0); | |
160 | #else // BSD | |
161 | ret = sendfile( | |
162 | sfd->fd->fd, | |
163 | st->fd, | |
164 | fileoffset, | |
165 | sfd->len, | |
166 | &hdtr, | |
167 | NULL, | |
168 | 0); | |
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 | 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 | 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 | 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 | 187 | return ret; |
188 | } | |
111
c93be34fde76
fixed NetBSD build and an uninitialized struct member
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
106
diff
changeset
|
189 | #endif |
54 | 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 | 547 | // maybe perform IO and refill the read buffer |
548 | // if we read data (read_data == true), make sure not to perform IO, | |
549 | // when a chunk is completed | |
550 | // | |
551 | // if we read a chunk header (read_data == false) it is very important | |
552 | // to not perform IO, if we have previously copied data from readbuf | |
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 | 711 | int remaining_len = chunkbuf_len - ret; |
712 | if(remaining_len > 0) { | |
713 | // we have read more into chunk_buf than the chunk_header | |
714 | // it is save to just move bufpos back | |
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 | 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 | 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 | 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 | 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 | 914 | return IO_ERROR; |
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 | 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 | 920 | return net_fallback_sendfile(out, sfd); |
54 | 921 | } |
922 | } | |
923 | ||
110
43a746e905f6
refactored IO system
Olaf Wintermann <olaf.wintermann@gmail.com>
parents:
106
diff
changeset
|
924 | // private |
112 | 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 | } |