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     int Listen(int type, int port, SocketCallback callback,void* userData)
00140     {
00141         SocketListener* li;
00142         SocketHandler* h = GetHandler(type);
00143         if (!h) return ERR_SOCKET_TYPE_NOT_FOUND;
00144         
00145         //printf("Call to Socket Manager Listen \r\n");
00146         for (int i = 0; i < MAX_LISTEN; i++)
00147         {
00148             li = (SocketListener*)(_listeners+i);
00149             if (( li->Type == type )&& (li->port == port)) {
00150                //printf("Port %d is already in use\r\n",port);
00151                return ERR_SOCKET_IN_USE; //in use
00152             }
00153         }
00154         
00155         for (int i = 0; i < MAX_LISTEN; i++)
00156         {
00157             li = (SocketListener*)(_listeners+i);
00158             if (( li->Type == 0 )&& (li->port == 0)) {
00159                 li->ID = i+1;
00160                 li->Type = type;
00161                 li->port = port;
00162                 li->Callback = callback;
00163                 li->userData = userData;
00164                 //printf("Listening on port %d \r\n",port);
00165                 return 0;
00166             }
00167         }
00168         //printf("Max listen ports reached\r\n",port);
00169         return ERR_SOCKET_NONE_LEFT;           
00170     }
00171     
00172     int InUse(int type, int port)
00173     {
00174         SocketListener* li;
00175         SocketHandler* h = GetHandler(type);
00176         if (!h) return ERR_SOCKET_TYPE_NOT_FOUND;
00177         for (int i = 0; i < MAX_LISTEN; i++)
00178         {
00179             li = (SocketListener*)(_listeners+i);
00180             if (( li->Type == type )&& (li->port == port)) {
00181 
00182                 //printf("Listen check on port %d OK\r\n",port);
00183                 return 0;
00184             }
00185         }
00186         //printf("Listen check on port %d NOK\r\n",port);
00187         return ERR_SOCKET_NONE_LEFT; 
00188      }
00189     
00190 
00191     int Accept(int socket, SocketCallback callback, void* userData)
00192     {
00193         SocketInternal* si = GetInternal(socket);
00194         if (!si || si->ID != socket)
00195             return ERR_SOCKET_NOT_FOUND;
00196             
00197         si->Callback = callback;
00198         si->userData = userData;
00199         
00200         //printf("Call to Socket Manager Accept \r\n");        
00201         return 0;
00202          
00203     }
00204 
00205     int Send(int socket, const u8* data, int len)
00206     {
00207         //printf("Call to Socket Manager Send \r\n"); 
00208         SocketInternal* si = GetInternal(socket);
00209         //printf("socket = %d si->ID = %d si->Type = %d \r\n", socket, si->ID, si->Type); 
00210         if (!si || si->ID != socket){
00211             //printf("send: socket not found \r\n");
00212             return ERR_SOCKET_NOT_FOUND;
00213         }
00214         //printf("Calling l2cap send \r\n");
00215         
00216         SocketHandler* h = GetHandler(si->Type);
00217         if (!h) {
00218                 //printf("Send: no socket type found \r\n");
00219                 return ERR_SOCKET_TYPE_NOT_FOUND;
00220         }
00221         return h->Send(si,data,len);
00222        
00223     }
00224 
00225     int Close(int socket)
00226     {
00227         SocketInternal* si = GetInternal(socket);
00228         if (!si || si->ID != socket)
00229             return ERR_SOCKET_NOT_FOUND;
00230         si->ID = 0;
00231         return GetHandler(si->Type)->Close(si);
00232     }
00233 };
00234 
00235 SocketManager gSocketManager;
00236 
00237 int Socket_Open(int type, SocketAddrHdr* addr, SocketCallback callback, void* userData)
00238 {
00239     //printf("Call to Socket Open \r\n");
00240     return gSocketManager.Open(type,addr,callback,userData);
00241 }
00242 
00243 SocketInternal* Socket_Create(int type, SocketAddrHdr* addr, int port)
00244 {
00245     return gSocketManager.Create(type, addr, port);
00246 }
00247 
00248 int Socket_Send(int socket, const u8* data, int len)
00249 {
00250     //printf("Call to Socket_Send \r\n");
00251     return gSocketManager.Send(socket,data,len);
00252 }
00253 
00254 int Socket_Close(int socket)
00255 {
00256     return gSocketManager.Close(socket);
00257 }
00258 
00259 int Socket_Listen(int type, int port,SocketCallback callback, void* userData)
00260 {
00261     //printf("Call to Socket_Listen \r\n");
00262     return gSocketManager.Listen(type, port,callback,userData);
00263 }
00264 
00265 int Socket_InUse(int type, int port)
00266 {
00267     //printf("Call to Socket_InUse \r\n");
00268     return gSocketManager.InUse(type, port);
00269 }
00270 
00271 int Socket_Accept(int socket, SocketCallback callback, void* userData)
00272 {
00273     //printf("Call to Socket_Accept \r\n");
00274     return gSocketManager.Accept(socket, callback, userData);
00275 }
00276 
00277 int RegisterSocketHandler(int type, SocketHandler* handler)
00278 {
00279     return gSocketManager.RegisterSocketHandler(type,handler);
00280 }
00281 
00282 SocketInternal* GetSocketInternal(int socket)
00283 {
00284     return gSocketManager.GetInternal(socket);
00285 }
00286