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 @interface SocketWrapper (Private)
  32
  33 - (void)connect: (id)obj;
  34 - (void)postNotification: (NSString *)name withObject: (id)obj;
  35 - (void)postNotification: (NSString *)name withObject: (id)obj withDict: (NSMutableDictionary *)dict;
  36
  37 @end
  38
  39 @implementation SocketWrapper
  40
  41 /**
  42  * Initializes the socket wrapper with a host and port
  43  */
  44 - (id)initWithPort: (int)port
  45 {
  46         if (self = [super init])
  47         {
  48                 _port = port;
  49
  50                 // the delegate notifications work funky because of threads. we register ourselves as the
  51                 // observer and then pass up the messages that are actually from this object (as we can't only observe self due to threads)
  52                 // to our delegate, and not to all delegates
  53                 [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(sendMessageToDelegate:) name: nil object: nil];
  54         }
  55         return self;
  56 }
  57
  58 /**
  59  * Close our socket and clean up anything else
  60  */
  61 - (void)dealloc
  62 {
  63         [[NSNotificationCenter defaultCenter] removeObserver: self];
  64         close(_socket);
  65
  66         [super dealloc];
  67 }
  68
  69 /**
  70  * Returns the delegate
  71  */
  72 - (id)delegate
  73 {
  74         return _delegate;
  75 }
  76
  77 /**
  78  * Sets the delegate but does *not* retain it
  79  */
  80 - (void)setDelegate: (id)delegate
  81 {
  82         _delegate = delegate;
  83 }
  84
  85 /**
  86  * Returns the name of the host to whom we are currently connected.
  87  */
  88 - (NSString *)remoteHost
  89 {
  90         struct sockaddr_in addr;
  91         socklen_t addrLength;
  92
  93         if (getpeername(_socket, (struct sockaddr *)&addr, &addrLength) < 0)
  94         {
  95                 [self postNotification: NsockError withObject: [NSError errorWithDomain: @"Could not get remote hostname." code: -1 userInfo: nil]];
  96         }
  97
  98         char *name = inet_ntoa(addr.sin_addr);
  99
 100         return [NSString stringWithUTF8String: name];
 101 }
 102
 103 /**
 104  * This is the notification listener for all types of notifications. If the notifications are from a SocketWrapper
 105  * class, it checks that the value of _delegate in the NSNotification's userInfo matches that of this object. If it does,
 106  * then the notification was sent from the same object in another thread and it passes the message along to the object's
 107  * delegate. Complicated enough?
 108  */
 109 - (void)sendMessageToDelegate: (NSNotification *)notif
 110 {
 111         // this isn't us, so there's no point in continuing
 112         if ([[notif userInfo] objectForKey: sockNotificationDebuggerConnection] != _delegate)
 113         {
 114                 return;
 115         }
 116
 117         NSString *name = [notif name];
 118
 119         if (name == NsockDidAccept)
 120         {
 121                 [_delegate socketDidAccept];
 122         }
 123         else if (name == NsockDataReceived)
 124         {
 125                 [_delegate dataReceived: [notif object] deliverTo: NSSelectorFromString([[notif userInfo] objectForKey: sockNotificationReceiver])];
 126         }
 127         else if (name == NsockDataSent)
 128         {
 129                 [_delegate dataSent: [notif object]];
 130         }
 131         else if (name == NsockError)
 132         {
 133                 [_delegate errorEncountered: [NSError errorWithDomain: [notif object] code: -1 userInfo: nil]];
 134         }
 135 }
 136
 137 /**
 138  * Connects to a socket on the port specified during init. This will dispatch another thread to do the
 139  * actual waiting. Delegate notifications are posted along the way to let the client know what is going on.
 140  */
 141 - (void)connect
 142 {
 143         [NSThread detachNewThreadSelector: @selector(connect:) toTarget: self withObject: nil];
 144 }
 145
 146 /**
 147  * This does the actual dirty work (in a separate thread) of connecting to a socket
 148  */
 149 - (void)connect: (id)obj
 150 {
 151         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 152
 153         // create an INET socket that we'll be listen()ing on
 154         int socketOpen = socket(PF_INET, SOCK_STREAM, 0);
 155
 156         // create our address given the port
 157         struct sockaddr_in address;
 158         address.sin_family = AF_INET;
 159         address.sin_port = htons(_port);
 160         address.sin_addr.s_addr = htonl(INADDR_ANY);
 161         memset(address.sin_zero, '\0', sizeof(address.sin_zero));
 162
 163         // bind the socket... and don't give up until we've tried for a while
 164         int tries = 0;
 165         while (bind(socketOpen, (struct sockaddr *)&address, sizeof(address)) < 0)
 166         {
 167                 if (tries >= 5)
 168                 {
 169                         close(socketOpen);
 170                         [self postNotification: NsockError withObject: @"Could not bind to socket"];
 171                         return;
 172                 }
 173                 NSLog(@"couldn't bind to the socket... trying again in 5");
 174                 sleep(5);
 175                 tries++;
 176         }
 177
 178         // now we just have to keep our ears open
 179         if (listen(socketOpen, 0) == -1)
 180         {
 181                 [self postNotification: NsockError withObject: @"Could not use bound socket for listening"];
 182         }
 183
 184         // accept a connection
 185         struct sockaddr_in remoteAddress;
 186         socklen_t remoteAddressLen = sizeof(remoteAddress);
 187         _socket = accept(socketOpen, (struct sockaddr *)&remoteAddress, &remoteAddressLen);
 188         if (_socket < 0)
 189         {
 190                 close(socketOpen);
 191                 [self postNotification: NsockError withObject: @"Client failed to accept remote socket"];
 192                 return;
 193         }
 194
 195         // we're done listening now that we have a connection
 196         close(socketOpen);
 197
 198         [self postNotification: NsockDidAccept withObject: nil];
 199
 200         [pool release];
 201 }
 202
 203 /**
 204  * Reads from the socket and returns the result as a NSString (because it's always going to be XML). Be aware
 205  * that the underlying socket recv() call will *wait* for the server to send a message, so be sure that this
 206  * is used either in a threaded environment so the interface does not hang, or when you *know* the server
 207  * will return something (which we almost always do).
 208  *
 209  * The paramater is an optional selector which the delegate method dataReceived:deliverTo: should forward to
 210  */
 211 - (void)receive: (SEL)selector
 212 {
 213         // create a buffer
 214         char buffer[1024];
 215
 216         // do our initial recv() call to get (hopefully) all the data and the lengh of the packet
 217         int recvd = recv(_socket, &buffer, sizeof(buffer), 0);
 218
 219         // take the received data and put it into an NSData
 220         NSMutableData *data = [NSMutableData data];
 221
 222         // strip the length from the packet, and clear the null byte then add it to the NSData
 223         char packetLength[8];
 224         memset(packetLength, '\0', sizeof(packetLength));
 225         int i = 0;
 226         while (buffer[i] != '\0')
 227         {
 228                 packetLength[i] = buffer[i];
 229                 i++;
 230         }
 231
 232         // we also want the null byte, so move us up 1
 233         i++;
 234
 235         // the total length of the full transmission
 236         int length = atoi(packetLength);
 237
 238         // move the packet part of the received data into it's own char[]
 239         char packet[sizeof(buffer)];
 240         memset(packet, '\0', sizeof(packet));
 241         memmove(packet, &buffer[i], recvd - i);
 242
 243         // convert bytes to NSData
 244         [data appendBytes: packet length: recvd - i];
 245
 246         // check if we have a partial packet
 247         if (length + i > sizeof(buffer))
 248         {
 249                 while (recvd < length)
 250                 {
 251                         int latest = recv(_socket, &buffer, sizeof(buffer), 0);
 252                         if (latest < 1)
 253                         {
 254                                 [self postNotification: NsockError withObject: @"Socket closed or could not be read"];
 255                                 return;
 256                         }
 257                         [data appendBytes: buffer length: latest];
 258                         recvd += latest;
 259                 }
 260         }
 261
 262         //NSLog(@"data = %@", [[[NSString alloc] initWithData: data encoding: NSUTF8StringEncoding] autorelease]);
 263
 264         if (selector != nil)
 265         {
 266                 [self postNotification: NsockDataReceived
 267                                          withObject: data
 268                                            withDict: [NSMutableDictionary dictionaryWithObject: NSStringFromSelector(selector) forKey: sockNotificationReceiver]];
 269         }
 270         else
 271         {
 272                 [self postNotification: NsockDataReceived withObject: data];
 273         }
 274 }
 275
 276 /**
 277  * Sends a given NSString over the socket
 278  */
 279 - (void)send: (NSString *)data
 280 {
 281         data = [NSString stringWithFormat: @"%@\0", data];
 282         int sent = send(_socket, [data UTF8String], [data length], 0);
 283         if (sent < 0)
 284         {
 285                 [self postNotification: NsockError withObject: @"Failed to write data to socket"];
 286                 return;
 287         }
 288         if (sent < [data length])
 289         {
 290                 // TODO - do we really need to worry about partial sends with the lenght of our commands?
 291                 NSLog(@"FAIL: only partial packet was sent; sent %d bytes", sent);
 292         }
 293
 294         [self postNotification: NsockDataSent withObject: [data substringToIndex: sent]];
 295 }
 296
 297 /**
 298  * Helper method to simply post a notification to the default notification center with a given name and object
 299  */
 300 - (void)postNotification: (NSString *)name withObject: (id)obj
 301 {
 302         [self postNotification: name withObject: obj withDict: [NSMutableDictionary dictionary]];
 303 }
 304
 305 /**
 306  * Another helper method to aid in the posting of notifications. This one should be used if you have additional
 307  * things for the userInfo. This automatically adds the sockNotificationDebuggerConnection key.
 308  */
 309 - (void)postNotification: (NSString *)name withObject: (id)obj withDict: (NSMutableDictionary *)dict
 310 {
 311         [dict setValue: _delegate forKey: sockNotificationDebuggerConnection];
 312         [[NSNotificationCenter defaultCenter] postNotificationName: name object: obj userInfo: dict];
 313 }
 314
 315 @end