tcpcallbackconnection.h

00001 #ifndef TCPCALLBACKCONNECTION_H
00002 #define TCPCALLBACKCONNECTION_H
00003 
00004 #include "tcpconnection.h"
00005 
00006 namespace mbed {
00007 
00008 #define NO_SENT_FNC    ((err_t (*)(TCPCallbackConnection *, u16_t))NULL)
00009 #define NO_RECV_FNC    ((err_t (*)(TCPCallbackConnection *, struct pbuf *, err_t))NULL)
00010 #define NO_POLL_FNC    ((err_t (*)(TCPCallbackConnection *))NULL)
00011 #define NO_ACCEPT_FNC  ((err_t (*)(TCPCallbackConnection *, struct tcp_pcb *, err_t))NULL)
00012 #define NO_CONNECT_FNC ((err_t (*)(TCPCallbackConnection *, err_t))NULL)
00013 #define NO_ERR_FNC      ((void (*)(TCPCallbackConnection *, err_t))NULL)
00014 
00015 
00016 class TCPCallbackConnection : public TCPConnection {
00017   public:
00018     TCPCallbackConnection(struct ip_addr ip_addr, u16_t port,
00019        err_t (*psent)(TCPCallbackConnection *, u16_t),
00020        err_t (*precv)(TCPCallbackConnection *, struct pbuf *, err_t),
00021        err_t (*ppoll)(TCPCallbackConnection *),
00022        err_t (*pconnected)(TCPCallbackConnection *, err_t),
00023        void  (*perr )(TCPCallbackConnection *, err_t))
00024       : TCPConnection(ip_addr, port) {
00025       _sent = psent;
00026       _recv = precv;
00027       _poll = ppoll;
00028       _connected = pconnected;
00029       _err  = perr;
00030       _membercaller_sent = NULL;
00031       _membercaller_recv = NULL;
00032       _membercaller_poll = NULL;
00033       _membercaller_connected = NULL;
00034       _membercaller_err  = NULL;
00035     }
00036 
00037     TCPCallbackConnection(TCPListener *parent, struct tcp_pcb *npcb,
00038        err_t (*psent)(TCPCallbackConnection *, u16_t),
00039        err_t (*precv)(TCPCallbackConnection *, struct pbuf *, err_t),
00040        err_t (*ppoll)(TCPCallbackConnection *),
00041        err_t (*pconnected)(TCPCallbackConnection *, err_t),
00042        void  (*perr )(TCPCallbackConnection *, err_t))
00043       : TCPConnection(parent, npcb) {
00044       _sent = psent;
00045       _recv = precv;
00046       _poll = ppoll;
00047       _connected = pconnected;
00048       _err  = perr;
00049       _membercaller_sent = NULL;
00050       _membercaller_recv = NULL;
00051       _membercaller_poll = NULL;
00052       _membercaller_connected = NULL;
00053       _membercaller_err  = NULL;
00054     }
00055 
00056 /*
00057     template<typename T>
00058     TCPCallbackConnection(NetServer *nnet, const struct ip_addr &ip_addr, const u16_t &port,
00059        T *o,
00060        err_t (T::*psent)(TCPCallbackConnection *, u16_t),
00061        err_t (T::*precv)(TCPCallbackConnection *, struct pbuf *p, err_t err),
00062        err_t (T::*ppoll)(TCPCallbackConnection *),
00063        err_t (T::*pconnected)(TCPCallbackConnection *, err_t),
00064        void  (T::*perr )(TCPCallbackConnection *, err_t))
00065       : TCPConnection(nnet, ip_addr, port) {
00066       _sent =  NULL; _recv =  NULL; _poll =  NULL; _connected = NULL; _err = NULL;
00067       _object_sent = _object_recv = _object_poll = 
00068       _object_connected = _object_err = static_cast<void *>(o);
00069       
00070       memcpy(_member_sent, (char *)&psent, sizeof(psent));
00071       memcpy(_member_recv, (char *)&precv, sizeof(precv));
00072       memcpy(_member_poll, (char *)&ppoll, sizeof(ppoll));
00073       memcpy(_member_connected, (char *)&pconnected, sizeof(pconnected));
00074       memcpy(_member_err, (char *)&perr, sizeof(perr));
00075       
00076       _membercaller_sent = &TCPCallbackConnection::_fsent<T>;
00077       _membercaller_recv = &TCPCallbackConnection::_frecv<T>;
00078       _membercaller_poll = &TCPCallbackConnection::_fpoll<T>;
00079       _membercaller_connected = &TCPCallbackConnection::_fconnected<T>;
00080       _membercaller_err  = &TCPCallbackConnection::_ferr<T>;
00081     }
00082 
00083     template<typename T_sent, typename T_recv, typename T_poll, typename T_accept, typename T_connected, typename T_err>
00084     TCPCallbackConnection(NetServer *nnet, const struct ip_addr &ip_addr, const u16_t &port,
00085        T_sent *osent,
00086        err_t (T_sent::*psent)(TCPCallbackConnection *, u16_t),
00087        T_recv *orecv,
00088        err_t (T_recv::*precv)(TCPCallbackConnection *, struct pbuf *p, err_t err),
00089        T_poll *opoll,
00090        err_t (T_poll::*ppoll)(TCPCallbackConnection *),
00091        T_connected *oconnected,
00092        err_t (T_connected::*pconnected)(TCPCallbackConnection *, err_t),
00093        T_err  *oerr,
00094        void  (T_err::*perr )(TCPCallbackConnection *, err_t))
00095       : TCPConnection(nnet, ip_addr, port) {
00096       _sent =  NULL; _recv =  NULL; _poll =  NULL; _connected = NULL; _err = NULL;
00097       
00098       _object_sent      = static_cast<void *>(osent);
00099       _object_recv      = static_cast<void *>(orecv);
00100       _object_poll      = static_cast<void *>(opoll);
00101       _object_connected = static_cast<void *>(oconnected);
00102       _object_err       = static_cast<void *>(oerr);
00103       
00104       memcpy(_member_sent,      (char *)&psent,   sizeof(psent));
00105       memcpy(_member_recv,      (char *)&precv,   sizeof(precv));
00106       memcpy(_member_poll,      (char *)&ppoll,   sizeof(ppoll));
00107       memcpy(_member_connected, (char *)&paccept, sizeof(paccept));
00108       memcpy(_member_err,       (char *)&perr,    sizeof(perr));
00109       
00110       _membercaller_sent      = &TCPCallbackConnection::_fsent<T_sent>;
00111       _membercaller_recv      = &TCPCallbackConnection::_frecv<T_recv>;
00112       _membercaller_poll      = &TCPCallbackConnection::_fpoll<T_poll>;
00113       _membercaller_connected = &TCPCallbackConnection::_fconnected<T_connected>;
00114       _membercaller_err       = &TCPCallbackConnection::_ferr<T_err>;
00115     }
00116 */
00117     /*
00118      * Function to be called when more send buffer space is available.
00119      * @param space the amount of bytes available
00120      * @return ERR_OK: try to send some data by calling tcp_output
00121      */
00122     virtual err_t sent(u16_t space) { 
00123       if(_sent) {
00124         return (_sent)(this, space);
00125       } else if(_membercaller_sent) {
00126         return (_membercaller_sent)(this, space);
00127       } else {
00128         return ERR_OK;
00129       }
00130     }
00131   
00132     /*
00133      * Function to be called when (in-sequence) data has arrived.
00134      * @param p the packet buffer which arrived
00135      * @param err an error argument (TODO: that is current always ERR_OK?)
00136      * @return ERR_OK: try to send some data by calling tcp_output
00137      */
00138     virtual err_t recv(struct pbuf *p, err_t err) { 
00139       if(_recv) {
00140         return (_recv)(this, p, err);
00141       } else if(_membercaller_recv) {
00142         return (_membercaller_recv)(this, p, err);
00143       } else {
00144         return ERR_OK;
00145       }
00146     }
00147 
00148     /*
00149      * Function which is called periodically.
00150      * The period can be adjusted in multiples of the TCP slow timer interval
00151      * by changing tcp_pcb.polltmr.
00152      * @return ERR_OK: try to send some data by calling tcp_output
00153      */
00154     virtual err_t poll() {
00155       if(_poll) {
00156         return (_poll)(this);
00157       } else if(_membercaller_poll) {
00158         return (_membercaller_poll)(this);
00159       } else {
00160         return ERR_OK;
00161       }
00162     }
00163 
00164     virtual err_t connected(err_t err) {
00165       err = TCPConnection::connected(err);
00166       if(_connected) {
00167         return (_connected)(this, err);
00168       } else if(_membercaller_connected) {
00169         return (_membercaller_connected)(this, err);
00170       } else {
00171         return ERR_OK;
00172       }
00173     }
00174 
00175     /*
00176      * Function to be called whenever a fatal error occurs.
00177      * There is no pcb parameter since most of the times, the pcb is
00178      * already deallocated (or there is no pcb) when this function is called.
00179      * @param err an indication why the error callback is called:
00180      *            ERR_ABRT: aborted through tcp_abort or by a TCP timer
00181      *            ERR_RST: the connection was reset by the remote host
00182      */
00183     virtual void err(err_t err) {
00184       if(_err) {
00185         (_err)(this, err);
00186       } else if(_membercaller_err) {
00187         (_membercaller_err)(this, err);
00188       }
00189     }
00190 
00191   private:
00192     template<typename T> static err_t _fsent(TCPCallbackConnection *me, u16_t space) {
00193       T* o = static_cast<T *>(me->_object_sent);
00194       err_t (T::*m)(TCPCallbackConnection *, u16_t);
00195       memcpy((char *)&m, me->_member_sent, sizeof(m));
00196       return (o->*m)(me, space);
00197     }
00198     
00199     template<typename T> static err_t _frecv(TCPCallbackConnection *me, struct pbuf *p, err_t err) {
00200       T* o = static_cast<T *>(me->_object_recv);
00201       err_t (T::*m)(TCPCallbackConnection *, struct pbuf *p, err_t err);
00202       memcpy((char *)&m, me->_member_recv, sizeof(m));
00203       return (o->*m)(me, p, err);
00204     }
00205     
00206     template<typename T> static err_t _fpoll(TCPCallbackConnection *me) {
00207       T* o = static_cast<T *>(me->_object_poll);
00208       err_t (T::*m)(TCPCallbackConnection *);
00209       memcpy((char *)&m, me->_member_poll, sizeof(m));
00210       return (o->*m)(me);
00211     }
00212     
00213     template<typename T> static err_t _faccept(TCPCallbackConnection *me, struct tcp_pcb *newpcb, err_t err) {
00214       T* o = static_cast<T *>(me->_object_accept);
00215       err_t (T::*m)(TCPCallbackConnection *, struct tcp_pcb *, err_t);
00216       memcpy((char *)&m, me->_member_accept, sizeof(m));
00217       return (o->*m)(me, newpcb, err);
00218     }
00219 
00220     template<typename T> static err_t _fconnected(TCPCallbackConnection *me, err_t err) {
00221       T* o = static_cast<T *>(me->_object_connected);
00222       err_t (T::*m)(TCPCallbackConnection *, err_t);
00223       memcpy((char *)&m, me->_member_connected, sizeof(m));
00224       return (o->*m)(me, err);
00225     }
00226 
00227     template<typename T> static void _ferr(TCPCallbackConnection *me, err_t) {
00228       T* o = static_cast<T *>(me->_object_err);
00229       err_t (T::*m)(TCPCallbackConnection *, err_t);
00230       memcpy((char *)&m, me->_member_err, sizeof(m));
00231       (o->*m)(me, err);
00232     }
00233 
00234     err_t (*_sent)(TCPCallbackConnection *, u16_t);
00235     err_t (*_recv)(TCPCallbackConnection *, struct pbuf *p, err_t err);
00236     err_t (*_poll)(TCPCallbackConnection *);
00237     err_t (*_accept)(TCPCallbackConnection *, struct tcp_pcb *newpcb, err_t err);
00238     err_t (*_connected)(TCPCallbackConnection *, err_t err);
00239     void  (*_err )(TCPCallbackConnection *, err_t);
00240     void *_object_sent;
00241     void *_object_recv;
00242     void *_object_poll;
00243     void *_object_accept;
00244     void *_object_connected;
00245     void *_object_err;
00246     char _member_sent[16];
00247     char _member_recv[16];
00248     char _member_poll[16];
00249     char _member_accept[16];
00250     char _member_connected[16];
00251     char _member_err[16];
00252     err_t (*_membercaller_sent)(TCPCallbackConnection *, u16_t);
00253     err_t (*_membercaller_recv)(TCPCallbackConnection *, struct pbuf *p, err_t err);
00254     err_t (*_membercaller_poll)(TCPCallbackConnection *);
00255     err_t (*_membercaller_accept)(TCPCallbackConnection *, struct tcp_pcb *newpcb, err_t err);
00256     err_t (*_membercaller_connected)(TCPCallbackConnection *, err_t err);
00257     void  (*_membercaller_err) (TCPCallbackConnection *, err_t err);
00258 };
00259   
00260 };
00261 
00262 #endif /* TCPCALLBACKCONNECTION_H */