Homepage Demos Overview Downloads Tutorials Reference
Credits
Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Namespace Members | Compound Members | File Members | Related Pages | Search

Wireless.cc

Go to the documentation of this file.
00001 
00002 #include <OPENR/OSyslog.h>
00003 #include <OPENR/OPENRAPI.h>
00004 #include <ant.h>
00005 #include <EndpointTypes.h>
00006 #include <TCPEndpointMsg.h>
00007 #include <UDPEndpointMsg.h>
00008 #include <string.h>
00009 #include "Wireless.h"
00010 #include "Socket.h"
00011 #include "MMCombo/entry.h"
00012 
00013 using namespace SocketNS;
00014 
00015 Wireless *wireless=NULL;
00016 
00017 Wireless::Wireless ()
00018   : ipstackRef(), myOID(), sock_num(0)
00019 {
00020   ipstackRef = antStackRef("IPStack");
00021   WhoAmI(&myOID);
00022 
00023   for (int sock = 0; sock < WIRELESS_MAX_SOCKETS; sock++) {
00024     sockets[sock]=NULL;
00025   }
00026 }    
00027 
00028 Wireless::~Wireless ()
00029 {
00030   // TODO
00031 }
00032 
00033 Socket* Wireless::socket(TransportType_t ttype)
00034 {
00035   return socket(ttype, WIRELESS_DEF_RECV_SIZE, WIRELESS_DEF_SEND_SIZE);
00036 }
00037 
00038 Socket* Wireless::socket(TransportType_t ttype, int recvsize, int sendsize)
00039 {
00040   if (sock_num >= WIRELESS_MAX_SOCKETS
00041       || (recvsize + sendsize) <= 256) return NULL;
00042 
00043   sockets[sock_num]=new Socket(sock_num);
00044   sockets[sock_num]->trType=ttype;
00045   sockets[sock_num]->sendBufSize=sendsize;
00046   sockets[sock_num]->recvBufSize=recvsize;
00047 
00048   // setup send buffer
00049   antEnvCreateSharedBufferMsg sendBufferMsg(sendsize*2);
00050   sendBufferMsg.Call(ipstackRef, sizeof(sendBufferMsg));
00051   if (sendBufferMsg.error != ANT_SUCCESS) return NULL;
00052   
00053   sockets[sock_num]->sendBuffer = sendBufferMsg.buffer;
00054   sockets[sock_num]->sendBuffer.Map();
00055   sockets[sock_num]->sendData
00056         = (byte*)(sockets[sock_num]->sendBuffer.GetAddress());
00057 
00058   // setup receive buffer
00059   antEnvCreateSharedBufferMsg recvBufferMsg(recvsize*2);
00060   recvBufferMsg.Call(ipstackRef, sizeof(recvBufferMsg));
00061   if (recvBufferMsg.error != ANT_SUCCESS) return NULL;
00062   
00063   sockets[sock_num]->recvBuffer = recvBufferMsg.buffer;
00064   sockets[sock_num]->recvBuffer.Map();
00065   sockets[sock_num]->recvData
00066         = (byte*)(sockets[sock_num]->recvBuffer.GetAddress());
00067 
00068   sockets[sock_num]->readData=sockets[sock_num]->recvData+recvsize;
00069   sockets[sock_num]->writeData=sockets[sock_num]->sendData+sendsize;
00070 
00071   return sockets[sock_num++]; 
00072 }
00073 
00074 int Wireless::listen(int sock, int port)
00075 {
00076   if (port<=0 || port>=65535
00077       || sock<0 || sock>=sock_num
00078       || sockets[sock]->state != CONNECTION_CLOSED) return -1;
00079   
00080   sockets[sock]->server_port=port;
00081   sockets[sock]->init();
00082 
00083   if (sockets[sock]->trType==SOCK_STREAM) {
00084     // create endpoint
00085     antEnvCreateEndpointMsg tcpCreateMsg(EndpointType_TCP,
00086                                          (sockets[sock]->recvBufSize+
00087                                          sockets[sock]->sendBufSize)*3);
00088     tcpCreateMsg.Call(ipstackRef, sizeof(tcpCreateMsg));
00089     if (tcpCreateMsg.error != ANT_SUCCESS) return -1;
00090     sockets[sock]->endpoint = tcpCreateMsg.moduleRef;
00091 
00092     // listen
00093     TCPEndpointListenMsg listenMsg(sockets[sock]->endpoint,
00094                                    IP_ADDR_ANY, port);
00095     listenMsg.continuation = (void*)sock;
00096 
00097     listenMsg.Send(ipstackRef, myOID,
00098                    Extra_Entry[entryListenCont], sizeof(listenMsg));
00099     
00100     sockets[sock]->state = CONNECTION_LISTENING;
00101     return 0;
00102   } else if (sockets[sock]->trType==SOCK_DGRAM) {
00103     // create endpoint
00104     antEnvCreateEndpointMsg udpCreateMsg(EndpointType_UDP,
00105                                          (sockets[sock]->recvBufSize+
00106                                          sockets[sock]->sendBufSize)*3);
00107     udpCreateMsg.Call(ipstackRef, sizeof(udpCreateMsg));
00108     if (udpCreateMsg.error != ANT_SUCCESS) return -1;
00109     sockets[sock]->endpoint = udpCreateMsg.moduleRef;
00110 
00111     // bind
00112     UDPEndpointBindMsg bindMsg(sockets[sock]->endpoint,
00113                                    IP_ADDR_ANY, port);
00114     bindMsg.continuation = (void*)sock;
00115 
00116     bindMsg.Send(ipstackRef, myOID,
00117                  Extra_Entry[entryBindCont], sizeof(bindMsg));
00118     
00119     sockets[sock]->state = CONNECTION_LISTENING;
00120     return 0;
00121   } else {
00122     return -1;
00123   }
00124 }
00125 
00126 int Wireless::connect(int sock, const char* ipaddr, int port)
00127 {
00128   if (port<=0 || port>=65535
00129       || sock<0 || sock>=sock_num
00130       || sockets[sock]->state != CONNECTION_CLOSED) return -1;
00131   
00132   sockets[sock]->init();
00133   if (sockets[sock]->trType==SOCK_STREAM) {
00134     // create endpoint
00135     antEnvCreateEndpointMsg tcpCreateMsg(EndpointType_TCP,
00136                                          (sockets[sock]->recvBufSize+
00137                                          sockets[sock]->sendBufSize)*3);
00138     tcpCreateMsg.Call(ipstackRef, sizeof(tcpCreateMsg));
00139     if (tcpCreateMsg.error != ANT_SUCCESS) return -1;
00140     sockets[sock]->endpoint = tcpCreateMsg.moduleRef;
00141 
00142     // connect
00143     TCPEndpointConnectMsg connectMsg(sockets[sock]->endpoint,
00144                                     IP_ADDR_ANY, IP_PORT_ANY, ipaddr, port);
00145     connectMsg.continuation = (void*)sock;
00146 
00147     connectMsg.Send(ipstackRef, myOID,
00148                     Extra_Entry[entryConnectCont], sizeof(connectMsg));
00149     
00150     sockets[sock]->state = CONNECTION_CONNECTING;
00151     return 0;
00152   } else if (sockets[sock]->trType==SOCK_DGRAM) {
00153     //TODO
00154     return 0;
00155   } else {
00156     return -1;
00157   }
00158 }
00159 
00160 void
00161 Wireless::ListenCont(void* msg)
00162 {
00163   TCPEndpointListenMsg* listenMsg = (TCPEndpointListenMsg*)msg;
00164   int sock = (int)listenMsg->continuation;
00165 
00166   if (listenMsg->error != TCP_SUCCESS) {
00167     sockets[sock]->state = CONNECTION_ERROR;
00168     // no use recycling since its a resource issue
00169     return;
00170   }
00171 
00172   sockets[sock]->state = CONNECTION_CONNECTED;
00173   if (sockets[sock]->rcvcbckfn) { receive(sock); }
00174 }
00175 
00176 void
00177 Wireless::ConnectCont(void *msg)
00178 {
00179   TCPEndpointConnectMsg* connectMsg = (TCPEndpointConnectMsg*)msg;
00180   int sock = (int)connectMsg->continuation;
00181 
00182   if (connectMsg->error != TCP_SUCCESS) {
00183     sockets[sock]->state = CONNECTION_ERROR;
00184     return;
00185   }
00186   
00187   sockets[sock]->state = CONNECTION_CONNECTED;
00188 }
00189 
00190 void
00191 Wireless::BindCont(void *msg)
00192 {
00193   UDPEndpointBindMsg* bindMsg = (UDPEndpointBindMsg*)msg;
00194   int sock = (int)bindMsg->continuation;
00195 
00196   if (bindMsg->error != UDP_SUCCESS) {
00197     sockets[sock]->state = CONNECTION_ERROR;
00198     return;
00199   }
00200 
00201   sockets[sock]->state = CONNECTION_CONNECTED;
00202 }
00203 
00204 void
00205 Wireless::send(int sock)
00206 {
00207   if (sock<0 || sock>=sock_num
00208       || sockets[sock]->state != CONNECTION_CONNECTED
00209       || sockets[sock]->sendSize <= 0) return;
00210 
00211     TCPEndpointSendMsg sendMsg(sockets[sock]->endpoint,
00212                                sockets[sock]->sendData,
00213                                sockets[sock]->sendSize);
00214     sendMsg.continuation = (void*)sock;
00215 
00216     sockets[sock]->tx=true;
00217     sendMsg.Send(ipstackRef, myOID,
00218                  Extra_Entry[entrySendCont],
00219                  sizeof(TCPEndpointSendMsg));
00220     sockets[sock]->sendSize = 0;
00221 }
00222 
00223 void
00224 Wireless::SendCont(void* msg)
00225 {
00226     TCPEndpointSendMsg* sendMsg = (TCPEndpointSendMsg*)msg;
00227     int sock = (int)(sendMsg->continuation);
00228 
00229     sockets[sock]->tx=false;
00230     if (sendMsg->error != TCP_SUCCESS) {
00231       sockets[sock]->state=CONNECTION_ERROR;
00232       close(sock);
00233       return;
00234     }
00235     sockets[sock]->flush();
00236 }
00237 
00238 void
00239 Wireless::blockingSend(int sock)
00240 {
00241   if (sock<0 || sock>=sock_num
00242       || sockets[sock]->state != CONNECTION_CONNECTED
00243       || sockets[sock]->sendSize <= 0) return;
00244 
00245     TCPEndpointSendMsg sendMsg(sockets[sock]->endpoint,
00246                                sockets[sock]->sendData,
00247                                sockets[sock]->sendSize);
00248     sendMsg.continuation = (void*)sock;
00249 
00250     sockets[sock]->tx=true;
00251     sockets[sock]->sendSize = 0;
00252     sendMsg.Call(ipstackRef, sizeof(TCPEndpointSendMsg));
00253     sockets[sock]->tx=false;
00254     // no double buffering
00255 }
00256 
00257 void
00258 Wireless::setReceiver(int sock, int (*rcvcbckfn) (char*, int) )
00259 {
00260   if (sock<0 || sock>=sock_num) return;
00261 
00262   sockets[sock]->rcvcbckfn=rcvcbckfn;
00263 }
00264 
00265 void
00266 Wireless::receive(int sock)
00267 {
00268   if (sock<0 || sock>=sock_num
00269       || sockets[sock]->state != CONNECTION_CONNECTED) return;
00270   
00271   TCPEndpointReceiveMsg receiveMsg(sockets[sock]->endpoint,
00272                                    sockets[sock]->recvData,
00273                                    1,sockets[sock]->recvBufSize);
00274   receiveMsg.continuation = (void*)sock;
00275 
00276   receiveMsg.Send(ipstackRef, myOID,
00277                   Extra_Entry[entryReceiveCont], sizeof(receiveMsg));
00278 
00279   sockets[sock]->rx=true;
00280 }
00281 
00282 void
00283 Wireless::receive(int sock, int (*rcvcbckfn) (char*, int) )
00284 {
00285   if (sock<0 || sock>=sock_num
00286       || sockets[sock]->state != CONNECTION_CONNECTED) return;
00287 
00288   sockets[sock]->rcvcbckfn=rcvcbckfn;
00289   
00290   TCPEndpointReceiveMsg receiveMsg(sockets[sock]->endpoint,
00291                                    sockets[sock]->recvData,
00292                                    1,sockets[sock]->recvBufSize);
00293   receiveMsg.continuation = (void*)sock;
00294 
00295   receiveMsg.Send(ipstackRef, myOID,
00296                   Extra_Entry[entryReceiveCont], sizeof(receiveMsg));
00297   sockets[sock]->rx=true;
00298 }
00299 
00300 void
00301 Wireless::ReceiveCont(void* msg)
00302 {
00303     TCPEndpointReceiveMsg* receiveMsg = (TCPEndpointReceiveMsg*)msg;
00304     int sock = (int)(receiveMsg->continuation);
00305 
00306     if (receiveMsg->error != TCP_SUCCESS) {
00307       sockets[sock]->state=CONNECTION_ERROR;
00308       close(sock);
00309       return;
00310     }
00311     sockets[sock]->recvSize=receiveMsg->sizeMin;
00312     sockets[sock]->rcvcbckfn((char*)sockets[sock]->recvData,
00313                              sockets[sock]->recvSize);
00314     sockets[sock]->recvSize=0;
00315     receive(sock);
00316 }
00317 
00318 void
00319 Wireless::close(int sock)
00320 {
00321   if (sockets[sock]->state == CONNECTION_CLOSED ||
00322       sockets[sock]->state == CONNECTION_CLOSING) return;
00323 
00324   TCPEndpointCloseMsg closeMsg(sockets[sock]->endpoint);
00325   closeMsg.continuation = (void*)sock;
00326 
00327   closeMsg.Send(ipstackRef, myOID,
00328       Extra_Entry[entryCloseCont], sizeof(closeMsg));
00329 
00330   sockets[sock]->state = CONNECTION_CLOSING;
00331 }
00332 
00333 void
00334 Wireless::CloseCont(void* msg)
00335 {
00336   TCPEndpointCloseMsg* closeMsg = (TCPEndpointCloseMsg*)msg;
00337   int sock = (int)(closeMsg->continuation);
00338 
00339   sockets[sock]->state = CONNECTION_CLOSED;
00340   if (sockets[sock]->server_port>0) {
00341     // recycle if server
00342     if (sockets[sock]->server_port>0)
00343       listen(sock, sockets[sock]->server_port);
00344   }
00345 }
00346 
00347 /*! @file
00348  * @brief Interacts with the system to provide networking services
00349  * @author alokl (Creator)
00350  * 
00351  * @verbinclude CMPack_license.txt
00352  *
00353  * $Author: ejt $
00354  * $Name: tekkotsu-1_4_1 $
00355  * $Revision: 1.7 $
00356  * $State: Exp $
00357  * $Date: 2003/06/12 23:41:41 $
00358  */
00359 

Tekkotsu v1.4
Generated Sat Jul 19 00:06:32 2003 by Doxygen 1.3.2