The Tor Browser: comparison ipc/chromium/src/third

--1:000000000000
+:df93d4bf2c69
+/*
+* Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. The name of the author may not be used to endorse or promote products
+*    derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#include "event2/event-config.h"
+#ifdef WIN32
+#include <winsock2.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#endif
+#include <sys/types.h>
+#if !defined(WIN32) && defined(_EVENT_HAVE_SYS_TIME_H)
+#include <sys/time.h>
+#endif
+#include <sys/queue.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+#include <errno.h>
+#include <signal.h>
+#include <string.h>
+#include <time.h>
+#include "event-internal.h"
+#include "evmap-internal.h"
+#include "mm-internal.h"
+#include "changelist-internal.h"
+/** An entry for an evmap_io list: notes all the events that want to read or
+	write on a given fd, and the number of each.
+*/
+struct evmap_io {
+	struct event_list events;
+	ev_uint16_t nread;
+	ev_uint16_t nwrite;
+};
+/* An entry for an evmap_signal list: notes all the events that want to know
+when a signal triggers. */
+struct evmap_signal {
+	struct event_list events;
+};
+/* On some platforms, fds start at 0 and increment by 1 as they are
+allocated, and old numbers get used.  For these platforms, we
+implement io maps just like signal maps: as an array of pointers to
+struct evmap_io.  But on other platforms (windows), sockets are not
+0-indexed, not necessarily consecutive, and not necessarily reused.
+There, we use a hashtable to implement evmap_io.
+*/
+#ifdef EVMAP_USE_HT
+struct event_map_entry {
+	HT_ENTRY(event_map_entry) map_node;
+	evutil_socket_t fd;
+	union { /* This is a union in case we need to make more things that can
+			   be in the hashtable. */
+		struct evmap_io evmap_io;
+	} ent;
+};
+/* Helper used by the event_io_map hashtable code; tries to return a good hash
+* of the fd in e->fd. */
+static inline unsigned
+hashsocket(struct event_map_entry *e)
+{
+	/* On win32, in practice, the low 2-3 bits of a SOCKET seem not to
+	 * matter.  Our hashtable implementation really likes low-order bits,
+	 * though, so let's do the rotate-and-add trick. */
+	unsigned h = (unsigned) e->fd;
+	h += (h >> 2) | (h << 30);
+	return h;
+}
+/* Helper used by the event_io_map hashtable code; returns true iff e1 and e2
+* have the same e->fd. */
+static inline int
+eqsocket(struct event_map_entry *e1, struct event_map_entry *e2)
+{
+	return e1->fd == e2->fd;
+}
+HT_PROTOTYPE(event_io_map, event_map_entry, map_node, hashsocket, eqsocket)
+HT_GENERATE(event_io_map, event_map_entry, map_node, hashsocket, eqsocket,
+			0.5, mm_malloc, mm_realloc, mm_free)
+#define GET_IO_SLOT(x, map, slot, type)					\
+	do {								\
+		struct event_map_entry _key, *_ent;			\
+		_key.fd = slot;						\
+		_ent = HT_FIND(event_io_map, map, &_key);		\
+		(x) = _ent ? &_ent->ent.type : NULL;			\
+	} while (0);
+#define GET_IO_SLOT_AND_CTOR(x, map, slot, type, ctor, fdinfo_len)	\
+	do {								\
+		struct event_map_entry _key, *_ent;			\
+		_key.fd = slot;						\
+		_HT_FIND_OR_INSERT(event_io_map, map_node, hashsocket, map, \
+		    event_map_entry, &_key, ptr,			\
+		    {							\
+			    _ent = *ptr;				\
+		    },							\
+		    {							\
+			    _ent = mm_calloc(1,sizeof(struct event_map_entry)+fdinfo_len); \
+			    if (EVUTIL_UNLIKELY(_ent == NULL))		\
+				    return (-1);			\
+			    _ent->fd = slot;				\
+			    (ctor)(&_ent->ent.type);			\
+			    _HT_FOI_INSERT(map_node, map, &_key, _ent, ptr) \
+				});					\
+		(x) = &_ent->ent.type;					\
+	} while (0)
+void evmap_io_initmap(struct event_io_map *ctx)
+{
+	HT_INIT(event_io_map, ctx);
+}
+void evmap_io_clear(struct event_io_map *ctx)
+{
+	struct event_map_entry **ent, **next, *this;
+	for (ent = HT_START(event_io_map, ctx); ent; ent = next) {
+		this = *ent;
+		next = HT_NEXT_RMV(event_io_map, ctx, ent);
+		mm_free(this);
+	}
+	HT_CLEAR(event_io_map, ctx); /* remove all storage held by the ctx. */
+}
+#endif
+/* Set the variable 'x' to the field in event_map 'map' with fields of type
+'struct type *' corresponding to the fd or signal 'slot'.  Set 'x' to NULL
+if there are no entries for 'slot'.  Does no bounds-checking. */
+#define GET_SIGNAL_SLOT(x, map, slot, type)			\
+	(x) = (struct type *)((map)->entries[slot])
+/* As GET_SLOT, but construct the entry for 'slot' if it is not present,
+by allocating enough memory for a 'struct type', and initializing the new
+value by calling the function 'ctor' on it.  Makes the function
+return -1 on allocation failure.
+*/
+#define GET_SIGNAL_SLOT_AND_CTOR(x, map, slot, type, ctor, fdinfo_len)	\
+	do {								\
+		if ((map)->entries[slot] == NULL) {			\
+			(map)->entries[slot] =				\
+			    mm_calloc(1,sizeof(struct type)+fdinfo_len); \
+			if (EVUTIL_UNLIKELY((map)->entries[slot] == NULL)) \
+				return (-1);				\
+			(ctor)((struct type *)(map)->entries[slot]);	\
+		}							\
+		(x) = (struct type *)((map)->entries[slot]);		\
+	} while (0)
+/* If we aren't using hashtables, then define the IO_SLOT macros and functions
+as thin aliases over the SIGNAL_SLOT versions. */
+#ifndef EVMAP_USE_HT
+#define GET_IO_SLOT(x,map,slot,type) GET_SIGNAL_SLOT(x,map,slot,type)
+#define GET_IO_SLOT_AND_CTOR(x,map,slot,type,ctor,fdinfo_len)	\
+	GET_SIGNAL_SLOT_AND_CTOR(x,map,slot,type,ctor,fdinfo_len)
+#define FDINFO_OFFSET sizeof(struct evmap_io)
+void
+evmap_io_initmap(struct event_io_map* ctx)
+{
+	evmap_signal_initmap(ctx);
+}
+void
+evmap_io_clear(struct event_io_map* ctx)
+{
+	evmap_signal_clear(ctx);
+}
+#endif
+/** Expand 'map' with new entries of width 'msize' until it is big enough
+	to store a value in 'slot'.
+*/
+static int
+evmap_make_space(struct event_signal_map *map, int slot, int msize)
+{
+	if (map->nentries <= slot) {
+		int nentries = map->nentries ? map->nentries : 32;
+		void **tmp;
+		while (nentries <= slot)
+			nentries <<= 1;
+		tmp = (void **)mm_realloc(map->entries, nentries * msize);
+		if (tmp == NULL)
+			return (-1);
+		memset(&tmp[map->nentries], 0,
+		    (nentries - map->nentries) * msize);
+		map->nentries = nentries;
+		map->entries = tmp;
+	}
+	return (0);
+}
+void
+evmap_signal_initmap(struct event_signal_map *ctx)
+{
+	ctx->nentries = 0;
+	ctx->entries = NULL;
+}
+void
+evmap_signal_clear(struct event_signal_map *ctx)
+{
+	if (ctx->entries != NULL) {
+		int i;
+		for (i = 0; i < ctx->nentries; ++i) {
+			if (ctx->entries[i] != NULL)
+				mm_free(ctx->entries[i]);
+		}
+		mm_free(ctx->entries);
+		ctx->entries = NULL;
+	}
+	ctx->nentries = 0;
+}
+/* code specific to file descriptors */
+/** Constructor for struct evmap_io */
+static void
+evmap_io_init(struct evmap_io *entry)
+{
+	TAILQ_INIT(&entry->events);
+	entry->nread = 0;
+	entry->nwrite = 0;
+}
+/* return -1 on error, 0 on success if nothing changed in the event backend,
+* and 1 on success if something did. */
+int
+evmap_io_add(struct event_base *base, evutil_socket_t fd, struct event *ev)
+{
+	const struct eventop *evsel = base->evsel;
+	struct event_io_map *io = &base->io;
+	struct evmap_io *ctx = NULL;
+	int nread, nwrite, retval = 0;
+	short res = 0, old = 0;
+	struct event *old_ev;
+	EVUTIL_ASSERT(fd == ev->ev_fd);
+	if (fd < 0)
+		return 0;
+#ifndef EVMAP_USE_HT
+	if (fd >= io->nentries) {
+		if (evmap_make_space(io, fd, sizeof(struct evmap_io *)) == -1)
+			return (-1);
+	}
+#endif
+	GET_IO_SLOT_AND_CTOR(ctx, io, fd, evmap_io, evmap_io_init,
+						 evsel->fdinfo_len);
+	nread = ctx->nread;
+	nwrite = ctx->nwrite;
+	if (nread)
+		old |= EV_READ;
+	if (nwrite)
+		old |= EV_WRITE;
+	if (ev->ev_events & EV_READ) {
+		if (++nread == 1)
+			res |= EV_READ;
+	}
+	if (ev->ev_events & EV_WRITE) {
+		if (++nwrite == 1)
+			res |= EV_WRITE;
+	}
+	if (EVUTIL_UNLIKELY(nread > 0xffff || nwrite > 0xffff)) {
+		event_warnx("Too many events reading or writing on fd %d",
+		    (int)fd);
+		return -1;
+	}
+	if (EVENT_DEBUG_MODE_IS_ON() &&
+	    (old_ev = TAILQ_FIRST(&ctx->events)) &&
+	    (old_ev->ev_events&EV_ET) != (ev->ev_events&EV_ET)) {
+		event_warnx("Tried to mix edge-triggered and non-edge-triggered"
+		    " events on fd %d", (int)fd);
+		return -1;
+	}
+	if (res) {
+		void *extra = ((char*)ctx) + sizeof(struct evmap_io);
+		/* XXX(niels): we cannot mix edge-triggered and
+		 * level-triggered, we should probably assert on
+		 * this. */
+		if (evsel->add(base, ev->ev_fd,
+			old, (ev->ev_events & EV_ET) | res, extra) == -1)
+			return (-1);
+		retval = 1;
+	}
+	ctx->nread = (ev_uint16_t) nread;
+	ctx->nwrite = (ev_uint16_t) nwrite;
+	TAILQ_INSERT_TAIL(&ctx->events, ev, ev_io_next);
+	return (retval);
+}
+/* return -1 on error, 0 on success if nothing changed in the event backend,
+* and 1 on success if something did. */
+int
+evmap_io_del(struct event_base *base, evutil_socket_t fd, struct event *ev)
+{
+	const struct eventop *evsel = base->evsel;
+	struct event_io_map *io = &base->io;
+	struct evmap_io *ctx;
+	int nread, nwrite, retval = 0;
+	short res = 0, old = 0;
+	if (fd < 0)
+		return 0;
+	EVUTIL_ASSERT(fd == ev->ev_fd);
+#ifndef EVMAP_USE_HT
+	if (fd >= io->nentries)
+		return (-1);
+#endif
+	GET_IO_SLOT(ctx, io, fd, evmap_io);
+	nread = ctx->nread;
+	nwrite = ctx->nwrite;
+	if (nread)
+		old |= EV_READ;
+	if (nwrite)
+		old |= EV_WRITE;
+	if (ev->ev_events & EV_READ) {
+		if (--nread == 0)
+			res |= EV_READ;
+		EVUTIL_ASSERT(nread >= 0);
+	}
+	if (ev->ev_events & EV_WRITE) {
+		if (--nwrite == 0)
+			res |= EV_WRITE;
+		EVUTIL_ASSERT(nwrite >= 0);
+	}
+	if (res) {
+		void *extra = ((char*)ctx) + sizeof(struct evmap_io);
+		if (evsel->del(base, ev->ev_fd, old, res, extra) == -1)
+			return (-1);
+		retval = 1;
+	}
+	ctx->nread = nread;
+	ctx->nwrite = nwrite;
+	TAILQ_REMOVE(&ctx->events, ev, ev_io_next);
+	return (retval);
+}
+void
+evmap_io_active(struct event_base *base, evutil_socket_t fd, short events)
+{
+	struct event_io_map *io = &base->io;
+	struct evmap_io *ctx;
+	struct event *ev;
+#ifndef EVMAP_USE_HT
+	EVUTIL_ASSERT(fd < io->nentries);
+#endif
+	GET_IO_SLOT(ctx, io, fd, evmap_io);
+	EVUTIL_ASSERT(ctx);
+	TAILQ_FOREACH(ev, &ctx->events, ev_io_next) {
+		if (ev->ev_events & events)
+			event_active_nolock(ev, ev->ev_events & events, 1);
+	}
+}
+/* code specific to signals */
+static void
+evmap_signal_init(struct evmap_signal *entry)
+{
+	TAILQ_INIT(&entry->events);
+}
+int
+evmap_signal_add(struct event_base *base, int sig, struct event *ev)
+{
+	const struct eventop *evsel = base->evsigsel;
+	struct event_signal_map *map = &base->sigmap;
+	struct evmap_signal *ctx = NULL;
+	if (sig >= map->nentries) {
+		if (evmap_make_space(
+			map, sig, sizeof(struct evmap_signal *)) == -1)
+			return (-1);
+	}
+	GET_SIGNAL_SLOT_AND_CTOR(ctx, map, sig, evmap_signal, evmap_signal_init,
+	    base->evsigsel->fdinfo_len);
+	if (TAILQ_EMPTY(&ctx->events)) {
+		if (evsel->add(base, ev->ev_fd, 0, EV_SIGNAL, NULL)
+		    == -1)
+			return (-1);
+	}
+	TAILQ_INSERT_TAIL(&ctx->events, ev, ev_signal_next);
+	return (1);
+}
+int
+evmap_signal_del(struct event_base *base, int sig, struct event *ev)
+{
+	const struct eventop *evsel = base->evsigsel;
+	struct event_signal_map *map = &base->sigmap;
+	struct evmap_signal *ctx;
+	if (sig >= map->nentries)
+		return (-1);
+	GET_SIGNAL_SLOT(ctx, map, sig, evmap_signal);
+	if (TAILQ_FIRST(&ctx->events) == TAILQ_LAST(&ctx->events, event_list)) {
+		if (evsel->del(base, ev->ev_fd, 0, EV_SIGNAL, NULL) == -1)
+			return (-1);
+	}
+	TAILQ_REMOVE(&ctx->events, ev, ev_signal_next);
+	return (1);
+}
+void
+evmap_signal_active(struct event_base *base, evutil_socket_t sig, int ncalls)
+{
+	struct event_signal_map *map = &base->sigmap;
+	struct evmap_signal *ctx;
+	struct event *ev;
+	EVUTIL_ASSERT(sig < map->nentries);
+	GET_SIGNAL_SLOT(ctx, map, sig, evmap_signal);
+	TAILQ_FOREACH(ev, &ctx->events, ev_signal_next)
+		event_active_nolock(ev, EV_SIGNAL, ncalls);
+}
+void *
+evmap_io_get_fdinfo(struct event_io_map *map, evutil_socket_t fd)
+{
+	struct evmap_io *ctx;
+	GET_IO_SLOT(ctx, map, fd, evmap_io);
+	if (ctx)
+		return ((char*)ctx) + sizeof(struct evmap_io);
+	else
+		return NULL;
+}
+/** Per-fd structure for use with changelists.  It keeps track, for each fd or
+* signal using the changelist, of where its entry in the changelist is.
+*/
+struct event_changelist_fdinfo {
+	int idxplus1; /* this is the index +1, so that memset(0) will make it
+		       * a no-such-element */
+};
+void
+event_changelist_init(struct event_changelist *changelist)
+{
+	changelist->changes = NULL;
+	changelist->changes_size = 0;
+	changelist->n_changes = 0;
+}
+/** Helper: return the changelist_fdinfo corresponding to a given change. */
+static inline struct event_changelist_fdinfo *
+event_change_get_fdinfo(struct event_base *base,
+const struct event_change *change)
+{
+	char *ptr;
+	if (change->read_change & EV_CHANGE_SIGNAL) {
+		struct evmap_signal *ctx;
+		GET_SIGNAL_SLOT(ctx, &base->sigmap, change->fd, evmap_signal);
+		ptr = ((char*)ctx) + sizeof(struct evmap_signal);
+	} else {
+		struct evmap_io *ctx;
+		GET_IO_SLOT(ctx, &base->io, change->fd, evmap_io);
+		ptr = ((char*)ctx) + sizeof(struct evmap_io);
+	}
+	return (void*)ptr;
+}
+#ifdef DEBUG_CHANGELIST
+/** Make sure that the changelist is consistent with the evmap structures. */
+static void
+event_changelist_check(struct event_base *base)
+{
+	int i;
+	struct event_changelist *changelist = &base->changelist;
+	EVUTIL_ASSERT(changelist->changes_size >= changelist->n_changes);
+	for (i = 0; i < changelist->n_changes; ++i) {
+		struct event_change *c = &changelist->changes[i];
+		struct event_changelist_fdinfo *f;
+		EVUTIL_ASSERT(c->fd >= 0);
+		f = event_change_get_fdinfo(base, c);
+		EVUTIL_ASSERT(f);
+		EVUTIL_ASSERT(f->idxplus1 == i + 1);
+	}
+	for (i = 0; i < base->io.nentries; ++i) {
+		struct evmap_io *io = base->io.entries[i];
+		struct event_changelist_fdinfo *f;
+		if (!io)
+			continue;
+		f = (void*)
+		    ( ((char*)io) + sizeof(struct evmap_io) );
+		if (f->idxplus1) {
+			struct event_change *c = &changelist->changes[f->idxplus1 - 1];
+			EVUTIL_ASSERT(c->fd == i);
+		}
+	}
+}
+#else
+#define event_changelist_check(base)  ((void)0)
+#endif
+void
+event_changelist_remove_all(struct event_changelist *changelist,
+struct event_base *base)
+{
+	int i;
+	event_changelist_check(base);
+	for (i = 0; i < changelist->n_changes; ++i) {
+		struct event_change *ch = &changelist->changes[i];
+		struct event_changelist_fdinfo *fdinfo =
+		    event_change_get_fdinfo(base, ch);
+		EVUTIL_ASSERT(fdinfo->idxplus1 == i + 1);
+		fdinfo->idxplus1 = 0;
+	}
+	changelist->n_changes = 0;
+	event_changelist_check(base);
+}
+void
+event_changelist_freemem(struct event_changelist *changelist)
+{
+	if (changelist->changes)
+		mm_free(changelist->changes);
+	event_changelist_init(changelist); /* zero it all out. */
+}
+/** Increase the size of 'changelist' to hold more changes. */
+static int
+event_changelist_grow(struct event_changelist *changelist)
+{
+	int new_size;
+	struct event_change *new_changes;
+	if (changelist->changes_size < 64)
+		new_size = 64;
+	else
+		new_size = changelist->changes_size * 2;
+	new_changes = mm_realloc(changelist->changes,
+	    new_size * sizeof(struct event_change));
+	if (EVUTIL_UNLIKELY(new_changes == NULL))
+		return (-1);
+	changelist->changes = new_changes;
+	changelist->changes_size = new_size;
+	return (0);
+}
+/** Return a pointer to the changelist entry for the file descriptor or signal
+* 'fd', whose fdinfo is 'fdinfo'.  If none exists, construct it, setting its
+* old_events field to old_events.
+*/
+static struct event_change *
+event_changelist_get_or_construct(struct event_changelist *changelist,
+evutil_socket_t fd,
+short old_events,
+struct event_changelist_fdinfo *fdinfo)
+{
+	struct event_change *change;
+	if (fdinfo->idxplus1 == 0) {
+		int idx;
+		EVUTIL_ASSERT(changelist->n_changes <= changelist->changes_size);
+		if (changelist->n_changes == changelist->changes_size) {
+			if (event_changelist_grow(changelist) < 0)
+				return NULL;
+		}
+		idx = changelist->n_changes++;
+		change = &changelist->changes[idx];
+		fdinfo->idxplus1 = idx + 1;
+		memset(change, 0, sizeof(struct event_change));
+		change->fd = fd;
+		change->old_events = old_events;
+	} else {
+		change = &changelist->changes[fdinfo->idxplus1 - 1];
+		EVUTIL_ASSERT(change->fd == fd);
+	}
+	return change;
+}
+int
+event_changelist_add(struct event_base *base, evutil_socket_t fd, short old, short events,
+void *p)
+{
+	struct event_changelist *changelist = &base->changelist;
+	struct event_changelist_fdinfo *fdinfo = p;
+	struct event_change *change;
+	event_changelist_check(base);
+	change = event_changelist_get_or_construct(changelist, fd, old, fdinfo);
+	if (!change)
+		return -1;
+	/* An add replaces any previous delete, but doesn't result in a no-op,
+	 * since the delete might fail (because the fd had been closed since
+	 * the last add, for instance. */
+	if (events & (EV_READ|EV_SIGNAL)) {
+		change->read_change = EV_CHANGE_ADD |
+		    (events & (EV_ET|EV_PERSIST|EV_SIGNAL));
+	}
+	if (events & EV_WRITE) {
+		change->write_change = EV_CHANGE_ADD |
+		    (events & (EV_ET|EV_PERSIST|EV_SIGNAL));
+	}
+	event_changelist_check(base);
+	return (0);
+}
+int
+event_changelist_del(struct event_base *base, evutil_socket_t fd, short old, short events,
+void *p)
+{
+	struct event_changelist *changelist = &base->changelist;
+	struct event_changelist_fdinfo *fdinfo = p;
+	struct event_change *change;
+	event_changelist_check(base);
+	change = event_changelist_get_or_construct(changelist, fd, old, fdinfo);
+	event_changelist_check(base);
+	if (!change)
+		return -1;
+	/* A delete removes any previous add, rather than replacing it:
+	   on those platforms where "add, delete, dispatch" is not the same
+	   as "no-op, dispatch", we want the no-op behavior.
+	   As well as checking the current operation we should also check
+	   the original set of events to make sure were not ignoring
+	   the case where the add operation is present on an event that
+	   was already set.
+	   If we have a no-op item, we could remove it it from the list
+	   entirely, but really there's not much point: skipping the no-op
+	   change when we do the dispatch later is far cheaper than rejuggling
+	   the array now.
+	   As this stands, it also lets through deletions of events that are
+	   not currently set.
+	 */
+	if (events & (EV_READ|EV_SIGNAL)) {
+		if (!(change->old_events & (EV_READ | EV_SIGNAL)) &&
+		    (change->read_change & EV_CHANGE_ADD))
+			change->read_change = 0;
+		else
+			change->read_change = EV_CHANGE_DEL;
+	}
+	if (events & EV_WRITE) {
+		if (!(change->old_events & EV_WRITE) &&
+		    (change->write_change & EV_CHANGE_ADD))
+			change->write_change = 0;
+		else
+			change->write_change = EV_CHANGE_DEL;
+	}
+	event_changelist_check(base);
+	return (0);
+}
+void
+evmap_check_integrity(struct event_base *base)
+{
+#define EVLIST_X_SIGFOUND 0x1000
+#define EVLIST_X_IOFOUND 0x2000
+	evutil_socket_t i;
+	struct event *ev;
+	struct event_io_map *io = &base->io;
+	struct event_signal_map *sigmap = &base->sigmap;
+#ifdef EVMAP_USE_HT
+	struct event_map_entry **mapent;
+#endif
+	int nsignals, ntimers, nio;
+	nsignals = ntimers = nio = 0;
+	TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {
+		EVUTIL_ASSERT(ev->ev_flags & EVLIST_INSERTED);
+		EVUTIL_ASSERT(ev->ev_flags & EVLIST_INIT);
+		ev->ev_flags &= ~(EVLIST_X_SIGFOUND|EVLIST_X_IOFOUND);
+	}
+#ifdef EVMAP_USE_HT
+	HT_FOREACH(mapent, event_io_map, io) {
+		struct evmap_io *ctx = &(*mapent)->ent.evmap_io;
+		i = (*mapent)->fd;
+#else
+	for (i = 0; i < io->nentries; ++i) {
+		struct evmap_io *ctx = io->entries[i];
+		if (!ctx)
+			continue;
+#endif
+		TAILQ_FOREACH(ev, &ctx->events, ev_io_next) {
+			EVUTIL_ASSERT(!(ev->ev_flags & EVLIST_X_IOFOUND));
+			EVUTIL_ASSERT(ev->ev_fd == i);
+			ev->ev_flags |= EVLIST_X_IOFOUND;
+			nio++;
+		}
+	}
+	for (i = 0; i < sigmap->nentries; ++i) {
+		struct evmap_signal *ctx = sigmap->entries[i];
+		if (!ctx)
+			continue;
+		TAILQ_FOREACH(ev, &ctx->events, ev_signal_next) {
+			EVUTIL_ASSERT(!(ev->ev_flags & EVLIST_X_SIGFOUND));
+			EVUTIL_ASSERT(ev->ev_fd == i);
+			ev->ev_flags |= EVLIST_X_SIGFOUND;
+			nsignals++;
+		}
+	}
+	TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {
+		if (ev->ev_events & (EV_READ|EV_WRITE)) {
+			EVUTIL_ASSERT(ev->ev_flags & EVLIST_X_IOFOUND);
+			--nio;
+		}
+		if (ev->ev_events & EV_SIGNAL) {
+			EVUTIL_ASSERT(ev->ev_flags & EVLIST_X_SIGFOUND);
+			--nsignals;
+		}
+	}
+	EVUTIL_ASSERT(nio == 0);
+	EVUTIL_ASSERT(nsignals == 0);
+	/* There is no "EVUTIL_ASSERT(ntimers == 0)": eventqueue is only for
+	 * pending signals and io events.
+	 */
+}

The Tor Browser / file comparison

comparison: ipc/chromium/src/third_party/libevent/evmap.c

ipc/chromium/src/third_party/libevent/evmap.c