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