# HG changeset patch # User Tero Marttila # Date 1241651630 -10800 # Node ID 6750d50ee8cd35b19295b4840ef6f58e5ff35433 # Parent a816950a6548c34e980969f4d600af7a3c94d555 modify transport to use the new object_* stuff, along with transport_fd and fifo diff -r a816950a6548 -r 6750d50ee8cd src/fifo.c --- a/src/fifo.c Thu May 07 02:12:55 2009 +0300 +++ b/src/fifo.c Thu May 07 02:13:50 2009 +0300 @@ -25,17 +25,6 @@ }; /** - * Get a sock_fd pointer from a sock_fifo pointer - */ -#define FIFO_FD(sock_ptr) (&(sock_ptr)->base_fd) - -/** - * Get a sock_base pointer from a sock_fifo pointer - */ -#define FIFO_TRANSPORT(sock_ptr) TRANSPORT_FD_BASE(FIFO_FD(sock_ptr)) - - -/** * (re)open the fifo, closing it if already open, and keeping any event callbacks registered. */ static err_t fifo_open (struct fifo *fifo, error_t *err) @@ -47,11 +36,11 @@ RETURN_SET_ERROR_ERRNO(err, ERR_OPEN); // set the new fd - if ((ERROR_CODE(err) = transport_fd_set(FIFO_FD(fifo), _fd))) + if ((ERROR_CODE(err) = transport_fd_set(&fifo->base_fd, _fd))) return ERROR_CODE(err); // use default transport event-based behaviour - if ((ERROR_CODE(err) = transport_fd_defaults(FIFO_FD(fifo)))) + if ((ERROR_CODE(err) = transport_fd_defaults(&fifo->base_fd))) return ERROR_CODE(err); // ok @@ -59,15 +48,17 @@ } /** - * Destroy the fifo, releasing all resources + * Deinit the fifo, releasing all resources */ -static void fifo_destroy (struct fifo *fifo) +static void fifo_deinit (struct fifo *fifo) { - // destroy base - transport_fd_destroy(FIFO_FD(fifo)); + // deinit base + transport_fd_deinit(&fifo->base_fd); // release the path free(fifo->path); + + fifo->path = NULL; } /** @@ -80,7 +71,7 @@ struct fifo *fifo = transport_check(transport, &fifo_type); // trap READ_EOF - if (transport_fd_methods_read(transport, buf, len, err) != ERR_EOF) + if (transport_fd__read(transport, buf, len, err) != ERR_EOF) return ERROR_CODE(err); // re-open it @@ -100,26 +91,38 @@ /** * sock_stream_methods::release implementation */ -static void _fifo_destroy (transport_t *transport) +static void fifo__deinit (transport_t *transport) { struct fifo *fifo = transport_check(transport, &fifo_type); - fifo_destroy(fifo); + fifo_deinit(fifo); } /* * Our sock_stream_type */ const struct transport_type fifo_type = { - .parent = &transport_fd_type, - .methods = { - .read = fifo_read, - .write = NULL, - .events = transport_fd_methods_events, - .destroy = _fifo_destroy, + .base_type = { + .parent = &transport_fd_type.base_type, + }, + .methods = { + .read = fifo_read, + .write = NULL, + .events = transport_fd__events, + .deinit = fifo__deinit, }, }; +/** + * Deinit and free + */ +static void fifo_destroy (struct fifo *fifo) +{ + fifo_deinit(fifo); + + free(fifo); +} + err_t fifo_open_read (struct transport_info *transport_info, transport_t **transport_ptr, struct event_base *ev_base, const char *path, error_t *err) { @@ -134,15 +137,15 @@ return SET_ERROR(err, ERR_STRDUP); // init - transport_init(FIFO_TRANSPORT(fifo), &fifo_type, transport_info); - transport_fd_init(FIFO_FD(fifo), ev_base, TRANSPORT_FD_INVALID); + transport_init(&fifo->base_fd.base, &fifo_type, transport_info); + transport_fd_init(&fifo->base_fd, ev_base, TRANSPORT_FD_INVALID); // open the fifo if (fifo_open(fifo, err)) goto error; // ok - *transport_ptr = FIFO_TRANSPORT(fifo); + *transport_ptr = &fifo->base_fd.base; return SUCCESS; diff -r a816950a6548 -r 6750d50ee8cd src/transport.c --- a/src/transport.c Thu May 07 02:12:55 2009 +0300 +++ b/src/transport.c Thu May 07 02:13:50 2009 +0300 @@ -2,46 +2,43 @@ #include +/** + * Our own object_type + */ +const struct object_type transport_type_type = { + .parent = NULL, +}; + /* * Internal API */ void transport_init (transport_t *transport, const struct transport_type *type, const struct transport_info *info) { - // not already bound - assert(!transport->type); - + // init object + object_init(&transport->base_obj, &type->base_type); + // store - transport->type = type; - if (info) transport->info = *info; } void* transport_check (transport_t *transport, const struct transport_type *type) { - const struct transport_type *tp_type; - - // sanity check - assert(type); + // trip as a bug + assert(object_check(&transport->base_obj, &type->base_type)); - // look for a matching type in the transport's type list - for (tp_type = transport->type; tp_type; tp_type = tp_type->parent) - if (tp_type == type) - break; - - // make sure we found one - assert(tp_type); - - // ok + // ok, cast via void* return transport; } void transport_connected (transport_t *transport, const error_t *err, bool direct) { + const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type); + // update state transport->connected = true; - if (direct || !transport->type->methods._connected) { + if (direct || !type->methods._connected) { // user callback if (err) // connect failed @@ -52,7 +49,7 @@ } else { // wrapper method - transport->type->methods._connected(transport, err); + type->methods._connected(transport, err); } } @@ -82,12 +79,14 @@ */ int transport_read (transport_t *transport, void *buf, size_t len, error_t *err) { + const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type); + // not readable - if (!transport->type->methods.read) + if (!type->methods.read) return SET_ERROR(err, -1); // proxy off to method handler - if (transport->type->methods.read(transport, buf, &len, err)) + if (type->methods.read(transport, buf, &len, err)) return -ERROR_CODE(err); // return updated 'bytes-read' len @@ -96,12 +95,14 @@ int transport_write (transport_t *transport, const void *buf, size_t len, error_t *err) { + const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type); + // XXX: not writeable - if (!transport->type->methods.write) + if (!type->methods.write) return SET_ERROR(err, -1); // proxy off to method handler - if (transport->type->methods.write(transport, buf, &len, err)) + if (type->methods.write(transport, buf, &len, err)) return -ERROR_CODE(err); // return updated 'bytes-written' len @@ -110,11 +111,12 @@ err_t transport_events (transport_t *transport, short mask) { + const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type); error_t err; // notify transport - if (transport->type->methods.events) { - if (transport->type->methods.events(transport, mask, &err)) + if (type->methods.events) { + if (type->methods.events(transport, mask, &err)) goto error; } @@ -136,9 +138,11 @@ void transport_destroy (transport_t *transport) { + const struct transport_type *type = object_type(&transport->base_obj, &transport_type_type); + // destroy the transport-specific stuff - if (transport->type->methods.destroy) - transport->type->methods.destroy(transport); + if (type->methods.deinit) + type->methods.deinit(transport); // then the transport itself free(transport); diff -r a816950a6548 -r 6750d50ee8cd src/transport_fd.c --- a/src/transport_fd.c Thu May 07 02:12:55 2009 +0300 +++ b/src/transport_fd.c Thu May 07 02:13:50 2009 +0300 @@ -31,7 +31,7 @@ /** * Our transport_methods implementations */ -err_t transport_fd_methods_read (transport_t *transport, void *buf, size_t *len, error_t *err) +err_t transport_fd__read (transport_t *transport, void *buf, size_t *len, error_t *err) { struct transport_fd *fd = transport_check(transport, &transport_fd_type); int ret; @@ -61,7 +61,7 @@ return SUCCESS; } -err_t transport_fd_methods_write (transport_t *transport, const void *buf, size_t *len, struct error_info *err) +err_t transport_fd__write (transport_t *transport, const void *buf, size_t *len, struct error_info *err) { struct transport_fd *fd = transport_check(transport, &transport_fd_type); int ret; @@ -95,7 +95,7 @@ return SUCCESS; } -err_t transport_fd_methods_events (transport_t *transport, short ev_mask, error_t *err) +err_t transport_fd__events (transport_t *transport, short ev_mask, error_t *err) { struct transport_fd *fd = transport_check(transport, &transport_fd_type); @@ -113,20 +113,22 @@ return (ERROR_CODE(err) = transport_fd_events(fd, mask)); } -void _transport_fd_destroy (transport_t *transport) +void transport_fd__deinit (transport_t *transport) { struct transport_fd *fd = transport_check(transport, &transport_fd_type); - transport_fd_destroy(fd); + transport_fd_deinit(fd); } const struct transport_type transport_fd_type = { - .parent = NULL, + .base_type = { + .parent = NULL, + }, .methods = { - .read = transport_fd_methods_read, - .write = transport_fd_methods_write, - .events = transport_fd_methods_events, - .destroy = _transport_fd_destroy + .read = transport_fd__read, + .write = transport_fd__write, + .events = transport_fd__events, + .deinit = transport_fd__deinit } }; @@ -353,13 +355,13 @@ return SUCCESS; } -void transport_fd_destroy (struct transport_fd *fd) +void transport_fd_deinit (struct transport_fd *fd) { err_t tmp; // XXX: this might block if ((tmp = transport_fd_close(fd))) - log_warn_err_code(tmp, "close"); + log_warn_err(tmp, "close"); } diff -r a816950a6548 -r 6750d50ee8cd src/transport_fd.h --- a/src/transport_fd.h Thu May 07 02:12:55 2009 +0300 +++ b/src/transport_fd.h Thu May 07 02:13:50 2009 +0300 @@ -63,14 +63,14 @@ /** * Implementation of transport_methods::read */ -err_t transport_fd_methods_read (transport_t *transport, void *buf, size_t *len, error_t *err); +err_t transport_fd__read (transport_t *transport, void *buf, size_t *len, error_t *err); /** * Implementation of transport_methods::write. * * If this gets EAGAIN, it will automatically enable the write event, unless masked out. */ -err_t transport_fd_methods_write (transport_t *transport, const void *buf, size_t *len, error_t *err); +err_t transport_fd__write (transport_t *transport, const void *buf, size_t *len, error_t *err); /** * Implementation of transport_methods::events. @@ -80,7 +80,14 @@ * For TRANSPORT_WRITE, the write event will only be enabled if given in the mask, *and* the ev_write event is currently * active (via transport_fd_methods_write()); otherwise, the write event will not be enabled. */ -err_t transport_fd_methods_events (transport_t *transport, short mask, error_t *err); +err_t transport_fd__events (transport_t *transport, short mask, error_t *err); + +/** + * Implementation of transport_methods::deinit. + * + * This simply calls transport_fd_deinit(). + */ +void transport_fd__deinit (transport_t *transport); /** * A transport_fd_callback_func that simply invokes the transport_callback user functions. @@ -155,12 +162,12 @@ err_t transport_fd_close (struct transport_fd *fd); /** - * Destroy the fd immediately. + * Deinitialize the transport_fd. * * This logs a warning if the close() fails. * * XXX: this may actually block, I think? SO_LINGER? */ -void transport_fd_destroy (struct transport_fd *fd); +void transport_fd_deinit (struct transport_fd *fd); #endif diff -r a816950a6548 -r 6750d50ee8cd src/transport_internal.h --- a/src/transport_internal.h Thu May 07 02:12:55 2009 +0300 +++ b/src/transport_internal.h Thu May 07 02:13:50 2009 +0300 @@ -7,65 +7,66 @@ * The internal interface for transport implementations. */ #include "transport.h" +#include "object.h" #include /** - * Method table for implementation stuff. - * - * Note that it is the transport's resposibility to implement the behaviour described in transport.h + * The object_type for a transport_type */ -struct transport_methods { - /** For transport_read() */ - err_t (*read) (transport_t *transport, void *buf, size_t *len, error_t *err); - - /** For transport_write() */ - err_t (*write) (transport_t *transport, const void *buf, size_t *len, error_t *err); - - /** - * The mask of event flags will be set to the given mask if this method is succesfull. - * - * The old mask is still available in transport::info::ev_mask. - */ - err_t (*events) (transport_t *transport, short mask, error_t *err); - - /** - * Release the transport's internal state, but not the transport itself. - * - * In other words, this should release everything inside the transport_t, but not free() the transport_t itself. - */ - void (*destroy) (transport_t *transport); - - /** - * Used by layered transports to handle transport_connected. - * - * If this is NULL, transport_connected will call the user callback directly, otherwise, it will proxy through this. - * - * The \a err param follows the same rules as for transport_connected() - NULL for success, error info otherwise. - * - * @param transport the transport state - * @param err error info if the connect failed - */ - void (*_connected) (transport_t *transport, const error_t *err); -}; +extern const struct object_type transport_type_type; /** * The definition of a transport type */ struct transport_type { - /** Parent type */ - const struct transport_type *parent; + struct object_type base_type; - /** Method table */ - struct transport_methods methods; + /** + * Method table for implementation stuff. + * + * Note that it is the transport's resposibility to implement the behaviour described in transport.h + */ + struct transport_methods { + /** For transport_read() */ + err_t (*read) (transport_t *transport, void *buf, size_t *len, error_t *err); + + /** For transport_write() */ + err_t (*write) (transport_t *transport, const void *buf, size_t *len, error_t *err); + + /** + * The mask of event flags will be set to the given mask if this method is succesfull. + * + * The old mask is still available in transport::info::ev_mask. + */ + err_t (*events) (transport_t *transport, short mask, error_t *err); + + /** + * Release the transport's internal state, but not the transport itself. + * + * In other words, this should release everything inside the transport_t, but not free() the transport_t itself. + */ + void (*deinit) (transport_t *transport); + + /** + * Used by layered transports to handle transport_connected. + * + * If this is NULL, transport_connected will call the user callback directly, otherwise, it will proxy through this. + * + * The \a err param follows the same rules as for transport_connected() - NULL for success, error info otherwise. + * + * @param transport the transport state + * @param err error info if the connect failed + */ + void (*_connected) (transport_t *transport, const error_t *err); + } methods; }; /** * The base transport type */ struct transport { - /** The type info, or NULL if not yet bound */ - const struct transport_type *type; + struct object base_obj; /** User info */ struct transport_info info;