The Tor Browser / file comparison
comparison: ipc/chromium/src/third_party/libevent/buffer_iocp.c
ipc/chromium/src/third_party/libevent/buffer_iocp.c
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:a4ed7a3588d8 |
|---|---|
| 1 /* | |
| 2 * Copyright (c) 2009-2012 Niels Provos and Nick Mathewson | |
| 3 * | |
| 4 * Redistribution and use in source and binary forms, with or without | |
| 5 * modification, are permitted provided that the following conditions | |
| 6 * are met: | |
| 7 * 1. Redistributions of source code must retain the above copyright | |
| 8 * notice, this list of conditions and the following disclaimer. | |
| 9 * 2. Redistributions in binary form must reproduce the above copyright | |
| 10 * notice, this list of conditions and the following disclaimer in the | |
| 11 * documentation and/or other materials provided with the distribution. | |
| 12 * 3. The name of the author may not be used to endorse or promote products | |
| 13 * derived from this software without specific prior written permission. | |
| 14 * | |
| 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR | |
| 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |
| 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
| 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | |
| 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
| 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
| 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 25 */ | |
| 26 | |
| 27 /** | |
| 28 @file buffer_iocp.c | |
| 29 | |
| 30 This module implements overlapped read and write functions for evbuffer | |
| 31 objects on Windows. | |
| 32 */ | |
| 33 | |
| 34 #include "event2/buffer.h" | |
| 35 #include "event2/buffer_compat.h" | |
| 36 #include "event2/util.h" | |
| 37 #include "event2/thread.h" | |
| 38 #include "event2/event-config.h" | |
| 39 #include "util-internal.h" | |
| 40 #include "evthread-internal.h" | |
| 41 #include "evbuffer-internal.h" | |
| 42 #include "iocp-internal.h" | |
| 43 #include "mm-internal.h" | |
| 44 | |
| 45 #include <winsock2.h> | |
| 46 #include <windows.h> | |
| 47 #include <stdio.h> | |
| 48 | |
| 49 #define MAX_WSABUFS 16 | |
| 50 | |
| 51 /** An evbuffer that can handle overlapped IO. */ | |
| 52 struct evbuffer_overlapped { | |
| 53 struct evbuffer buffer; | |
| 54 /** The socket that we're doing overlapped IO on. */ | |
| 55 evutil_socket_t fd; | |
| 56 | |
| 57 /** pending I/O type */ | |
| 58 unsigned read_in_progress : 1; | |
| 59 unsigned write_in_progress : 1; | |
| 60 | |
| 61 /** The first pinned chain in the buffer. */ | |
| 62 struct evbuffer_chain *first_pinned; | |
| 63 | |
| 64 /** How many chains are pinned; how many of the fields in buffers | |
| 65 * are we using. */ | |
| 66 int n_buffers; | |
| 67 WSABUF buffers[MAX_WSABUFS]; | |
| 68 }; | |
| 69 | |
| 70 /** Given an evbuffer, return the correponding evbuffer structure, or NULL if | |
| 71 * the evbuffer isn't overlapped. */ | |
| 72 static inline struct evbuffer_overlapped * | |
| 73 upcast_evbuffer(struct evbuffer *buf) | |
| 74 { | |
| 75 if (!buf || !buf->is_overlapped) | |
| 76 return NULL; | |
| 77 return EVUTIL_UPCAST(buf, struct evbuffer_overlapped, buffer); | |
| 78 } | |
| 79 | |
| 80 /** Unpin all the chains noted as pinned in 'eo'. */ | |
| 81 static void | |
| 82 pin_release(struct evbuffer_overlapped *eo, unsigned flag) | |
| 83 { | |
| 84 int i; | |
| 85 struct evbuffer_chain *next, *chain = eo->first_pinned; | |
| 86 | |
| 87 for (i = 0; i < eo->n_buffers; ++i) { | |
| 88 EVUTIL_ASSERT(chain); | |
| 89 next = chain->next; | |
| 90 _evbuffer_chain_unpin(chain, flag); | |
| 91 chain = next; | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 void | |
| 96 evbuffer_commit_read(struct evbuffer *evbuf, ev_ssize_t nBytes) | |
| 97 { | |
| 98 struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf); | |
| 99 struct evbuffer_chain **chainp; | |
| 100 size_t remaining, len; | |
| 101 unsigned i; | |
| 102 | |
| 103 EVBUFFER_LOCK(evbuf); | |
| 104 EVUTIL_ASSERT(buf->read_in_progress && !buf->write_in_progress); | |
| 105 EVUTIL_ASSERT(nBytes >= 0); /* XXXX Can this be false? */ | |
| 106 | |
| 107 evbuffer_unfreeze(evbuf, 0); | |
| 108 | |
| 109 chainp = evbuf->last_with_datap; | |
| 110 if (!((*chainp)->flags & EVBUFFER_MEM_PINNED_R)) | |
| 111 chainp = &(*chainp)->next; | |
| 112 remaining = nBytes; | |
| 113 for (i = 0; remaining > 0 && i < (unsigned)buf->n_buffers; ++i) { | |
| 114 EVUTIL_ASSERT(*chainp); | |
| 115 len = buf->buffers[i].len; | |
| 116 if (remaining < len) | |
| 117 len = remaining; | |
| 118 (*chainp)->off += len; | |
| 119 evbuf->last_with_datap = chainp; | |
| 120 remaining -= len; | |
| 121 chainp = &(*chainp)->next; | |
| 122 } | |
| 123 | |
| 124 pin_release(buf, EVBUFFER_MEM_PINNED_R); | |
| 125 | |
| 126 buf->read_in_progress = 0; | |
| 127 | |
| 128 evbuf->total_len += nBytes; | |
| 129 evbuf->n_add_for_cb += nBytes; | |
| 130 | |
| 131 evbuffer_invoke_callbacks(evbuf); | |
| 132 | |
| 133 _evbuffer_decref_and_unlock(evbuf); | |
| 134 } | |
| 135 | |
| 136 void | |
| 137 evbuffer_commit_write(struct evbuffer *evbuf, ev_ssize_t nBytes) | |
| 138 { | |
| 139 struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf); | |
| 140 | |
| 141 EVBUFFER_LOCK(evbuf); | |
| 142 EVUTIL_ASSERT(buf->write_in_progress && !buf->read_in_progress); | |
| 143 evbuffer_unfreeze(evbuf, 1); | |
| 144 evbuffer_drain(evbuf, nBytes); | |
| 145 pin_release(buf,EVBUFFER_MEM_PINNED_W); | |
| 146 buf->write_in_progress = 0; | |
| 147 _evbuffer_decref_and_unlock(evbuf); | |
| 148 } | |
| 149 | |
| 150 struct evbuffer * | |
| 151 evbuffer_overlapped_new(evutil_socket_t fd) | |
| 152 { | |
| 153 struct evbuffer_overlapped *evo; | |
| 154 | |
| 155 evo = mm_calloc(1, sizeof(struct evbuffer_overlapped)); | |
| 156 if (!evo) | |
| 157 return NULL; | |
| 158 | |
| 159 TAILQ_INIT(&evo->buffer.callbacks); | |
| 160 evo->buffer.refcnt = 1; | |
| 161 evo->buffer.last_with_datap = &evo->buffer.first; | |
| 162 | |
| 163 evo->buffer.is_overlapped = 1; | |
| 164 evo->fd = fd; | |
| 165 | |
| 166 return &evo->buffer; | |
| 167 } | |
| 168 | |
| 169 int | |
| 170 evbuffer_launch_write(struct evbuffer *buf, ev_ssize_t at_most, | |
| 171 struct event_overlapped *ol) | |
| 172 { | |
| 173 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); | |
| 174 int r = -1; | |
| 175 int i; | |
| 176 struct evbuffer_chain *chain; | |
| 177 DWORD bytesSent; | |
| 178 | |
| 179 if (!buf) { | |
| 180 /* No buffer, or it isn't overlapped */ | |
| 181 return -1; | |
| 182 } | |
| 183 | |
| 184 EVBUFFER_LOCK(buf); | |
| 185 EVUTIL_ASSERT(!buf_o->read_in_progress); | |
| 186 if (buf->freeze_start || buf_o->write_in_progress) | |
| 187 goto done; | |
| 188 if (!buf->total_len) { | |
| 189 /* Nothing to write */ | |
| 190 r = 0; | |
| 191 goto done; | |
| 192 } else if (at_most < 0 || (size_t)at_most > buf->total_len) { | |
| 193 at_most = buf->total_len; | |
| 194 } | |
| 195 evbuffer_freeze(buf, 1); | |
| 196 | |
| 197 buf_o->first_pinned = NULL; | |
| 198 buf_o->n_buffers = 0; | |
| 199 memset(buf_o->buffers, 0, sizeof(buf_o->buffers)); | |
| 200 | |
| 201 chain = buf_o->first_pinned = buf->first; | |
| 202 | |
| 203 for (i=0; i < MAX_WSABUFS && chain; ++i, chain=chain->next) { | |
| 204 WSABUF *b = &buf_o->buffers[i]; | |
| 205 b->buf = (char*)( chain->buffer + chain->misalign ); | |
| 206 _evbuffer_chain_pin(chain, EVBUFFER_MEM_PINNED_W); | |
| 207 | |
| 208 if ((size_t)at_most > chain->off) { | |
| 209 /* XXXX Cast is safe for now, since win32 has no | |
| 210 mmaped chains. But later, we need to have this | |
| 211 add more WSAbufs if chain->off is greater than | |
| 212 ULONG_MAX */ | |
| 213 b->len = (unsigned long)chain->off; | |
| 214 at_most -= chain->off; | |
| 215 } else { | |
| 216 b->len = (unsigned long)at_most; | |
| 217 ++i; | |
| 218 break; | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 buf_o->n_buffers = i; | |
| 223 _evbuffer_incref(buf); | |
| 224 if (WSASend(buf_o->fd, buf_o->buffers, i, &bytesSent, 0, | |
| 225 &ol->overlapped, NULL)) { | |
| 226 int error = WSAGetLastError(); | |
| 227 if (error != WSA_IO_PENDING) { | |
| 228 /* An actual error. */ | |
| 229 pin_release(buf_o, EVBUFFER_MEM_PINNED_W); | |
| 230 evbuffer_unfreeze(buf, 1); | |
| 231 evbuffer_free(buf); /* decref */ | |
| 232 goto done; | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 buf_o->write_in_progress = 1; | |
| 237 r = 0; | |
| 238 done: | |
| 239 EVBUFFER_UNLOCK(buf); | |
| 240 return r; | |
| 241 } | |
| 242 | |
| 243 int | |
| 244 evbuffer_launch_read(struct evbuffer *buf, size_t at_most, | |
| 245 struct event_overlapped *ol) | |
| 246 { | |
| 247 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); | |
| 248 int r = -1, i; | |
| 249 int nvecs; | |
| 250 int npin=0; | |
| 251 struct evbuffer_chain *chain=NULL, **chainp; | |
| 252 DWORD bytesRead; | |
| 253 DWORD flags = 0; | |
| 254 struct evbuffer_iovec vecs[MAX_WSABUFS]; | |
| 255 | |
| 256 if (!buf_o) | |
| 257 return -1; | |
| 258 EVBUFFER_LOCK(buf); | |
| 259 EVUTIL_ASSERT(!buf_o->write_in_progress); | |
| 260 if (buf->freeze_end || buf_o->read_in_progress) | |
| 261 goto done; | |
| 262 | |
| 263 buf_o->first_pinned = NULL; | |
| 264 buf_o->n_buffers = 0; | |
| 265 memset(buf_o->buffers, 0, sizeof(buf_o->buffers)); | |
| 266 | |
| 267 if (_evbuffer_expand_fast(buf, at_most, MAX_WSABUFS) == -1) | |
| 268 goto done; | |
| 269 evbuffer_freeze(buf, 0); | |
| 270 | |
| 271 nvecs = _evbuffer_read_setup_vecs(buf, at_most, | |
| 272 vecs, MAX_WSABUFS, &chainp, 1); | |
| 273 for (i=0;i<nvecs;++i) { | |
| 274 WSABUF_FROM_EVBUFFER_IOV( | |
| 275 &buf_o->buffers[i], | |
| 276 &vecs[i]); | |
| 277 } | |
| 278 | |
| 279 buf_o->n_buffers = nvecs; | |
| 280 buf_o->first_pinned = chain = *chainp; | |
| 281 | |
| 282 npin=0; | |
| 283 for ( ; chain; chain = chain->next) { | |
| 284 _evbuffer_chain_pin(chain, EVBUFFER_MEM_PINNED_R); | |
| 285 ++npin; | |
| 286 } | |
| 287 EVUTIL_ASSERT(npin == nvecs); | |
| 288 | |
| 289 _evbuffer_incref(buf); | |
| 290 if (WSARecv(buf_o->fd, buf_o->buffers, nvecs, &bytesRead, &flags, | |
| 291 &ol->overlapped, NULL)) { | |
| 292 int error = WSAGetLastError(); | |
| 293 if (error != WSA_IO_PENDING) { | |
| 294 /* An actual error. */ | |
| 295 pin_release(buf_o, EVBUFFER_MEM_PINNED_R); | |
| 296 evbuffer_unfreeze(buf, 0); | |
| 297 evbuffer_free(buf); /* decref */ | |
| 298 goto done; | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 buf_o->read_in_progress = 1; | |
| 303 r = 0; | |
| 304 done: | |
| 305 EVBUFFER_UNLOCK(buf); | |
| 306 return r; | |
| 307 } | |
| 308 | |
| 309 evutil_socket_t | |
| 310 _evbuffer_overlapped_get_fd(struct evbuffer *buf) | |
| 311 { | |
| 312 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); | |
| 313 return buf_o ? buf_o->fd : -1; | |
| 314 } | |
| 315 | |
| 316 void | |
| 317 _evbuffer_overlapped_set_fd(struct evbuffer *buf, evutil_socket_t fd) | |
| 318 { | |
| 319 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); | |
| 320 EVBUFFER_LOCK(buf); | |
| 321 /* XXX is this right?, should it cancel current I/O operations? */ | |
| 322 if (buf_o) | |
| 323 buf_o->fd = fd; | |
| 324 EVBUFFER_UNLOCK(buf); | |
| 325 } |
