The Tor Browser / file comparison
comparison: ipc/chromium/src/third_party/libevent/bufferevent_pair.c
ipc/chromium/src/third_party/libevent/bufferevent_pair.c
- branch
- TOR_BUG_9701
- changeset 11
- deefc01c0e14
equal
deleted
inserted
replaced
| -1:000000000000 | 0:688813bf26a5 |
|---|---|
| 1 /* | |
| 2 * Copyright (c) 2009-2012 Niels Provos, 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 #include <sys/types.h> | |
| 28 | |
| 29 #ifdef WIN32 | |
| 30 #include <winsock2.h> | |
| 31 #endif | |
| 32 | |
| 33 #include "event2/event-config.h" | |
| 34 | |
| 35 #include "event2/util.h" | |
| 36 #include "event2/buffer.h" | |
| 37 #include "event2/bufferevent.h" | |
| 38 #include "event2/bufferevent_struct.h" | |
| 39 #include "event2/event.h" | |
| 40 #include "defer-internal.h" | |
| 41 #include "bufferevent-internal.h" | |
| 42 #include "mm-internal.h" | |
| 43 #include "util-internal.h" | |
| 44 | |
| 45 struct bufferevent_pair { | |
| 46 struct bufferevent_private bev; | |
| 47 struct bufferevent_pair *partner; | |
| 48 }; | |
| 49 | |
| 50 | |
| 51 /* Given a bufferevent that's really a bev part of a bufferevent_pair, | |
| 52 * return that bufferevent_filtered. Returns NULL otherwise.*/ | |
| 53 static inline struct bufferevent_pair * | |
| 54 upcast(struct bufferevent *bev) | |
| 55 { | |
| 56 struct bufferevent_pair *bev_p; | |
| 57 if (bev->be_ops != &bufferevent_ops_pair) | |
| 58 return NULL; | |
| 59 bev_p = EVUTIL_UPCAST(bev, struct bufferevent_pair, bev.bev); | |
| 60 EVUTIL_ASSERT(bev_p->bev.bev.be_ops == &bufferevent_ops_pair); | |
| 61 return bev_p; | |
| 62 } | |
| 63 | |
| 64 #define downcast(bev_pair) (&(bev_pair)->bev.bev) | |
| 65 | |
| 66 static inline void | |
| 67 incref_and_lock(struct bufferevent *b) | |
| 68 { | |
| 69 struct bufferevent_pair *bevp; | |
| 70 _bufferevent_incref_and_lock(b); | |
| 71 bevp = upcast(b); | |
| 72 if (bevp->partner) | |
| 73 _bufferevent_incref_and_lock(downcast(bevp->partner)); | |
| 74 } | |
| 75 | |
| 76 static inline void | |
| 77 decref_and_unlock(struct bufferevent *b) | |
| 78 { | |
| 79 struct bufferevent_pair *bevp = upcast(b); | |
| 80 if (bevp->partner) | |
| 81 _bufferevent_decref_and_unlock(downcast(bevp->partner)); | |
| 82 _bufferevent_decref_and_unlock(b); | |
| 83 } | |
| 84 | |
| 85 /* XXX Handle close */ | |
| 86 | |
| 87 static void be_pair_outbuf_cb(struct evbuffer *, | |
| 88 const struct evbuffer_cb_info *, void *); | |
| 89 | |
| 90 static struct bufferevent_pair * | |
| 91 bufferevent_pair_elt_new(struct event_base *base, | |
| 92 int options) | |
| 93 { | |
| 94 struct bufferevent_pair *bufev; | |
| 95 if (! (bufev = mm_calloc(1, sizeof(struct bufferevent_pair)))) | |
| 96 return NULL; | |
| 97 if (bufferevent_init_common(&bufev->bev, base, &bufferevent_ops_pair, | |
| 98 options)) { | |
| 99 mm_free(bufev); | |
| 100 return NULL; | |
| 101 } | |
| 102 if (!evbuffer_add_cb(bufev->bev.bev.output, be_pair_outbuf_cb, bufev)) { | |
| 103 bufferevent_free(downcast(bufev)); | |
| 104 return NULL; | |
| 105 } | |
| 106 | |
| 107 _bufferevent_init_generic_timeout_cbs(&bufev->bev.bev); | |
| 108 | |
| 109 return bufev; | |
| 110 } | |
| 111 | |
| 112 int | |
| 113 bufferevent_pair_new(struct event_base *base, int options, | |
| 114 struct bufferevent *pair[2]) | |
| 115 { | |
| 116 struct bufferevent_pair *bufev1 = NULL, *bufev2 = NULL; | |
| 117 int tmp_options; | |
| 118 | |
| 119 options |= BEV_OPT_DEFER_CALLBACKS; | |
| 120 tmp_options = options & ~BEV_OPT_THREADSAFE; | |
| 121 | |
| 122 bufev1 = bufferevent_pair_elt_new(base, options); | |
| 123 if (!bufev1) | |
| 124 return -1; | |
| 125 bufev2 = bufferevent_pair_elt_new(base, tmp_options); | |
| 126 if (!bufev2) { | |
| 127 bufferevent_free(downcast(bufev1)); | |
| 128 return -1; | |
| 129 } | |
| 130 | |
| 131 if (options & BEV_OPT_THREADSAFE) { | |
| 132 /*XXXX check return */ | |
| 133 bufferevent_enable_locking(downcast(bufev2), bufev1->bev.lock); | |
| 134 } | |
| 135 | |
| 136 bufev1->partner = bufev2; | |
| 137 bufev2->partner = bufev1; | |
| 138 | |
| 139 evbuffer_freeze(downcast(bufev1)->input, 0); | |
| 140 evbuffer_freeze(downcast(bufev1)->output, 1); | |
| 141 evbuffer_freeze(downcast(bufev2)->input, 0); | |
| 142 evbuffer_freeze(downcast(bufev2)->output, 1); | |
| 143 | |
| 144 pair[0] = downcast(bufev1); | |
| 145 pair[1] = downcast(bufev2); | |
| 146 | |
| 147 return 0; | |
| 148 } | |
| 149 | |
| 150 static void | |
| 151 be_pair_transfer(struct bufferevent *src, struct bufferevent *dst, | |
| 152 int ignore_wm) | |
| 153 { | |
| 154 size_t src_size, dst_size; | |
| 155 size_t n; | |
| 156 | |
| 157 evbuffer_unfreeze(src->output, 1); | |
| 158 evbuffer_unfreeze(dst->input, 0); | |
| 159 | |
| 160 if (dst->wm_read.high) { | |
| 161 dst_size = evbuffer_get_length(dst->input); | |
| 162 if (dst_size < dst->wm_read.high) { | |
| 163 n = dst->wm_read.high - dst_size; | |
| 164 evbuffer_remove_buffer(src->output, dst->input, n); | |
| 165 } else { | |
| 166 if (!ignore_wm) | |
| 167 goto done; | |
| 168 n = evbuffer_get_length(src->output); | |
| 169 evbuffer_add_buffer(dst->input, src->output); | |
| 170 } | |
| 171 } else { | |
| 172 n = evbuffer_get_length(src->output); | |
| 173 evbuffer_add_buffer(dst->input, src->output); | |
| 174 } | |
| 175 | |
| 176 if (n) { | |
| 177 BEV_RESET_GENERIC_READ_TIMEOUT(dst); | |
| 178 | |
| 179 if (evbuffer_get_length(dst->output)) | |
| 180 BEV_RESET_GENERIC_WRITE_TIMEOUT(dst); | |
| 181 else | |
| 182 BEV_DEL_GENERIC_WRITE_TIMEOUT(dst); | |
| 183 } | |
| 184 | |
| 185 src_size = evbuffer_get_length(src->output); | |
| 186 dst_size = evbuffer_get_length(dst->input); | |
| 187 | |
| 188 if (dst_size >= dst->wm_read.low) { | |
| 189 _bufferevent_run_readcb(dst); | |
| 190 } | |
| 191 if (src_size <= src->wm_write.low) { | |
| 192 _bufferevent_run_writecb(src); | |
| 193 } | |
| 194 done: | |
| 195 evbuffer_freeze(src->output, 1); | |
| 196 evbuffer_freeze(dst->input, 0); | |
| 197 } | |
| 198 | |
| 199 static inline int | |
| 200 be_pair_wants_to_talk(struct bufferevent_pair *src, | |
| 201 struct bufferevent_pair *dst) | |
| 202 { | |
| 203 return (downcast(src)->enabled & EV_WRITE) && | |
| 204 (downcast(dst)->enabled & EV_READ) && | |
| 205 !dst->bev.read_suspended && | |
| 206 evbuffer_get_length(downcast(src)->output); | |
| 207 } | |
| 208 | |
| 209 static void | |
| 210 be_pair_outbuf_cb(struct evbuffer *outbuf, | |
| 211 const struct evbuffer_cb_info *info, void *arg) | |
| 212 { | |
| 213 struct bufferevent_pair *bev_pair = arg; | |
| 214 struct bufferevent_pair *partner = bev_pair->partner; | |
| 215 | |
| 216 incref_and_lock(downcast(bev_pair)); | |
| 217 | |
| 218 if (info->n_added > info->n_deleted && partner) { | |
| 219 /* We got more data. If the other side's reading, then | |
| 220 hand it over. */ | |
| 221 if (be_pair_wants_to_talk(bev_pair, partner)) { | |
| 222 be_pair_transfer(downcast(bev_pair), downcast(partner), 0); | |
| 223 } | |
| 224 } | |
| 225 | |
| 226 decref_and_unlock(downcast(bev_pair)); | |
| 227 } | |
| 228 | |
| 229 static int | |
| 230 be_pair_enable(struct bufferevent *bufev, short events) | |
| 231 { | |
| 232 struct bufferevent_pair *bev_p = upcast(bufev); | |
| 233 struct bufferevent_pair *partner = bev_p->partner; | |
| 234 | |
| 235 incref_and_lock(bufev); | |
| 236 | |
| 237 if (events & EV_READ) { | |
| 238 BEV_RESET_GENERIC_READ_TIMEOUT(bufev); | |
| 239 } | |
| 240 if ((events & EV_WRITE) && evbuffer_get_length(bufev->output)) | |
| 241 BEV_RESET_GENERIC_WRITE_TIMEOUT(bufev); | |
| 242 | |
| 243 /* We're starting to read! Does the other side have anything to write?*/ | |
| 244 if ((events & EV_READ) && partner && | |
| 245 be_pair_wants_to_talk(partner, bev_p)) { | |
| 246 be_pair_transfer(downcast(partner), bufev, 0); | |
| 247 } | |
| 248 /* We're starting to write! Does the other side want to read? */ | |
| 249 if ((events & EV_WRITE) && partner && | |
| 250 be_pair_wants_to_talk(bev_p, partner)) { | |
| 251 be_pair_transfer(bufev, downcast(partner), 0); | |
| 252 } | |
| 253 decref_and_unlock(bufev); | |
| 254 return 0; | |
| 255 } | |
| 256 | |
| 257 static int | |
| 258 be_pair_disable(struct bufferevent *bev, short events) | |
| 259 { | |
| 260 if (events & EV_READ) { | |
| 261 BEV_DEL_GENERIC_READ_TIMEOUT(bev); | |
| 262 } | |
| 263 if (events & EV_WRITE) | |
| 264 BEV_DEL_GENERIC_WRITE_TIMEOUT(bev); | |
| 265 return 0; | |
| 266 } | |
| 267 | |
| 268 static void | |
| 269 be_pair_destruct(struct bufferevent *bev) | |
| 270 { | |
| 271 struct bufferevent_pair *bev_p = upcast(bev); | |
| 272 | |
| 273 if (bev_p->partner) { | |
| 274 bev_p->partner->partner = NULL; | |
| 275 bev_p->partner = NULL; | |
| 276 } | |
| 277 | |
| 278 _bufferevent_del_generic_timeout_cbs(bev); | |
| 279 } | |
| 280 | |
| 281 static int | |
| 282 be_pair_flush(struct bufferevent *bev, short iotype, | |
| 283 enum bufferevent_flush_mode mode) | |
| 284 { | |
| 285 struct bufferevent_pair *bev_p = upcast(bev); | |
| 286 struct bufferevent *partner; | |
| 287 incref_and_lock(bev); | |
| 288 if (!bev_p->partner) | |
| 289 return -1; | |
| 290 | |
| 291 partner = downcast(bev_p->partner); | |
| 292 | |
| 293 if (mode == BEV_NORMAL) | |
| 294 return 0; | |
| 295 | |
| 296 if ((iotype & EV_READ) != 0) | |
| 297 be_pair_transfer(partner, bev, 1); | |
| 298 | |
| 299 if ((iotype & EV_WRITE) != 0) | |
| 300 be_pair_transfer(bev, partner, 1); | |
| 301 | |
| 302 if (mode == BEV_FINISHED) { | |
| 303 _bufferevent_run_eventcb(partner, iotype|BEV_EVENT_EOF); | |
| 304 } | |
| 305 decref_and_unlock(bev); | |
| 306 return 0; | |
| 307 } | |
| 308 | |
| 309 struct bufferevent * | |
| 310 bufferevent_pair_get_partner(struct bufferevent *bev) | |
| 311 { | |
| 312 struct bufferevent_pair *bev_p; | |
| 313 struct bufferevent *partner; | |
| 314 bev_p = upcast(bev); | |
| 315 if (! bev_p) | |
| 316 return NULL; | |
| 317 | |
| 318 incref_and_lock(bev); | |
| 319 partner = downcast(bev_p->partner); | |
| 320 decref_and_unlock(bev); | |
| 321 return partner; | |
| 322 } | |
| 323 | |
| 324 const struct bufferevent_ops bufferevent_ops_pair = { | |
| 325 "pair_elt", | |
| 326 evutil_offsetof(struct bufferevent_pair, bev.bev), | |
| 327 be_pair_enable, | |
| 328 be_pair_disable, | |
| 329 be_pair_destruct, | |
| 330 _bufferevent_generic_adj_timeouts, | |
| 331 be_pair_flush, | |
| 332 NULL, /* ctrl */ | |
| 333 }; |
