Consistently say "eventcb" instead of "errorcb"

svn:r1316

diff --git a/bufferevent-internal.h b/bufferevent-internal.h
index cc4e9e5ca966200790c0e8cfffea65a605e3590a..56cc4434c8724e514f2058e231dfc28cb7c3120e 100644 (file)
--- a/bufferevent-internal.h
+++ b/bufferevent-internal.h
@@ -60,8 +60,8 @@ struct bufferevent_private {
        unsigned connecting : 1;
        /** Set to the events pending if we have deferred callbacks and
         * an events callback is pending. */
-       short errorcb_pending;
-       /** Set to the current error if we have deferred callbacks and
+       short eventcb_pending;
+       /** Set to the current socket errno if we have deferred callbacks and
         * an events callback is pending. */
        int errno_pending;
        /** Used to implement deferred callbacks */
@@ -168,7 +168,7 @@ void _bufferevent_run_readcb(struct bufferevent *bufev);
 void _bufferevent_run_writecb(struct bufferevent *bufev);
 /** Internal: If callbacks are deferred and we have an eventcb, schedule
  * it to run with events "what".  Otherwise just run the eventcb. */
-void _bufferevent_run_errorcb(struct bufferevent *bufev, short what);
+void _bufferevent_run_eventcb(struct bufferevent *bufev, short what);
 
 /* =========
  * These next functions implement timeouts for bufferevents that aren't doing

diff --git a/bufferevent.c b/bufferevent.c
index 94a22f6f74d8b6c8d8bd3e95a5b8da4690f39b7e..be1630e340893c6af33535250ec22dc6afdbb2aa 100644 (file)
--- a/bufferevent.c
+++ b/bufferevent.c
@@ -129,10 +129,10 @@ bufferevent_run_deferred_callbacks(struct deferred_cb *_, void *arg)
                bufev_private->writecb_pending = 0;
                bufev->writecb(bufev, bufev->cbarg);
        }
-       if (bufev_private->errorcb_pending && bufev->errorcb) {
-               short what = bufev_private->errorcb_pending;
+       if (bufev_private->eventcb_pending && bufev->errorcb) {
+               short what = bufev_private->eventcb_pending;
                int err = bufev_private->errno_pending;
-               bufev_private->errorcb_pending = 0;
+               bufev_private->eventcb_pending = 0;
                bufev_private->errno_pending = 0;
                EVUTIL_SET_SOCKET_ERROR(err);
                bufev->errorcb(bufev, what, bufev->cbarg);
@@ -177,13 +177,13 @@ _bufferevent_run_writecb(struct bufferevent *bufev)
 }
 
 void
-_bufferevent_run_errorcb(struct bufferevent *bufev, short what)
+_bufferevent_run_eventcb(struct bufferevent *bufev, short what)
 {
        /* Requires lock. */
        struct bufferevent_private *p =
            EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
        if (p->options & BEV_OPT_DEFER_CALLBACKS) {
-               p->errorcb_pending |= what;
+               p->eventcb_pending |= what;
                p->errno_pending = EVUTIL_SOCKET_ERROR();
                if (!p->deferred.queued) {
                        bufferevent_incref(bufev);
@@ -253,13 +253,13 @@ bufferevent_init_common(struct bufferevent_private *bufev_private,
 void
 bufferevent_setcb(struct bufferevent *bufev,
     bufferevent_data_cb readcb, bufferevent_data_cb writecb,
-    bufferevent_event_cb errorcb, void *cbarg)
+    bufferevent_event_cb eventcb, void *cbarg)
 {
        BEV_LOCK(bufev);
 
        bufev->readcb = readcb;
        bufev->writecb = writecb;
-       bufev->errorcb = errorcb;
+       bufev->errorcb = eventcb;
 
        bufev->cbarg = cbarg;
        BEV_UNLOCK(bufev);
@@ -574,13 +574,13 @@ static void
 bufferevent_generic_read_timeout_cb(evutil_socket_t fd, short event, void *ctx)
 {
        struct bufferevent *bev = ctx;
-       _bufferevent_run_errorcb(bev, BEV_EVENT_TIMEOUT|BEV_EVENT_READING);
+       _bufferevent_run_eventcb(bev, BEV_EVENT_TIMEOUT|BEV_EVENT_READING);
 }
 static void
 bufferevent_generic_write_timeout_cb(evutil_socket_t fd, short event, void *ctx)
 {
        struct bufferevent *bev = ctx;
-       _bufferevent_run_errorcb(bev, BEV_EVENT_TIMEOUT|BEV_EVENT_WRITING);
+       _bufferevent_run_eventcb(bev, BEV_EVENT_TIMEOUT|BEV_EVENT_WRITING);
 }
 
 void

diff --git a/bufferevent_filter.c b/bufferevent_filter.c
index 585b3c255dd700c09adcfafcf0a00d5bb9c74091..d350f08198787d0b30e086532813caddfb2b00a3 100644 (file)
--- a/bufferevent_filter.c
+++ b/bufferevent_filter.c
@@ -66,7 +66,7 @@ static void be_filter_destruct(struct bufferevent *);
 
 static void be_filter_readcb(struct bufferevent *, void *);
 static void be_filter_writecb(struct bufferevent *, void *);
-static void be_filter_errorcb(struct bufferevent *, short, void *);
+static void be_filter_eventcb(struct bufferevent *, short, void *);
 static int be_filter_flush(struct bufferevent *bufev,
     short iotype, enum bufferevent_flush_mode mode);
 static int be_filter_ctrl(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);
@@ -202,7 +202,7 @@ bufferevent_filter_new(struct bufferevent *underlying,
        bufev_f->context = ctx;
 
        bufferevent_setcb(bufev_f->underlying,
-            be_filter_readcb, be_filter_writecb, be_filter_errorcb, bufev_f);
+            be_filter_readcb, be_filter_writecb, be_filter_eventcb, bufev_f);
 
        bufev_f->outbuf_cb = evbuffer_add_cb(downcast(bufev_f)->output,
           bufferevent_filtered_outbuf_cb, bufev_f);
@@ -410,14 +410,14 @@ be_filter_writecb(struct bufferevent *underlying, void *_me)
 
 /* Called when the underlying socket has given us an error */
 static void
-be_filter_errorcb(struct bufferevent *underlying, short what, void *_me)
+be_filter_eventcb(struct bufferevent *underlying, short what, void *_me)
 {
        struct bufferevent_filtered *bevf = _me;
        struct bufferevent *bev = downcast(bevf);
 
-       /* All we can really to is tell our own errorcb. */
+       /* All we can really to is tell our own eventcb. */
        if (bev->errorcb)
-               _bufferevent_run_errorcb(bev, what);
+               _bufferevent_run_eventcb(bev, what);
 }
 
 static int

diff --git a/bufferevent_sock.c b/bufferevent_sock.c
index d2723739e08a825d700074cfb46859a8ef20bb0f..e8e5f4736e6f0a682ee463c3248686e72dc961c5 100644 (file)
--- a/bufferevent_sock.c
+++ b/bufferevent_sock.c
@@ -173,7 +173,7 @@ bufferevent_readcb(evutil_socket_t fd, short event, void *arg)
 
  error:
        event_del(&bufev->ev_read);
-       _bufferevent_run_errorcb(bufev, what);
+       _bufferevent_run_eventcb(bufev, what);
 }
 
 static void
@@ -191,7 +191,7 @@ bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
        }
        if (bufev_p->connecting) {
                bufev_p->connecting = 0;
-               _bufferevent_run_errorcb(bufev, BEV_EVENT_CONNECTED);
+               _bufferevent_run_eventcb(bufev, BEV_EVENT_CONNECTED);
                if (!(bufev->enabled & EV_WRITE)) {
                        event_del(&bufev->ev_write);
                        return;
@@ -235,7 +235,7 @@ bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
 
  error:
        event_del(&bufev->ev_write);
-       _bufferevent_run_errorcb(bufev, what);
+       _bufferevent_run_eventcb(bufev, what);
 }
 
 struct bufferevent *
@@ -302,11 +302,11 @@ bufferevent_socket_connect(struct bufferevent *bev,
                                return 0;
                        }
                }
-               _bufferevent_run_errorcb(bev, BEV_EVENT_ERROR);
+               _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
                /* do something about the error? */
        } else {
                /* The connect succeeded already. How odd. */
-               _bufferevent_run_errorcb(bev, BEV_EVENT_CONNECTED);
+               _bufferevent_run_eventcb(bev, BEV_EVENT_CONNECTED);
        }
 
        return 0;
@@ -326,14 +326,14 @@ bufferevent_socket_connect(struct bufferevent *bev,
 struct bufferevent *
 bufferevent_new(evutil_socket_t fd,
     bufferevent_data_cb readcb, bufferevent_data_cb writecb,
-    bufferevent_event_cb errorcb, void *cbarg)
+    bufferevent_event_cb eventcb, void *cbarg)
 {
        struct bufferevent *bufev;
 
        if (!(bufev = bufferevent_socket_new(NULL, fd, 0)))
                return NULL;
 
-       bufferevent_setcb(bufev, readcb, writecb, errorcb, cbarg);
+       bufferevent_setcb(bufev, readcb, writecb, eventcb, cbarg);
 
        return bufev;
 }

diff --git a/include/event2/bufferevent.h b/include/event2/bufferevent.h
index 80dcbd9d568962b7c71acd0825a2000592468642..af75f12ebb884ac8790e8bab931f0e3e65f7d7f8 100644 (file)
--- a/include/event2/bufferevent.h
+++ b/include/event2/bufferevent.h
@@ -145,7 +145,7 @@ struct bufferevent *bufferevent_socket_new(struct event_base *base, evutil_socke
 
 /**
    Launch a connect() attempt with a socket.  When the connect succeeds,
-   the errorcb will be invoked with BEV_EVENT_CONNECTED set.
+   the eventcb will be invoked with BEV_EVENT_CONNECTED set.
 
    If the bufferevent does not already have a socket set, we allocate a new
    socket here and make it nonblocking before we begin.
@@ -195,7 +195,7 @@ void bufferevent_free(struct bufferevent *bufev);
          no callback is desired
   @param writecb callback to invoke when the file descriptor is ready for
          writing, or NULL if no callback is desired
-  @param errorcb callback to invoke when there is an error on the file
+  @param eventcb callback to invoke when there is an event on the file
          descriptor
   @param cbarg an argument that will be supplied to each of the callbacks
          (readcb, writecb, and errorcb)
@@ -203,7 +203,7 @@ void bufferevent_free(struct bufferevent *bufev);
   */
 void bufferevent_setcb(struct bufferevent *bufev,
     bufferevent_data_cb readcb, bufferevent_data_cb writecb,
-    bufferevent_event_cb errorcb, void *cbarg);
+    bufferevent_event_cb eventcb, void *cbarg);
 
 /**
   Changes the file descriptor on which the bufferevent operates.

diff --git a/include/event2/bufferevent_struct.h b/include/event2/bufferevent_struct.h
index e7c4ff6ab535e5abd7604ab9c8dc2972990b0101..8cbec9b4c249a183fa03fe77849bf32bbc2b299c 100644 (file)
--- a/include/event2/bufferevent_struct.h
+++ b/include/event2/bufferevent_struct.h
@@ -99,6 +99,8 @@ struct bufferevent {
 
        bufferevent_data_cb readcb;
        bufferevent_data_cb writecb;
+       /* This should be called 'eventcb', but renaming it would break
+        * backward compatibility */
        bufferevent_event_cb errorcb;
        void *cbarg;