2 |
2 |
3 #include <stdlib.h> |
3 #include <stdlib.h> |
4 #include <string.h> |
4 #include <string.h> |
5 #include <assert.h> |
5 #include <assert.h> |
6 |
6 |
|
7 /** |
|
8 * Grow buf->vecs as needed, to ensure that buf->write_vec is valid |
|
9 */ |
|
10 static err_t sock_test_grow_buf (struct io_buf *buf) |
|
11 { |
|
12 size_t read_vec_offset = buf->read_vec ? (buf->read_vec - buf->vecs) : 0; |
|
13 size_t write_vec_offset = buf->write_vec ? (buf->write_vec - buf->vecs) : 0; |
|
14 struct io_vec *v; |
|
15 struct io_vec *vecs_tmp = buf->vecs; |
|
16 |
|
17 // don't grow if not full |
|
18 if (buf->vecs && buf->write_vec < buf->vecs + buf->count) |
|
19 return SUCCESS; |
|
20 |
|
21 // new size |
|
22 buf->count = buf->count * 2 + 1; |
|
23 |
|
24 // grow |
|
25 if ((buf->vecs = realloc(buf->vecs, buf->count * sizeof(struct io_vec))) == NULL) { |
|
26 // restore old value |
|
27 buf->vecs = vecs_tmp; |
|
28 |
|
29 return ERR_CALLOC; |
|
30 } |
|
31 |
|
32 // set vec |
|
33 buf->write_vec = buf->vecs + write_vec_offset; |
|
34 buf->read_vec = buf->vecs + read_vec_offset; |
|
35 |
|
36 // zero new vecs |
|
37 for (v = buf->write_vec; v < buf->vecs + buf->count; v++) { |
|
38 v->buf = NULL; |
|
39 v->len = 0; |
|
40 } |
|
41 |
|
42 // ok |
|
43 return SUCCESS; |
|
44 } |
|
45 |
7 static err_t sock_test_read (struct sock_stream *base_sock, void *buf_ptr, size_t *len) |
46 static err_t sock_test_read (struct sock_stream *base_sock, void *buf_ptr, size_t *len) |
8 { |
47 { |
9 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
48 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
10 struct io_buf *buf = &sock->recv_buf; |
49 struct io_buf *buf = &sock->recv_buf; |
11 struct io_vec *vec = buf->vec; |
50 struct io_vec *vec = buf->read_vec; |
12 |
51 |
13 // no current vector -> EOF |
52 // EOF/nonblock if we're past the end of the last vector |
14 if (!vec) |
53 if (!vec || vec == buf->vecs + buf->count || buf->off >= vec->len) { |
15 return ERR_READ_EOF; |
54 if (sock->nonblocking && !sock->eof) { |
16 |
55 // wait for more to be fed in |
17 // vector past the end -> EOF |
56 *len = 0; |
18 if (vec == &buf->vecs[buf->count]) |
57 return SUCCESS; |
19 return ERR_READ_EOF; |
58 |
20 |
59 } else { |
21 // no data left in current vector -> EOF |
60 // EOF! |
22 if (buf->off >= vec->len) |
61 return SET_ERROR(SOCK_TEST_ERR(sock), ERR_READ_EOF); |
23 return ERR_READ_EOF; |
62 } |
|
63 } |
24 |
64 |
25 // amount of data available in this iovec |
65 // amount of data available in this iovec |
26 size_t available = vec->len - buf->off; |
66 size_t available = vec->len - buf->off; |
27 |
67 |
28 // amount to read |
68 // amount to read |
54 |
94 |
55 static err_t sock_test_write (struct sock_stream *base_sock, const void *buf_ptr, size_t *len) |
95 static err_t sock_test_write (struct sock_stream *base_sock, const void *buf_ptr, size_t *len) |
56 { |
96 { |
57 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
97 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
58 struct io_buf *buf = &sock->send_buf; |
98 struct io_buf *buf = &sock->send_buf; |
59 struct io_vec *vec = buf->vec; |
99 |
60 |
100 // ensure there's room |
61 // vectors full? |
101 assert(sock_test_grow_buf(buf) == SUCCESS); |
62 if (buf->vecs == NULL || vec == &buf->vecs[buf->count]) { |
102 |
63 size_t vec_offset = vec ? (vec - buf->vecs) : 0; |
103 // the next buffer |
64 struct io_vec *v; |
104 struct io_vec *vec = buf->write_vec; |
65 |
|
66 // new size |
|
67 buf->count = buf->count * 2 + 1; |
|
68 |
|
69 // grow |
|
70 assert((buf->vecs = realloc(buf->vecs, buf->count * sizeof(struct io_vec)))); |
|
71 |
|
72 // set vec |
|
73 vec = buf->vec = buf->vecs + vec_offset; |
|
74 |
|
75 // zero |
|
76 for (v = vec; v < &buf->vecs[buf->count]; v++) { |
|
77 v->buf = NULL; |
|
78 v->len = 0; |
|
79 } |
|
80 } |
|
81 |
105 |
82 // store |
106 // store |
83 vec->len = *len; |
107 vec->len = *len; |
84 assert((vec->buf = malloc(vec->len))); |
108 assert((vec->buf = malloc(vec->len))); |
85 memcpy(vec->buf, buf_ptr, vec->len); |
109 memcpy(vec->buf, buf_ptr, vec->len); |
86 |
110 |
87 // move vec onwards |
111 // move vec onwards |
88 buf->vec++; |
112 buf->write_vec++; |
89 |
113 |
90 // ok |
114 // ok |
91 return SUCCESS; |
115 return SUCCESS; |
92 } |
116 } |
93 |
117 |
94 static err_t sock_test_event_init (struct sock_stream *base_sock) |
118 static err_t sock_test_event_init (struct sock_stream *base_sock) |
95 { |
119 { |
96 |
120 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
|
121 |
|
122 // set the nonblocking flag |
|
123 sock->nonblocking = true; |
|
124 |
97 return SUCCESS; |
125 return SUCCESS; |
98 } |
126 } |
99 |
127 |
100 static err_t sock_test_event_enable (struct sock_stream *base_sock, short mask) |
128 static err_t sock_test_event_enable (struct sock_stream *base_sock, short mask) |
101 { |
129 { |
102 |
130 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
|
131 |
103 return SUCCESS; |
132 return SUCCESS; |
104 } |
133 } |
105 |
134 |
106 static void sock_test_release (struct sock_stream *base_sock) |
135 static void sock_test_release (struct sock_stream *base_sock) |
107 { |
136 { |
108 |
137 struct sock_test *sock = SOCK_FROM_BASE(base_sock, struct sock_test); |
|
138 |
|
139 sock_test_destroy(sock); |
109 } |
140 } |
110 |
141 |
111 /* |
142 /* |
112 * Our sock_stream_type |
143 * Our sock_stream_type |
113 */ |
144 */ |
133 |
164 |
134 // ok |
165 // ok |
135 return sock; |
166 return sock; |
136 } |
167 } |
137 |
168 |
138 void sock_test_set_recv_buffer (struct sock_test *sock, struct io_vec *vecs, size_t count) |
169 void sock_test_destroy (struct sock_test *sock) |
139 { |
170 { |
140 sock->recv_buf.vecs = vecs; |
171 size_t i; |
141 sock->recv_buf.count = count; |
172 struct io_buf *sbuf = &sock->send_buf, *rbuf = &sock->recv_buf; |
142 sock->recv_buf.vec = vecs; |
173 |
143 sock->recv_buf.off = 0; |
174 // free the send buffer |
|
175 for (i = 0; i < sbuf->count; i++) { |
|
176 free(sbuf->vecs[i].buf); |
|
177 } |
|
178 |
|
179 // free the buffer vector lists |
|
180 free(sbuf->vecs); |
|
181 free(rbuf->vecs); |
|
182 |
|
183 // free the sock itself |
|
184 free(sock); |
|
185 } |
|
186 |
|
187 void sock_test_set_recv_buffer (struct sock_test *sock, struct io_vec *vecs, size_t count, bool eof) |
|
188 { |
|
189 struct io_buf *buf = &sock->recv_buf; |
|
190 |
|
191 // allocate + copy |
|
192 assert((buf->vecs = calloc(count, sizeof(struct io_vec)))); |
|
193 memcpy(buf->vecs, vecs, count * sizeof(struct io_vec)); |
|
194 |
|
195 // set |
|
196 buf->count = count; |
|
197 buf->read_vec = buf->vecs; |
|
198 buf->write_vec = buf->vecs + count; |
|
199 buf->off = 0; |
|
200 |
|
201 // set EOF flag? |
|
202 if (eof) |
|
203 sock->eof = true; |
|
204 } |
|
205 |
|
206 void sock_test_add_recv_vec (struct sock_test *sock, struct io_vec new_vec) |
|
207 { |
|
208 struct io_buf *buf = &sock->recv_buf; |
|
209 |
|
210 // ensure there's room |
|
211 assert(sock_test_grow_buf(buf) == SUCCESS); |
|
212 |
|
213 // copy |
|
214 *(buf->write_vec++) = new_vec; |
144 } |
215 } |
145 |
216 |
146 void sock_test_get_send_data (struct sock_test *sock, char **buf_ptr, size_t *len_ptr) |
217 void sock_test_get_send_data (struct sock_test *sock, char **buf_ptr, size_t *len_ptr) |
147 { |
218 { |
148 struct io_buf *buf = &sock->send_buf; |
219 struct io_buf *buf = &sock->send_buf; |