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 #include <stdio.h>
00024 #include <stdlib.h>
00025 #include <stdio.h>
00026 #include <string.h>
00027 
00028 #include "Utils.h"
00029 #include "Socket.h"
00030 
00031 #define MAX_SOCKET_HANDLERS 4
00032 #define MAX_SOCKETS 16
00033 
00034 class SocketInternalPad
00035 {
00036     public:
00037     SocketInternal si;
00038     u8  pad[8];
00039 };
00040 
00041 class SocketManager
00042 {
00043     SocketHandler*  _handlers[MAX_SOCKET_HANDLERS];
00044     SocketInternalPad  _sockets[MAX_SOCKETS];
00045 
00046     public:
00047     SocketManager()
00048     {
00049         memset(_handlers,0,sizeof(_handlers));
00050         memset(_sockets,0,sizeof(_sockets));
00051     }
00052 
00053     SocketHandler* GetHandler(int type)
00054     {
00055         if (type < 1 || type > MAX_SOCKET_HANDLERS)
00056             return 0;
00057         return _handlers[type - 1];
00058     }
00059 
00060     SocketInternal* GetInternal(int s)
00061     {
00062         if (s < 1 || s > MAX_SOCKETS)
00063             return 0;
00064         return &_sockets[s - 1].si;
00065     }
00066 
00067     int RegisterSocketHandler(int type, SocketHandler* handler)
00068     {
00069        if (type < 1 || type > MAX_SOCKET_HANDLERS)
00070             return ERR_SOCKET_TYPE_NOT_FOUND;
00071         _handlers[type - 1] = handler;
00072         return 0;
00073     }
00074 
00075     int Create(int type, SocketCallback callback, void* userData)
00076     {
00077         SocketHandler* h = GetHandler(type);
00078         if (!h)
00079             return ERR_SOCKET_TYPE_NOT_FOUND;
00080         
00081         for (int i = 0; i < MAX_SOCKETS; i++)
00082         {
00083             SocketInternal* si = (SocketInternal*)(_sockets+i);
00084             if (si->ID == 0)
00085             {
00086                 si->ID = i+1;
00087                 si->Type = type;
00088                 si->Callback = callback;
00089                 si->userData = userData;
00090                 printf("Creating socket %d for type %d, invoking 'Open' on %p (=%s)\n", si->ID, type, h, h->Name());
00091                 return h->Create(si);
00092             }
00093         }
00094         return ERR_SOCKET_NONE_LEFT;
00095     }
00096 
00097     int Open(int type, SocketAddrHdr* addr, SocketCallback callback, void* userData)
00098     {
00099         SocketHandler* h = GetHandler(type);
00100         if (!h)
00101             return ERR_SOCKET_TYPE_NOT_FOUND;
00102         
00103         for (int i = 0; i < MAX_SOCKETS; i++)
00104         {
00105             SocketInternal* si = (SocketInternal*)(_sockets+i);
00106             if (si->ID == 0)
00107             {
00108                 si->ID = i+1;
00109                 si->Type = type;
00110                 si->Callback = callback;
00111                 si->userData = userData;
00112                 printf("Opening socket %d for type %d, invoking 'Open' on %p (=%s)\n", si->ID, type, h, h->Name());
00113                 return h->Open(si,addr);
00114             }
00115         }
00116         return ERR_SOCKET_NONE_LEFT;
00117     }
00118 
00119     int Listen(int type, int channel, SocketCallback callback, void* userData)
00120     {
00121         SocketHandler* h = GetHandler(type);
00122         if (!h)
00123             return ERR_SOCKET_TYPE_NOT_FOUND;
00124         
00125         for (int i = 0; i < MAX_SOCKETS; i++)
00126         {
00127             SocketInternal* si = (SocketInternal*)(_sockets+i);
00128             if (si->ID == 0)
00129             {
00130                 si->ID = i+1;
00131                 si->Type = type;
00132                 si->Callback = callback;
00133                 si->userData = userData;
00134                 printf("Passively opening socket %d for type %d, invoking 'Listen' on %p (=%s)\n", si->ID, type, h, h->Name());
00135                 int sn = h->Listen(si, channel);
00136                 if (sn < 0)
00137                   si->ID = 0;//free the socket when error
00138                 return sn;
00139             }
00140         }
00141         return ERR_SOCKET_NONE_LEFT;
00142     }
00143 
00144     int Accept(int type, int scid, int rxid, SocketCallback callback, void* userData)
00145     {
00146         SocketHandler* h = GetHandler(type);
00147         if (!h)
00148             return ERR_SOCKET_TYPE_NOT_FOUND;
00149         
00150         for (int i = 0; i < MAX_SOCKETS; i++)
00151         {
00152             SocketInternal* si = (SocketInternal*)(_sockets+i);
00153             if (si->ID == 0)
00154             {
00155                 si->ID = i+1;
00156                 si->Type = type;
00157                 si->Callback = callback;
00158                 si->userData = userData;
00159                 printf("Accepting socket %d for type %d, invoking 'Accept' on %p (=%s)\n", si->ID, type, h, h->Name());
00160                 return h->Accept(si, scid, rxid);
00161             }
00162         }
00163         return ERR_SOCKET_NONE_LEFT;
00164     }
00165 
00166     int Send(int socket, const u8* data, int len)
00167     {
00168         SocketInternal* si = GetInternal(socket);
00169         if (!si || si->ID != socket)
00170             return ERR_SOCKET_NOT_FOUND;
00171            // printf("sending %d bytes to socket %d (ID=%d)\n", len, socket, si->ID);
00172         return GetHandler(si->Type)->Send(si,data,len);
00173     }
00174 
00175     int SetOpt(int socket, int so, int* data, int len)
00176     {
00177         SocketInternal* si = GetInternal(socket);
00178         if (!si || si->ID != socket)
00179             return ERR_SOCKET_NOT_FOUND;
00180         return GetHandler(si->Type)->SetOpt(si, so, data,len);
00181     }
00182 
00183     int GetOpt(int socket, int so, int* data, int len)
00184     {
00185         SocketInternal* si = GetInternal(socket);
00186         if (!si || si->ID != socket)
00187             return ERR_SOCKET_NOT_FOUND;
00188         return GetHandler(si->Type)->GetOpt(si, so, data,len);
00189     }
00190 
00191     int Close(int socket)
00192     {
00193         SocketInternal* si = GetInternal(socket);
00194         if (!si || si->ID != socket){
00195             printf("Close: socket %d not found\n", socket);
00196             return ERR_SOCKET_NOT_FOUND;
00197         }
00198         printf("Close: socket %d (type=%d)\n", socket, si->Type);
00199         si->SetState(SocketState_Closing);
00200         int retval = GetHandler(si->Type)->Close(si);
00201         //si->SetState(Socket_Closed);
00202         //si->ID = 0;
00203         return retval;
00204     }
00205 };
00206 
00207 SocketManager gSocketManager;
00208 
00209 int Socket_Open(int type, SocketAddrHdr* addr, SocketCallback callback, void* userData)
00210 {
00211     return gSocketManager.Open(type,addr,callback,userData);
00212 }
00213 
00214 int Socket_Listen(int type, int channel, SocketCallback callback, void* userData)  // Open a socket for listening
00215 {
00216     return gSocketManager.Listen(type,channel,callback,userData);
00217 }
00218 
00219 int Socket_Accept(int type, int scid, int rxid, SocketCallback callback, void* userData)  // Open a socket for an incoming connection
00220 {
00221     return gSocketManager.Accept(type,scid,rxid,callback,userData);
00222 }
00223 
00224 int Socket_Send(int socket, const u8* data, int len)
00225 {
00226     return gSocketManager.Send(socket,data,len);
00227 }
00228 
00229 int Socket_SetOpt(int socket, int so, int* data, int len)
00230 {
00231     return gSocketManager.SetOpt(socket, so, data,len);
00232 }
00233 
00234 int Socket_GetOpt(int socket, int so, int* data, int len)
00235 {
00236     return gSocketManager.GetOpt(socket, so, data,len);
00237 }
00238 
00239 int Socket_Close(int socket)
00240 {
00241     return gSocketManager.Close(socket);
00242 }
00243 
00244 int RegisterSocketHandler(int type, SocketHandler* handler)
00245 {
00246     return gSocketManager.RegisterSocketHandler(type,handler);
00247 }
00248 
00249 SocketInternal* GetSocketInternal(int socket)
00250 {
00251     return gSocketManager.GetInternal(socket);
00252 }
00253