Socket.cpp

00001 /*
00002 Copyright (c) 2010 Peter Barrett
00003 
00004 Permission is hereby granted, free of charge, to any person obtaining a copy
00005 of this software and associated documentation files (the "Software"), to deal
00006 in the Software without restriction, including without limitation the rights
00007 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00008 copies of the Software, and to permit persons to whom the Software is
00009 furnished to do so, subject to the following conditions:
00010 
00011 The above copyright notice and this permission notice shall be included in
00012 all copies or substantial portions of the Software.
00013 
00014 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00015 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00016 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00017 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00018 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00019 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00020 THE SOFTWARE.
00021 */
00022 
00023 /* 
00024 Tue Apr 26 2011 Bart Janssens: added a socket listener
00025 */
00026 
00027 #include <stdio.h>
00028 #include <stdlib.h>
00029 #include <stdio.h>
00030 #include <string.h>
00031 
00032 #include "Utils.h"
00033 #include "Socket.h"
00034 
00035 #define MAX_SOCKET_HANDLERS 3
00036 #define MAX_SOCKETS 16
00037 #define MAX_LISTEN 8
00038 
00039 class SocketInternalPad
00040 {
00041     public:
00042     SocketInternal si;
00043     u8  pad[8];
00044 };
00045 
00046 
00047     
00048 
00049 class SocketManager
00050 {
00051     SocketHandler*  _handlers[MAX_SOCKET_HANDLERS];
00052     SocketInternalPad  _sockets[MAX_SOCKETS];
00053     SocketListener _listeners[MAX_LISTEN];
00054 
00055     public:
00056     SocketManager()
00057     {
00058         memset(_handlers,0,sizeof(_handlers));
00059         memset(_sockets,0,sizeof(_sockets));
00060         memset(_listeners,0,sizeof(_listeners));
00061     }
00062 
00063     SocketHandler* GetHandler(int type)
00064     {
00065         if (type < 1 || type > MAX_SOCKET_HANDLERS)
00066             return 0;
00067         return _handlers[type - 1];
00068     }
00069 
00070     SocketInternal* GetInternal(int s)
00071     {
00072         if (s < 1 || s > MAX_SOCKETS)
00073             return 0;
00074         return &_sockets[s - 1].si;
00075     }
00076 
00077     int RegisterSocketHandler(int type, SocketHandler* handler)
00078     {
00079        if (type < 1 || type > MAX_SOCKET_HANDLERS)
00080             return ERR_SOCKET_TYPE_NOT_FOUND;
00081         _handlers[type - 1] = handler;
00082         return 0;
00083     }
00084 
00085     int Open(int type, SocketAddrHdr* addr, SocketCallback callback, void* userData)
00086     {
00087         SocketHandler* h = GetHandler(type);
00088         if (!h)
00089             return ERR_SOCKET_TYPE_NOT_FOUND;
00090         
00091         for (int i = 0; i < MAX_SOCKETS; i++)
00092         {
00093             SocketInternal* si = (SocketInternal*)(_sockets+i);
00094             if (si->ID == 0)
00095             {
00096                 //printf("Call to Socket Manager Open \r\n");
00097                 si->ID = i+1;
00098                 si->Type = type;
00099                 si->Callback = callback;
00100                 si->userData = userData;
00101                 return h->Open(si,addr);
00102             }
00103         }
00104         return ERR_SOCKET_NONE_LEFT;
00105     }
00106     
00107     SocketInternal* Create(int type, SocketAddrHdr* addr, int port)
00108     {
00109         SocketInternal* si;
00110         SocketListener* li;
00111         SocketHandler* h = GetHandler(type);
00112         if (!h)
00113             return 0;
00114         
00115         for (int i = 0; i < MAX_SOCKETS; i++)
00116         {
00117             si = (SocketInternal*)(_sockets+i);
00118             if (si->ID == 0)
00119             {
00120                 si->ID = i+1;
00121                 si->State = SocketState_Listen;
00122                 si->Type = type;
00123                 si->port = port;
00124                 for (int i = 0; i < MAX_LISTEN; i++){
00125                     li = (SocketListener*)(_listeners+i);
00126                     if (( li->Type == si->Type )&& (li->port == si->port)) {
00127                         si->Callback = li->Callback;
00128                         si->userData = li->userData;
00129                         h->Create(si,addr);
00130                         return si;
00131                     }
00132 
00133                 }
00134              }
00135         }
00136 
00137     }
00138     
00139     
00140     int Listen(int type, int port, SocketCallback callback,void* userData)
00141     {
00142         SocketListener* li;
00143         SocketHandler* h = GetHandler(type);
00144         if (!h) return ERR_SOCKET_TYPE_NOT_FOUND;
00145         
00146         //printf("Call to Socket Manager Listen \r\n");
00147         for (int i = 0; i < MAX_LISTEN; i++)
00148         {
00149             li = (SocketListener*)(_listeners+i);
00150             if (( li->Type == type )&& (li->port == port)) {
00151                //printf("Port %d is already in use\r\n",port);
00152                return ERR_SOCKET_IN_USE; //in use
00153             }
00154         }
00155         
00156         for (int i = 0; i < MAX_LISTEN; i++)
00157         {
00158             li = (SocketListener*)(_listeners+i);
00159             if (( li->Type == 0 )&& (li->port == 0)) {
00160                 li->ID = i+1;
00161                 li->Type = type;
00162                 li->port = port;
00163                 li->Callback = callback;
00164                 li->userData = userData;
00165                 //printf("Listening on port %d \r\n",port);
00166                 return 0;
00167             }
00168         }
00169         //printf("Max listen ports reached\r\n",port);
00170         return ERR_SOCKET_NONE_LEFT;           
00171     }
00172     
00173     int InUse(int type, int port)
00174     {
00175         SocketListener* li;
00176         SocketHandler* h = GetHandler(type);
00177         if (!h) return ERR_SOCKET_TYPE_NOT_FOUND;
00178         for (int i = 0; i < MAX_LISTEN; i++)
00179         {
00180             li = (SocketListener*)(_listeners+i);
00181             if (( li->Type == type )&& (li->port == port)) {
00182 
00183                 //printf("Listen check on port %d OK\r\n",port);
00184                 return 0;
00185             }
00186         }
00187         //printf("Listen check on port %d NOK\r\n",port);
00188         return ERR_SOCKET_NONE_LEFT; 
00189      }
00190     
00191 
00192     int Accept(int socket, SocketCallback callback, void* userData)
00193     {
00194         SocketInternal* si = GetInternal(socket);
00195         if (!si || si->ID != socket)
00196             return ERR_SOCKET_NOT_FOUND;
00197             
00198         si->Callback = callback;
00199         si->userData = userData;
00200         
00201         //printf("Call to Socket Manager Accept \r\n");        
00202         return 0;
00203          
00204     }
00205 
00206     int Send(int socket, const u8* data, int len)
00207     {
00208         //printf("Call to Socket Manager Send \r\n"); 
00209         SocketInternal* si = GetInternal(socket);
00210         //printf("socket = %d si->ID = %d si->Type = %d \r\n", socket, si->ID, si->Type); 
00211         if (!si || si->ID != socket){
00212             //printf("send: socket not found \r\n");
00213             return ERR_SOCKET_NOT_FOUND;
00214         }
00215         //printf("Calling l2cap send \r\n");
00216         
00217         SocketHandler* h = GetHandler(si->Type);
00218         if (!h) {
00219                 //printf("Send: no socket type found \r\n");
00220                 return ERR_SOCKET_TYPE_NOT_FOUND;
00221         }
00222         return h->Send(si,data,len);
00223        
00224     }
00225 
00226     int Close(int socket)
00227     {
00228         SocketInternal* si = GetInternal(socket);
00229         if (!si || si->ID != socket)
00230             return ERR_SOCKET_NOT_FOUND;
00231         si->ID = 0;
00232         return GetHandler(si->Type)->Close(si);
00233     }
00234 };
00235 
00236 SocketManager gSocketManager;
00237 
00238 int Socket_Open(int type, SocketAddrHdr* addr, SocketCallback callback, void* userData)
00239 {
00240     //printf("Call to Socket Open \r\n");
00241     return gSocketManager.Open(type,addr,callback,userData);
00242 }
00243 
00244 SocketInternal* Socket_Create(int type, SocketAddrHdr* addr, int port)
00245 {
00246     return gSocketManager.Create(type, addr, port);
00247 }
00248 
00249 int Socket_Send(int socket, const u8* data, int len)
00250 {
00251     //printf("Call to Socket_Send \r\n");
00252     return gSocketManager.Send(socket,data,len);
00253 }
00254 
00255 int Socket_Close(int socket)
00256 {
00257     return gSocketManager.Close(socket);
00258 }
00259 
00260 int Socket_Listen(int type, int port,SocketCallback callback, void* userData)
00261 {
00262     //printf("Call to Socket_Listen \r\n");
00263     return gSocketManager.Listen(type, port,callback,userData);
00264 }
00265 
00266 int Socket_InUse(int type, int port)
00267 {
00268     //printf("Call to Socket_InUse \r\n");
00269     return gSocketManager.InUse(type, port);
00270 }
00271 
00272 int Socket_Accept(int socket, SocketCallback callback, void* userData)
00273 {
00274     //printf("Call to Socket_Accept \r\n");
00275     return gSocketManager.Accept(socket, callback, userData);
00276 }
00277 
00278 int RegisterSocketHandler(int type, SocketHandler* handler)
00279 {
00280     return gSocketManager.RegisterSocketHandler(type,handler);
00281 }
00282 
00283 SocketInternal* GetSocketInternal(int socket)
00284 {
00285     return gSocketManager.GetInternal(socket);
00286 }
00287