Source/SocketWrapper.m

   1 /*
   2  * MacGDBp
   3  * Copyright (c) 2002 - 2007, Blue Static <http://www.bluestatic.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU
   6  * General Public License as published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
  10  * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with this program; if not,
  14  * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  15  */
  16
  17 #import "SocketWrapper.h"
  18 #include <sys/types.h>
  19 #include <sys/socket.h>
  20 #include <netinet/in.h>
  21 #include <arpa/inet.h>
  22 #include <unistd.h>
  23
  24 NSString *sockNotificationDebuggerConnection = @"DebuggerConnection";
  25 NSString *sockNotificationReceiver = @"SEL-del-SocketWrapper_dataReceived";
  26 NSString *NsockError = @"SocketWrapper_Error";
  27 NSString *NsockDidAccept = @"SocketWrapper_DidAccept";
  28 NSString *NsockDataReceived = @"SocketWrapper_DataReceived";
  29 NSString *NsockDataSent = @"SocketWrapper_DataSent";
  30
  31 @implementation SocketWrapper
  32
  33 /**
  34  * Initializes the socket wrapper with a host and port
  35  */
  36 - (id)initWithPort: (int)port
  37 {
  38         if (self = [super init])
  39         {
  40                 _port = port;
  41
  42                 // the delegate notifications work funky because of threads. we register ourselves as the
  43                 // observer and then pass up the messages that are actually from this object (as we can't only observe self due to threads)
  44                 // to our delegate, and not to all delegates
  45                 [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(_sendMessageToDelegate:) name: nil object: nil];
  46         }
  47         return self;
  48 }
  49
  50 /**
  51  * Close our socket and clean up anything else
  52  */
  53 - (void)dealloc
  54 {
  55         close(_socket);
  56
  57         [super dealloc];
  58 }
  59
  60 /**
  61  * Returns the delegate
  62  */
  63 - (id)delegate
  64 {
  65         return _delegate;
  66 }
  67
  68 /**
  69  * Sets the delegate but does *not* retain it
  70  */
  71 - (void)setDelegate: (id)delegate
  72 {
  73         _delegate = delegate;
  74 }
  75
  76 /**
  77  * This is the notification listener for all types of notifications. If the notifications are from a SocketWrapper
  78  * class, it checks that the value of _delegate in the NSNotification's userInfo matches that of this object. If it does,
  79  * then the notification was sent from the same object in another thread and it passes the message along to the object's
  80  * delegate. Complicated enough?
  81  */
  82 - (void)_sendMessageToDelegate: (NSNotification *)notif
  83 {
  84         // this isn't us, so there's no point in continuing
  85         if ([[notif userInfo] objectForKey: sockNotificationDebuggerConnection] != _delegate)
  86         {
  87                 return;
  88         }
  89
  90         NSString *name = [notif name];
  91
  92         if (name == NsockDidAccept)
  93         {
  94                 [_delegate socketDidAccept];
  95         }
  96         else if (name == NsockDataReceived)
  97         {
  98                 [_delegate dataReceived: [notif object] deliverTo: NSSelectorFromString([[notif userInfo] objectForKey: sockNotificationReceiver])];
  99         }
 100         else if (name == NsockDataSent)
 101         {
 102                 [_delegate dataSent];
 103         }
 104         else if (name == NsockError)
 105         {
 106                 [_delegate errorEncountered: [NSError errorWithDomain: [notif object] code: -1 userInfo: nil]];
 107         }
 108 }
 109
 110 /**
 111  * Connects to a socket on the port specified during init. This will dispatch another thread to do the
 112  * actual waiting. Delegate notifications are posted along the way to let the client know what is going on.
 113  */
 114 - (void)connect
 115 {
 116         [NSThread detachNewThreadSelector: @selector(_connect:) toTarget: self withObject: nil];
 117 }
 118
 119 /**
 120  * This does the actual dirty work (in a separate thread) of connecting to a socket
 121  */
 122 - (void)_connect: (id)obj
 123 {
 124         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 125
 126         // create an INET socket that we'll be listen()ing on
 127         int socketOpen = socket(PF_INET, SOCK_STREAM, 0);
 128
 129         // create our address given the port
 130         struct sockaddr_in address;
 131         address.sin_family = AF_INET;
 132         address.sin_port = htons(_port);
 133         address.sin_addr.s_addr = htonl(INADDR_ANY);
 134         memset(address.sin_zero, '\0', sizeof(address.sin_zero));
 135
 136         // bind the socket... and don't give up until we've tried for a while
 137         int tries = 0;
 138         while (bind(socketOpen, (struct sockaddr *)&address, sizeof(address)) < 0)
 139         {
 140                 if (tries >= 5)
 141                 {
 142                         close(socketOpen);
 143                         [self _postNotification: NsockError withObject: @"Could not bind to socket"];
 144                         return;
 145                 }
 146                 NSLog(@"couldn't bind to the socket... trying again in 5");
 147                 sleep(5);
 148                 tries++;
 149         }
 150
 151         // now we just have to keep our ears open
 152         if (listen(socketOpen, 0) == -1)
 153         {
 154                 [self _postNotification: NsockError withObject: @"Could not use bound socket for listening"];
 155         }
 156
 157         // accept a connection
 158         struct sockaddr_in remoteAddress;
 159         socklen_t remoteAddressLen = sizeof(remoteAddress);
 160         _socket = accept(socketOpen, (struct sockaddr *)&remoteAddress, &remoteAddressLen);
 161         if (_socket < 0)
 162         {
 163                 close(socketOpen);
 164                 [self _postNotification: NsockError withObject: @"Client failed to accept remote socket"];
 165                 return;
 166         }
 167
 168         // we're done listening now that we have a connection
 169         close(socketOpen);
 170
 171         [self _postNotification: NsockDidAccept withObject: nil];
 172
 173         [pool release];
 174 }
 175
 176 /**
 177  * Reads from the socket and returns the result as a NSString (because it's always going to be XML). Be aware
 178  * that the underlying socket recv() call will *wait* for the server to send a message, so be sure that this
 179  * is used either in a threaded environment so the interface does not hang, or when you *know* the server
 180  * will return something (which we almost always do).
 181  *
 182  * The paramater is an optional selector which the delegate method dataReceived:deliverTo: should forward to
 183  */
 184 - (void)receive: (SEL)selector
 185 {
 186         // create a buffer
 187         char buffer[1024];
 188
 189         // do our initial recv() call to get (hopefully) all the data and the lengh of the packet
 190         int recvd = recv(_socket, &buffer, sizeof(buffer), 0);
 191
 192         // take the received data and put it into an NSData
 193         NSMutableData *data = [NSMutableData data];
 194
 195         // strip the length from the packet, and clear the null byte then add it to the NSData
 196         char packetLength[8];
 197         int i = 0;
 198         while (buffer[i] != '\0')
 199         {
 200                 packetLength[i] = buffer[i];
 201                 i++;
 202         }
 203
 204         // we also want the null byte, so move us up 1
 205         i++;
 206
 207         // the total length of the full transmission
 208         int length = atoi(packetLength);
 209
 210         // move the packet part of the received data into it's own char[]
 211         char packet[sizeof(buffer)];
 212         memmove(packet, &buffer[i], recvd - i);
 213
 214         // convert bytes to NSData
 215         [data appendBytes: packet length: recvd];
 216
 217         // check if we have a partial packet
 218         if (length + i > sizeof(buffer))
 219         {
 220                 while (recvd < length)
 221                 {
 222                         int latest = recv(_socket, &buffer, sizeof(buffer), 0);
 223                         if (latest < 1)
 224                         {
 225                                 [self _postNotification: NsockError withObject: @"Socket closed or could not be read"];
 226                                 return;
 227                         }
 228                         [data appendBytes: buffer length: latest];
 229                         recvd += latest;
 230                 }
 231         }
 232
 233         // convert the NSData into a NSString
 234         NSString *string = [[[NSString alloc] initWithData: data encoding: NSUTF8StringEncoding] autorelease];
 235
 236         [self _postNotification: NsockDataReceived
 237                                  withObject: string
 238                                    withDict: [NSMutableDictionary dictionaryWithObject: NSStringFromSelector(selector) forKey: sockNotificationReceiver]];
 239 }
 240
 241 /**
 242  * Sends a given NSString over the socket
 243  */
 244 - (void)send: (NSString *)data
 245 {
 246         data = [NSString stringWithFormat: @"%@\0", data];
 247         int sent = send(_socket, [data UTF8String], [data length], 0);
 248         if (sent < 0)
 249         {
 250                 [self _postNotification: NsockError withObject: @"Failed to write data to socket"];
 251                 return;
 252         }
 253         if (sent < [data length])
 254         {
 255                 // TODO - do we really need to worry about partial sends with the lenght of our commands?
 256                 NSLog(@"FAIL: only partial packet was sent; sent %d bytes", sent);
 257         }
 258
 259         [self _postNotification: NsockDataSent withObject: nil];
 260 }
 261
 262 /**
 263  * Helper method to simply post a notification to the default notification center with a given name and object
 264  */
 265 - (void)_postNotification: (NSString *)name withObject: (id)obj
 266 {
 267         [self _postNotification: name withObject: obj withDict: [NSMutableDictionary dictionary]];
 268 }
 269
 270 /**
 271  * Another helper method to aid in the posting of notifications. This one should be used if you have additional
 272  * things for the userInfo. This automatically adds the sockNotificationDebuggerConnection key.
 273  */
 274 - (void)_postNotification: (NSString *)name withObject: (id)obj withDict: (NSMutableDictionary *)dict
 275 {
 276         [dict setValue: _delegate forKey: sockNotificationDebuggerConnection];
 277         [[NSNotificationCenter defaultCenter] postNotificationName: name object: obj userInfo: dict];
 278 }
 279
 280 @end