woshiniuren
diff --git a/‎arc4random.c
+4-4 b/‎arc4random.c
+4-4
diff --git a/‎buffer.c
+23-23 b/‎buffer.c
+23-23
diff --git a/‎buffer_iocp.c
+6-6 b/‎buffer_iocp.c
+6-6
diff --git a/‎bufferevent-internal.h
+12-12 b/‎bufferevent-internal.h
+12-12
@@ -261,7 +261,7 @@ arc4_seed_proc_sys_kernel_random_uuid(void)
 	unsigned char entropy[64];
 	int bytes, n, i, nybbles;
 	for (bytes = 0; bytes<ADD_ENTROPY; ) {
-		fd = evutil_open_closeonexec("/proc/sys/kernel/random/uuid", O_RDONLY, 0);
+		fd = evutil_open_closeonexec_("/proc/sys/kernel/random/uuid", O_RDONLY, 0);
 		if (fd < 0)
 			return -1;
 		n = read(fd, buf, sizeof(buf));
@@ -270,8 +270,8 @@ arc4_seed_proc_sys_kernel_random_uuid(void)
 			return -1;
 		memset(entropy, 0, sizeof(entropy));
 		for (i=nybbles=0; i<n; ++i) {
-			if (EVUTIL_ISXDIGIT(buf[i])) {
-				int nyb = evutil_hex_char_to_int(buf[i]);
+			if (EVUTIL_ISXDIGIT_(buf[i])) {
+				int nyb = evutil_hex_char_to_int_(buf[i]);
 				if (nybbles & 1) {
 					entropy[nybbles/2] |= nyb;
 				} else {
@@ -305,7 +305,7 @@ arc4_seed_urandom(void)
 	size_t n;
 
 	for (i = 0; filenames[i]; ++i) {
-		fd = evutil_open_closeonexec(filenames[i], O_RDONLY, 0);
+		fd = evutil_open_closeonexec_(filenames[i], O_RDONLY, 0);
 		if (fd<0)
 			continue;
 		n = read_all(fd, buf, sizeof(buf));
 
@@ -402,9 +402,9 @@ int
 evbuffer_defer_callbacks(struct evbuffer *buffer, struct event_base *base)
 {
 	EVBUFFER_LOCK(buffer);
-	buffer->cb_queue = event_base_get_deferred_cb_queue(base);
+	buffer->cb_queue = event_base_get_deferred_cb_queue_(base);
 	buffer->deferred_cbs = 1;
-	event_deferred_cb_init(&buffer->deferred,
+	event_deferred_cb_init_(&buffer->deferred,
 	    evbuffer_deferred_callback, buffer);
 	EVBUFFER_UNLOCK(buffer);
 	return 0;
@@ -435,7 +435,7 @@ evbuffer_enable_locking(struct evbuffer *buf, void *lock)
 }
 
 void
-evbuffer_set_parent(struct evbuffer *buf, struct bufferevent *bev)
+evbuffer_set_parent_(struct evbuffer *buf, struct bufferevent *bev)
 {
 	EVBUFFER_LOCK(buf);
 	buf->parent = bev;
@@ -501,7 +501,7 @@ evbuffer_run_callbacks(struct evbuffer *buffer, int running_deferred)
 }
 
 void
-evbuffer_invoke_callbacks(struct evbuffer *buffer)
+evbuffer_invoke_callbacks_(struct evbuffer *buffer)
 {
 	if (LIST_EMPTY(&buffer->callbacks)) {
 		buffer->n_add_for_cb = buffer->n_del_for_cb = 0;
@@ -513,9 +513,9 @@ evbuffer_invoke_callbacks(struct evbuffer *buffer)
 			return;
 		evbuffer_incref_and_lock_(buffer);
 		if (buffer->parent)
-			bufferevent_incref(buffer->parent);
+			bufferevent_incref_(buffer->parent);
 		EVBUFFER_UNLOCK(buffer);
-		event_deferred_cb_schedule(buffer->cb_queue, &buffer->deferred);
+		event_deferred_cb_schedule_(buffer->cb_queue, &buffer->deferred);
 	}
 
 	evbuffer_run_callbacks(buffer, 0);
@@ -534,7 +534,7 @@ evbuffer_deferred_callback(struct deferred_cb *cb, void *arg)
 	evbuffer_run_callbacks(buffer, 1);
 	evbuffer_decref_and_unlock_(buffer);
 	if (parent)
-		bufferevent_decref(parent);
+		bufferevent_decref_(parent);
 }
 
 static void
@@ -567,7 +567,7 @@ evbuffer_decref_and_unlock_(struct evbuffer *buffer)
 	}
 	evbuffer_remove_all_callbacks(buffer);
 	if (buffer->deferred_cbs)
-		event_deferred_cb_cancel(buffer->cb_queue, &buffer->deferred);
+		event_deferred_cb_cancel_(buffer->cb_queue, &buffer->deferred);
 
 	EVBUFFER_UNLOCK(buffer);
 	if (buffer->own_lock)
@@ -770,7 +770,7 @@ evbuffer_commit_space(struct evbuffer *buf,
 	buf->total_len += added;
 	buf->n_add_for_cb += added;
 	result = 0;
-	evbuffer_invoke_callbacks(buf);
+	evbuffer_invoke_callbacks_(buf);
 
 done:
 	EVBUFFER_UNLOCK(buf);
@@ -982,8 +982,8 @@ evbuffer_add_buffer(struct evbuffer *outbuf, struct evbuffer *inbuf)
 	inbuf->n_del_for_cb += in_total_len;
 	outbuf->n_add_for_cb += in_total_len;
 
-	evbuffer_invoke_callbacks(inbuf);
-	evbuffer_invoke_callbacks(outbuf);
+	evbuffer_invoke_callbacks_(inbuf);
+	evbuffer_invoke_callbacks_(outbuf);
 
 done:
 	EVBUFFER_UNLOCK2(inbuf, outbuf);
@@ -1026,7 +1026,7 @@ evbuffer_add_buffer_reference(struct evbuffer *outbuf, struct evbuffer *inbuf)
 	APPEND_CHAIN_MULTICAST(outbuf, inbuf);
 
 	outbuf->n_add_for_cb += in_total_len;
-	evbuffer_invoke_callbacks(outbuf);
+	evbuffer_invoke_callbacks_(outbuf);
 
 done:
 	EVBUFFER_UNLOCK2(inbuf, outbuf);
@@ -1072,8 +1072,8 @@ evbuffer_prepend_buffer(struct evbuffer *outbuf, struct evbuffer *inbuf)
 	inbuf->n_del_for_cb += in_total_len;
 	outbuf->n_add_for_cb += in_total_len;
 
-	evbuffer_invoke_callbacks(inbuf);
-	evbuffer_invoke_callbacks(outbuf);
+	evbuffer_invoke_callbacks_(inbuf);
+	evbuffer_invoke_callbacks_(outbuf);
 done:
 	EVBUFFER_UNLOCK2(inbuf, outbuf);
 	return result;
@@ -1139,7 +1139,7 @@ evbuffer_drain(struct evbuffer *buf, size_t len)
 
 	buf->n_del_for_cb += len;
 	/* Tell someone about changes in this buffer */
-	evbuffer_invoke_callbacks(buf);
+	evbuffer_invoke_callbacks_(buf);
 
 done:
 	EVBUFFER_UNLOCK(buf);
@@ -1311,8 +1311,8 @@ evbuffer_remove_buffer(struct evbuffer *src, struct evbuffer *dst,
 	src->n_del_for_cb += nread;
 
 	if (nread) {
-		evbuffer_invoke_callbacks(dst);
-		evbuffer_invoke_callbacks(src);
+		evbuffer_invoke_callbacks_(dst);
+		evbuffer_invoke_callbacks_(src);
 	}
 	result = (int)nread;/*XXXX should change return type */
 
@@ -1778,7 +1778,7 @@ evbuffer_add(struct evbuffer *buf, const void *data_in, size_t datlen)
 	buf->n_add_for_cb += datlen;
 
 out:
-	evbuffer_invoke_callbacks(buf);
+	evbuffer_invoke_callbacks_(buf);
 	result = 0;
 done:
 	EVBUFFER_UNLOCK(buf);
@@ -1852,7 +1852,7 @@ evbuffer_prepend(struct evbuffer *buf, const void *data, size_t datlen)
 	buf->n_add_for_cb += (size_t)chain->misalign;
 
 out:
-	evbuffer_invoke_callbacks(buf);
+	evbuffer_invoke_callbacks_(buf);
 	result = 0;
 done:
 	EVBUFFER_UNLOCK(buf);
@@ -2341,7 +2341,7 @@ evbuffer_read(struct evbuffer *buf, evutil_socket_t fd, int howmuch)
 	buf->n_add_for_cb += n;
 
 	/* Tell someone about changes in this buffer */
-	evbuffer_invoke_callbacks(buf);
+	evbuffer_invoke_callbacks_(buf);
 	result = n;
 done:
 	EVBUFFER_UNLOCK(buf);
@@ -2807,7 +2807,7 @@ evbuffer_add_vprintf(struct evbuffer *buf, const char *fmt, va_list ap)
 			buf->n_add_for_cb += sz;
 
 			advance_last_with_data(buf);
-			evbuffer_invoke_callbacks(buf);
+			evbuffer_invoke_callbacks_(buf);
 			result = sz;
 			goto done;
 		}
@@ -2865,7 +2865,7 @@ evbuffer_add_reference(struct evbuffer *outbuf,
 	evbuffer_chain_insert(outbuf, chain);
 	outbuf->n_add_for_cb += datlen;
 
-	evbuffer_invoke_callbacks(outbuf);
+	evbuffer_invoke_callbacks_(outbuf);
 
 	result = 0;
 done:
@@ -3159,7 +3159,7 @@ evbuffer_add_file_segment(struct evbuffer *buf,
 	buf->n_add_for_cb += length;
 	evbuffer_chain_insert(buf, chain);
 
-	evbuffer_invoke_callbacks(buf);
+	evbuffer_invoke_callbacks_(buf);
 
 	EVBUFFER_UNLOCK(buf);
 
 
@@ -94,7 +94,7 @@ pin_release(struct evbuffer_overlapped *eo, unsigned flag)
 }
 
 void
-evbuffer_commit_read(struct evbuffer *evbuf, ev_ssize_t nBytes)
+evbuffer_commit_read_(struct evbuffer *evbuf, ev_ssize_t nBytes)
 {
 	struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf);
 	struct evbuffer_chain **chainp;
@@ -129,13 +129,13 @@ evbuffer_commit_read(struct evbuffer *evbuf, ev_ssize_t nBytes)
 	evbuf->total_len += nBytes;
 	evbuf->n_add_for_cb += nBytes;
 
-	evbuffer_invoke_callbacks(evbuf);
+	evbuffer_invoke_callbacks_(evbuf);
 
 	evbuffer_decref_and_unlock_(evbuf);
 }
 
 void
-evbuffer_commit_write(struct evbuffer *evbuf, ev_ssize_t nBytes)
+evbuffer_commit_write_(struct evbuffer *evbuf, ev_ssize_t nBytes)
 {
 	struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf);
 
@@ -149,7 +149,7 @@ evbuffer_commit_write(struct evbuffer *evbuf, ev_ssize_t nBytes)
 }
 
 struct evbuffer *
-evbuffer_overlapped_new(evutil_socket_t fd)
+evbuffer_overlapped_new_(evutil_socket_t fd)
 {
 	struct evbuffer_overlapped *evo;
 
@@ -168,7 +168,7 @@ evbuffer_overlapped_new(evutil_socket_t fd)
 }
 
 int
-evbuffer_launch_write(struct evbuffer *buf, ev_ssize_t at_most,
+evbuffer_launch_write_(struct evbuffer *buf, ev_ssize_t at_most,
 		struct event_overlapped *ol)
 {
 	struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf);
@@ -242,7 +242,7 @@ evbuffer_launch_write(struct evbuffer *buf, ev_ssize_t at_most,
 }
 
 int
-evbuffer_launch_read(struct evbuffer *buf, size_t at_most,
+evbuffer_launch_read_(struct evbuffer *buf, size_t at_most,
 		struct event_overlapped *ol)
 {
 	struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf);
 
@@ -279,52 +279,52 @@ extern const struct bufferevent_ops bufferevent_ops_async;
 #endif
 
 /** Initialize the shared parts of a bufferevent. */
-int bufferevent_init_common(struct bufferevent_private *, struct event_base *, const struct bufferevent_ops *, enum bufferevent_options options);
+int bufferevent_init_common_(struct bufferevent_private *, struct event_base *, const struct bufferevent_ops *, enum bufferevent_options options);
 
 /** For internal use: temporarily stop all reads on bufev, until the conditions
  * in 'what' are over. */
-void bufferevent_suspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what);
+void bufferevent_suspend_read_(struct bufferevent *bufev, bufferevent_suspend_flags what);
 /** For internal use: clear the conditions 'what' on bufev, and re-enable
  * reading if there are no conditions left. */
-void bufferevent_unsuspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what);
+void bufferevent_unsuspend_read_(struct bufferevent *bufev, bufferevent_suspend_flags what);
 
 /** For internal use: temporarily stop all writes on bufev, until the conditions
  * in 'what' are over. */
-void bufferevent_suspend_write(struct bufferevent *bufev, bufferevent_suspend_flags what);
+void bufferevent_suspend_write_(struct bufferevent *bufev, bufferevent_suspend_flags what);
 /** For internal use: clear the conditions 'what' on bufev, and re-enable
  * writing if there are no conditions left. */
-void bufferevent_unsuspend_write(struct bufferevent *bufev, bufferevent_suspend_flags what);
+void bufferevent_unsuspend_write_(struct bufferevent *bufev, bufferevent_suspend_flags what);
 
 #define bufferevent_wm_suspend_read(b) \
-	bufferevent_suspend_read((b), BEV_SUSPEND_WM)
+	bufferevent_suspend_read_((b), BEV_SUSPEND_WM)
 #define bufferevent_wm_unsuspend_read(b) \
-	bufferevent_unsuspend_read((b), BEV_SUSPEND_WM)
+	bufferevent_unsuspend_read_((b), BEV_SUSPEND_WM)
 
 /*
   Disable a bufferevent.  Equivalent to bufferevent_disable(), but
   first resets 'connecting' flag to force EV_WRITE down for sure.
 
   XXXX this method will go away in the future; try not to add new users.
-    See comment in evhttp_connection_reset() for discussion.
+    See comment in evhttp_connection_reset_() for discussion.
 
   @param bufev the bufferevent to be disabled
   @param event any combination of EV_READ | EV_WRITE.
   @return 0 if successful, or -1 if an error occurred
   @see bufferevent_disable()
  */
-int bufferevent_disable_hard(struct bufferevent *bufev, short event);
+int bufferevent_disable_hard_(struct bufferevent *bufev, short event);
 
 /** Internal: Set up locking on a bufferevent.  If lock is set, use it.
  * Otherwise, use a new lock. */
-int bufferevent_enable_locking(struct bufferevent *bufev, void *lock);
+int bufferevent_enable_locking_(struct bufferevent *bufev, void *lock);
 /** Internal: Increment the reference count on bufev. */
-void bufferevent_incref(struct bufferevent *bufev);
+void bufferevent_incref_(struct bufferevent *bufev);
 /** Internal: Lock bufev and increase its reference count.
  * unlocking it otherwise. */
 void bufferevent_incref_and_lock_(struct bufferevent *bufev);
 /** Internal: Decrement the reference count on bufev.  Returns 1 if it freed
  * the bufferevent.*/
-int bufferevent_decref(struct bufferevent *bufev);
+int bufferevent_decref_(struct bufferevent *bufev);
 /** Internal: Drop the reference count on bufev, freeing as necessary, and
  * unlocking it otherwise.  Returns 1 if it freed the bufferevent. */
 int bufferevent_decref_and_unlock_(struct bufferevent *bufev);
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ pin_release(struct evbuffer_overlapped *eo, unsigned flag)`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`void`
`97`		`-evbuffer_commit_read(struct evbuffer *evbuf, ev_ssize_t nBytes)`
	`97`	`+evbuffer_commit_read_(struct evbuffer *evbuf, ev_ssize_t nBytes)`
`98`	`98`	`{`
`99`	`99`	`struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf);`
`100`	`100`	`struct evbuffer_chain **chainp;`
`@@ -129,13 +129,13 @@ evbuffer_commit_read(struct evbuffer *evbuf, ev_ssize_t nBytes)`
`129`	`129`	`evbuf->total_len += nBytes;`
`130`	`130`	`evbuf->n_add_for_cb += nBytes;`
`131`	`131`
`132`		`- evbuffer_invoke_callbacks(evbuf);`
	`132`	`+ evbuffer_invoke_callbacks_(evbuf);`
`133`	`133`
`134`	`134`	`evbuffer_decref_and_unlock_(evbuf);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`void`
`138`		`-evbuffer_commit_write(struct evbuffer *evbuf, ev_ssize_t nBytes)`
	`138`	`+evbuffer_commit_write_(struct evbuffer *evbuf, ev_ssize_t nBytes)`
`139`	`139`	`{`
`140`	`140`	`struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf);`
`141`	`141`
`@@ -149,7 +149,7 @@ evbuffer_commit_write(struct evbuffer *evbuf, ev_ssize_t nBytes)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`struct evbuffer *`
`152`		`-evbuffer_overlapped_new(evutil_socket_t fd)`
	`152`	`+evbuffer_overlapped_new_(evutil_socket_t fd)`
`153`	`153`	`{`
`154`	`154`	`struct evbuffer_overlapped *evo;`
`155`	`155`
`@@ -168,7 +168,7 @@ evbuffer_overlapped_new(evutil_socket_t fd)`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`int`
`171`		`-evbuffer_launch_write(struct evbuffer *buf, ev_ssize_t at_most,`
	`171`	`+evbuffer_launch_write_(struct evbuffer *buf, ev_ssize_t at_most,`
`172`	`172`	`struct event_overlapped *ol)`
`173`	`173`	`{`
`174`	`174`	`struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf);`
`@@ -242,7 +242,7 @@ evbuffer_launch_write(struct evbuffer *buf, ev_ssize_t at_most,`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`int`
`245`		`-evbuffer_launch_read(struct evbuffer *buf, size_t at_most,`
	`245`	`+evbuffer_launch_read_(struct evbuffer *buf, size_t at_most,`
`246`	`246`	`struct event_overlapped *ol)`
`247`	`247`	`{`
`248`	`248`	`struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf);`