Source/DebuggerConnection.m

   1 /*
   2  * MacGDBp
   3  * Copyright (c) 2007 - 2010, 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 <sys/socket.h>
  18 #import <netinet/in.h>
  19
  20 #import "DebuggerConnection.h"
  21
  22 #import "AppDelegate.h"
  23 #import "LoggingController.h"
  24
  25 // GDBpConnection (Private) ////////////////////////////////////////////////////
  26
  27 @interface DebuggerConnection ()
  28 @property (readwrite, copy) NSString* status;
  29 @property (assign) CFSocketRef socket;
  30 @property (assign) CFReadStreamRef readStream;
  31 @property NSUInteger lastReadTransaction;
  32 @property (retain) NSMutableString* currentPacket;
  33 @property (assign) CFWriteStreamRef writeStream;
  34 @property NSUInteger lastWrittenTransaction;
  35 @property (retain) NSMutableArray* queuedWrites;
  36
  37 - (void)connect;
  38 - (void)close;
  39 - (void)socketDidAccept;
  40 - (void)socketDisconnected;
  41 - (void)readStreamHasData;
  42 - (void)send:(NSString*)command;
  43 - (void)performSend:(NSString*)command;
  44 - (void)errorEncountered:(NSString*)error;
  45
  46 - (void)handleResponse:(NSXMLDocument*)response;
  47 - (void)handlePacket:(NSString*)packet;
  48
  49 - (void)initReceived:(NSXMLDocument*)response;
  50 - (void)updateStatus:(NSXMLDocument*)response;
  51 - (void)debuggerStep:(NSXMLDocument*)response;
  52 - (void)rebuildStack:(NSXMLDocument*)response;
  53 - (void)getStackFrame:(NSXMLDocument*)response;
  54 - (void)setSource:(NSXMLDocument*)response;
  55 - (void)contextsReceived:(NSXMLDocument*)response;
  56 - (void)variablesReceived:(NSXMLDocument*)response;
  57 - (void)propertiesReceived:(NSXMLDocument*)response;
  58
  59 - (NSNumber*)sendCommandWithCallback:(SEL)callback format:(NSString*)format, ...;
  60
  61 - (void)sendQueuedWrites;
  62
  63 - (NSString*)escapedURIPath:(NSString*)path;
  64 - (NSInteger)transactionIDFromResponse:(NSXMLDocument*)response;
  65 - (NSInteger)transactionIDFromCommand:(NSString*)command;
  66 @end
  67
  68 // CFNetwork Callbacks /////////////////////////////////////////////////////////
  69
  70 void ReadStreamCallback(CFReadStreamRef stream, CFStreamEventType eventType, void* connectionRaw)
  71 {
  72         DebuggerConnection* connection = (DebuggerConnection*)connectionRaw;
  73         switch (eventType)
  74         {
  75                 case kCFStreamEventHasBytesAvailable:
  76                         [connection readStreamHasData];
  77                         break;
  78
  79                 case kCFStreamEventErrorOccurred:
  80                 {
  81                         CFErrorRef error = CFReadStreamCopyError(stream);
  82                         CFReadStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
  83                         CFReadStreamClose(stream);
  84                         CFRelease(stream);
  85                         [connection errorEncountered:[[(NSError*)error autorelease] description]];
  86                         break;
  87                 }
  88
  89                 case kCFStreamEventEndEncountered:
  90                         CFReadStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
  91                         CFReadStreamClose(stream);
  92                         CFRelease(stream);
  93                         [connection socketDisconnected];
  94                         break;
  95         };
  96 }
  97
  98 void WriteStreamCallback(CFWriteStreamRef stream, CFStreamEventType eventType, void* connectionRaw)
  99 {
 100         DebuggerConnection* connection = (DebuggerConnection*)connectionRaw;
 101         switch (eventType)
 102         {
 103                 case kCFStreamEventCanAcceptBytes:
 104                         [connection sendQueuedWrites];
 105                         break;
 106
 107                 case kCFStreamEventErrorOccurred:
 108                 {
 109                         CFErrorRef error = CFWriteStreamCopyError(stream);
 110                         CFWriteStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 111                         CFWriteStreamClose(stream);
 112                         CFRelease(stream);
 113                         [connection errorEncountered:[[(NSError*)error autorelease] description]];
 114                         break;
 115                 }
 116
 117                 case kCFStreamEventEndEncountered:
 118                         CFWriteStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 119                         CFWriteStreamClose(stream);
 120                         CFRelease(stream);
 121                         [connection socketDisconnected];
 122                         break;
 123         }
 124 }
 125
 126 void SocketAcceptCallback(CFSocketRef socket,
 127                                                   CFSocketCallBackType callbackType,
 128                                                   CFDataRef address,
 129                                                   const void* data,
 130                                                   void* connectionRaw)
 131 {
 132         assert(callbackType == kCFSocketAcceptCallBack);
 133         NSLog(@"SocketAcceptCallback()");
 134
 135         DebuggerConnection* connection = (DebuggerConnection*)connectionRaw;
 136
 137         CFReadStreamRef readStream;
 138         CFWriteStreamRef writeStream;
 139
 140         // Create the streams on the socket.
 141         CFStreamCreatePairWithSocket(kCFAllocatorDefault,
 142                                                                  *(CFSocketNativeHandle*)data,  // Socket handle.
 143                                                                  &readStream,  // Read stream in-pointer.
 144                                                                  &writeStream);  // Write stream in-pointer.
 145
 146         // Create struct to register callbacks for the stream.
 147         CFStreamClientContext context;
 148         context.version = 0;
 149         context.info = connection;
 150         context.retain = NULL;
 151         context.release = NULL;
 152         context.copyDescription = NULL;
 153
 154         // Set the client of the read stream.
 155         CFOptionFlags readFlags =
 156                 kCFStreamEventOpenCompleted |
 157                 kCFStreamEventHasBytesAvailable |
 158                 kCFStreamEventErrorOccurred |
 159                 kCFStreamEventEndEncountered;
 160         if (CFReadStreamSetClient(readStream, readFlags, ReadStreamCallback, &context))
 161                 // Schedule in run loop to do asynchronous communication with the engine.
 162                 CFReadStreamScheduleWithRunLoop(readStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 163         else
 164                 return;
 165
 166         // Open the stream now that it's scheduled on the run loop.
 167         if (!CFReadStreamOpen(readStream))
 168         {
 169                 CFStreamError error = CFReadStreamGetError(readStream);
 170                 NSLog(@"error! %@", error);
 171                 return;
 172         }
 173
 174         // Set the client of the write stream.
 175         CFOptionFlags writeFlags =
 176                 kCFStreamEventOpenCompleted |
 177                 kCFStreamEventCanAcceptBytes |
 178                 kCFStreamEventErrorOccurred |
 179                 kCFStreamEventEndEncountered;
 180         if (CFWriteStreamSetClient(writeStream, writeFlags, WriteStreamCallback, &context))
 181                 // Schedule it in the run loop to receive error information.
 182                 CFWriteStreamScheduleWithRunLoop(writeStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 183         else
 184                 return;
 185
 186         // Open the write stream.
 187         if (!CFWriteStreamOpen(writeStream))
 188         {
 189                 CFStreamError error = CFWriteStreamGetError(writeStream);
 190                 NSLog(@"error! %@", error);
 191                 return;
 192         }
 193
 194         connection.readStream = readStream;
 195         connection.writeStream = writeStream;
 196         [connection socketDidAccept];
 197 }
 198
 199 // GDBpConnection //////////////////////////////////////////////////////////////
 200
 201 @implementation DebuggerConnection
 202 @synthesize socket = socket_;
 203 @synthesize readStream = readStream_;
 204 @synthesize lastReadTransaction = lastReadTransaction_;
 205 @synthesize currentPacket = currentPacket_;
 206 @synthesize writeStream = writeStream_;
 207 @synthesize lastWrittenTransaction = lastWrittenTransaction_;
 208 @synthesize queuedWrites = queuedWrites_;
 209 @synthesize status;
 210 @synthesize delegate;
 211
 212 /**
 213  * Creates a new DebuggerConnection and initializes the socket from the given connection
 214  * paramters.
 215  */
 216 - (id)initWithPort:(NSUInteger)aPort
 217 {
 218         if (self = [super init])
 219         {
 220                 port = aPort;
 221                 connected = NO;
 222
 223                 [[BreakpointManager sharedManager] setConnection:self];
 224                 [self connect];
 225         }
 226         return self;
 227 }
 228
 229 /**
 230  * Deallocates the object
 231  */
 232 - (void)dealloc
 233 {
 234         [self close];
 235         self.currentPacket = nil;
 236
 237         [super dealloc];
 238 }
 239
 240
 241 // Getters /////////////////////////////////////////////////////////////////////
 242 #pragma mark Getters
 243
 244 /**
 245  * Gets the port number
 246  */
 247 - (NSUInteger)port
 248 {
 249         return port;
 250 }
 251
 252 /**
 253  * Returns the name of the remote host
 254  */
 255 - (NSString*)remoteHost
 256 {
 257         if (!connected)
 258         {
 259                 return @"(DISCONNECTED)";
 260         }
 261         // TODO: Either impl or remove.
 262         return @"";
 263 }
 264
 265 /**
 266  * Returns whether or not we have an active connection
 267  */
 268 - (BOOL)isConnected
 269 {
 270         return connected;
 271 }
 272
 273 // Commands ////////////////////////////////////////////////////////////////////
 274 #pragma mark Commands
 275
 276 /**
 277  * Reestablishes communication with the remote debugger so that a new connection doesn't have to be
 278  * created every time you want to debug a page
 279  */
 280 - (void)reconnect
 281 {
 282         [self close];
 283         self.status = @"Connecting";
 284         [self connect];
 285 }
 286
 287 /**
 288  * Tells the debugger to continue running the script. Returns the current stack frame.
 289  */
 290 - (void)run
 291 {
 292         [self sendCommandWithCallback:@selector(debuggerStep:) format:@"run"];
 293 }
 294
 295 /**
 296  * Tells the debugger to step into the current command.
 297  */
 298 - (void)stepIn
 299 {
 300         [self sendCommandWithCallback:@selector(debuggerStep:) format:@"step_into"];
 301 }
 302
 303 /**
 304  * Tells the debugger to step out of the current context
 305  */
 306 - (void)stepOut
 307 {
 308         [self sendCommandWithCallback:@selector(debuggerStep:) format:@"step_out"];
 309 }
 310
 311 /**
 312  * Tells the debugger to step over the current function
 313  */
 314 - (void)stepOver
 315 {
 316         [self sendCommandWithCallback:@selector(debuggerStep:) format:@"step_over"];
 317 }
 318
 319 /**
 320  * Tells the debugger engine to get a specifc property. This also takes in the NSXMLElement
 321  * that requested it so that the child can be attached.
 322  */
 323 - (NSInteger)getProperty:(NSString*)property
 324 {
 325         [self sendCommandWithCallback:@selector(propertiesReceived:) format:@"property_get -n \"%@\"", property];
 326 }
 327
 328 // Breakpoint Management ///////////////////////////////////////////////////////
 329 #pragma mark Breakpoints
 330
 331 /**
 332  * Send an add breakpoint command
 333  */
 334 - (void)addBreakpoint:(Breakpoint*)bp
 335 {
 336         if (!connected)
 337                 return;
 338
 339         NSString* file = [self escapedURIPath:[bp transformedPath]];
 340         NSNumber* transaction = [self sendCommandWithCallback:@selector(breakpointReceived:)
 341                                                                                                    format:@"breakpoint_set -t line -f %@ -n %i", file, [bp line]];
 342         [callbackContext_ setObject:bp forKey:transaction];
 343 }
 344
 345 /**
 346  * Removes a breakpoint
 347  */
 348 - (void)removeBreakpoint:(Breakpoint*)bp
 349 {
 350         if (!connected)
 351         {
 352                 return;
 353         }
 354
 355         [self sendCommandWithCallback:nil format:@"breakpoint_remove -d %i", [bp debuggerId]];
 356 }
 357
 358
 359 // Socket and Stream Callbacks /////////////////////////////////////////////////
 360 #pragma mark Callbacks
 361
 362 /**
 363  * Called by SocketWrapper after the connection is successful. This immediately calls
 364  * -[SocketWrapper receive] to clear the way for communication, though the information
 365  * could be useful server information that we don't use right now.
 366  */
 367 - (void)socketDidAccept
 368 {
 369         connected = YES;
 370         transactionID = 1;
 371         stackFrames_ = [[NSMutableDictionary alloc] init];
 372         self.queuedWrites = [NSMutableArray array];
 373         writeQueueLock_ = [NSRecursiveLock new];
 374         callTable_ = [NSMutableDictionary new];
 375         callbackContext_ = [NSMutableDictionary new];
 376 }
 377
 378 /**
 379  * Receives errors from the SocketWrapper and updates the display
 380  */
 381 - (void)errorEncountered:(NSString*)error
 382 {
 383         [delegate errorEncountered:error];
 384 }
 385
 386 /**
 387  * Creates, connects to, and schedules a CFSocket.
 388  */
 389 - (void)connect
 390 {
 391         // Pass ourselves to the callback so we don't have to use ugly globals.
 392         CFSocketContext context;
 393         context.version = 0;
 394         context.info = self;
 395         context.retain = NULL;
 396         context.release = NULL;
 397         context.copyDescription = NULL;
 398
 399         // Create the address structure.
 400         struct sockaddr_in address;
 401         memset(&address, 0, sizeof(address));
 402         address.sin_len = sizeof(address);
 403         address.sin_family = AF_INET;
 404         address.sin_port = htons(port);
 405         address.sin_addr.s_addr = htonl(INADDR_ANY);
 406
 407         // Create the socket signature.
 408         CFSocketSignature signature;
 409         signature.protocolFamily = PF_INET;
 410         signature.socketType = SOCK_STREAM;
 411         signature.protocol = IPPROTO_TCP;
 412         signature.address = (CFDataRef)[NSData dataWithBytes:&address length:sizeof(address)];
 413
 414         socket_ = CFSocketCreateWithSocketSignature(kCFAllocatorDefault,
 415                                                                                                 &signature,  // Socket signature.
 416                                                                                                 kCFSocketAcceptCallBack,  // Callback types.
 417                                                                                                 SocketAcceptCallback,  // Callout function pointer.
 418                                                                                                 &context);  // Context to pass to callout.
 419         if (!socket_)
 420         {
 421                 [self errorEncountered:@"Could not open socket."];
 422                 return;
 423         }
 424
 425         // Allow old, yet-to-be recycled sockets to be reused.
 426         BOOL yes = YES;
 427         setsockopt(CFSocketGetNative(socket_), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(BOOL));
 428
 429         // Schedule the socket on the run loop.
 430         CFRunLoopSourceRef source = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket_, 0);
 431         CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
 432         CFRelease(source);
 433
 434         self.status = @"Connecting";
 435 }
 436
 437 /**
 438  * Closes a socket and releases the ref.
 439  */
 440 - (void)close
 441 {
 442         // The socket goes down, so do the streams, which clean themselves up.
 443         CFSocketInvalidate(socket_);
 444         CFRelease(socket_);
 445         [stackFrames_ release];
 446         self.queuedWrites = nil;
 447         [writeQueueLock_ release];
 448         [callTable_ release];
 449         [callbackContext_ release];
 450 }
 451
 452 /**
 453  * Notification that the socket disconnected.
 454  */
 455 - (void)socketDisconnected
 456 {
 457         [self close];
 458         [delegate debuggerDisconnected];
 459 }
 460
 461 /**
 462  * Callback from the CFReadStream that there is data waiting to be read.
 463  */
 464 - (void)readStreamHasData
 465 {
 466         const NSUInteger kBufferSize = 1024;
 467         UInt8 buffer[kBufferSize];
 468         CFIndex bufferOffset = 0;  // Starting point in |buffer| to work with.
 469         CFIndex bytesRead = CFReadStreamRead(readStream_, buffer, kBufferSize);
 470         const char* charBuffer = (const char*)buffer;
 471
 472         // The read loop works by going through the buffer until all the bytes have
 473         // been processed.
 474         while (bufferOffset < bytesRead)
 475         {
 476                 // strlen() counts to the first non-NULL character.
 477                 NSUInteger partLength = MIN(strlen(charBuffer + bufferOffset), kBufferSize - bufferOffset);
 478
 479                 // If there is not a current packet, set some state.
 480                 if (!self.currentPacket)
 481                 {
 482                         // Read the message header: the size.  This will be |partLength| bytes.
 483                         packetSize_ = atoi(charBuffer + bufferOffset);
 484                         currentPacketIndex_ = 0;
 485                         self.currentPacket = [NSMutableString stringWithCapacity:packetSize_];
 486                         bufferOffset += partLength + 1;  // Pass over the NULL byte.
 487                         continue;  // Spin the loop to begin reading actual data.
 488                 }
 489
 490                 // Substring the byte stream and append it to the packet string.
 491                 CFStringRef bufferString = CFStringCreateWithBytes(kCFAllocatorDefault,
 492                                                                                                                    buffer + bufferOffset,  // Byte pointer, offset by start index.
 493                                                                                                                    partLength,  // Length.
 494                                                                                                                    kCFStringEncodingUTF8,
 495                                                                                                                    true);
 496                 [self.currentPacket appendString:(NSString*)bufferString];
 497                 CFRelease(bufferString);
 498
 499                 // Advance counters.
 500                 currentPacketIndex_ += partLength;
 501                 bufferOffset += partLength + 1;
 502
 503                 // If this read finished the packet, handle it and reset.
 504                 NSLog(@"cpi %d ps %d br %d ds %d", currentPacketIndex_, packetSize_, bytesRead, partLength);
 505                 if (currentPacketIndex_ >= packetSize_)
 506                 {
 507                         [self handlePacket:[[currentPacket_ retain] autorelease]];
 508                         self.currentPacket = nil;
 509                         packetSize_ = 0;
 510                         currentPacketIndex_ = 0;
 511                 }
 512         }
 513 }
 514
 515 /**
 516  * Performs the packet handling of a raw string XML packet. From this point on,
 517  * the packets are associated with a transaction and are then dispatched.
 518  */
 519 - (void)handlePacket:(NSString*)packet
 520 {
 521         // Test if we can convert it into an NSXMLDocument.
 522         NSError* error = nil;
 523         NSXMLDocument* xmlTest = [[NSXMLDocument alloc] initWithXMLString:currentPacket_ options:NSXMLDocumentTidyXML error:&error];
 524
 525         // Try to recover if we encountered an error.
 526         if (!xmlTest)
 527         {
 528                 // We do not want to starve the write queue, so manually parse out the
 529                 // transaction ID.
 530                 NSRange location = [currentPacket_ rangeOfString:@"transaction_id"];
 531                 if (location.location != NSNotFound)
 532                 {
 533                         NSUInteger start = location.location + location.length;
 534                         NSUInteger end = start;
 535
 536                         NSCharacterSet* numericSet = [NSCharacterSet decimalDigitCharacterSet];
 537
 538                         // Loop over the characters after the attribute name to extract the ID.
 539                         while (end < [currentPacket_ length])
 540                         {
 541                                 unichar c = [currentPacket_ characterAtIndex:end];
 542                                 if ([numericSet characterIsMember:c])
 543                                 {
 544                                         // If this character is numeric, extend the range to substring.
 545                                         ++end;
 546                                 }
 547                                 else
 548                                 {
 549                                         if (start == end)
 550                                         {
 551                                                 // If this character is nonnumeric and we have nothing in the
 552                                                 // range, skip this character.
 553                                                 ++start;
 554                                                 ++end;
 555                                         }
 556                                         else
 557                                         {
 558                                                 // We've moved past the numeric ID so we should stop searching.
 559                                                 break;
 560                                         }
 561                                 }
 562                         }
 563
 564                         // If we were able to extract the transaction ID, update the last read.
 565                         NSRange substringRange = NSMakeRange(start, end - start);
 566                         NSString* transactionStr = [currentPacket_ substringWithRange:substringRange];
 567                         if ([transactionStr length])
 568                                 lastReadTransaction_ = [transactionStr intValue];
 569                 }
 570
 571                 // Otherwise, assume +1 and hope it works.
 572                 ++lastReadTransaction_;
 573         }
 574         else
 575         {
 576                 // See if the transaction can be parsed out.
 577                 NSInteger transaction = [self transactionIDFromResponse:xmlTest];
 578                 if (transaction < lastReadTransaction_)
 579                 {
 580                         NSLog(@"tx = %d vs %d", transaction, lastReadTransaction_);
 581                         NSLog(@"out of date transaction %@", packet);
 582                         return;
 583                 }
 584
 585                 if (transaction != lastWrittenTransaction_)
 586                         NSLog(@"txn %d(%d) <> %d doesn't match last written", transaction, lastReadTransaction_, lastWrittenTransaction_);
 587
 588                 lastReadTransaction_ = transaction;
 589         }
 590
 591         // Log this receive event.
 592         LoggingController* logger = [(AppDelegate*)[NSApp delegate] loggingController];
 593         LogEntry* log = [logger recordReceive:currentPacket_];
 594         log.error = error;
 595         log.lastWrittenTransactionID = lastWrittenTransaction_;
 596         log.lastReadTransactionID = lastReadTransaction_;
 597
 598         // Finally, dispatch the handler for this response.
 599         [self handleResponse:[xmlTest autorelease]];
 600 }
 601
 602 /**
 603  * Writes a command into the write stream. If the stream is ready for writing,
 604  * we do so immediately. If not, the command is queued and will be written
 605  * when the stream is ready.
 606  */
 607 - (void)send:(NSString*)command
 608 {
 609         if (CFWriteStreamCanAcceptBytes(writeStream_))
 610                 [self performSend:command];
 611         else
 612                 [queuedWrites_ addObject:command];
 613         [self sendQueuedWrites];
 614 }
 615
 616 /**
 617  * This performs a blocking send. This should ONLY be called when we know we
 618  * have write access to the stream. We will busy wait in case we don't do a full
 619  * send.
 620  */
 621 - (void)performSend:(NSString*)command
 622 {
 623         // If this is an out-of-date transaction, do not bother sending it.
 624         NSInteger transaction = [self transactionIDFromCommand:command];
 625         if (transaction != NSNotFound && transaction < lastWrittenTransaction_)
 626                 return;
 627
 628         BOOL done = NO;
 629
 630         char* string = (char*)[command UTF8String];
 631         int stringLength = strlen(string);
 632
 633         // Busy wait while writing. BAADD. Should background this operation.
 634         while (!done)
 635         {
 636                 if (CFWriteStreamCanAcceptBytes(writeStream_))
 637                 {
 638                         // Include the NULL byte in the string when we write.
 639                         int bytesWritten = CFWriteStreamWrite(writeStream_, (UInt8*)string, stringLength + 1);
 640                         if (bytesWritten < 0)
 641                         {
 642                                 NSLog(@"write error");
 643                         }
 644                         // Incomplete write.
 645                         else if (bytesWritten < strlen(string))
 646                         {
 647                                 // Adjust the buffer and wait for another chance to write.
 648                                 stringLength -= bytesWritten;
 649                                 memmove(string, string + bytesWritten, stringLength);
 650                         }
 651                         else
 652                         {
 653                                 done = YES;
 654
 655                                 // We need to scan the string to find the transactionID.
 656                                 if (transaction == NSNotFound)
 657                                 {
 658                                         NSLog(@"sent %@ without a transaction ID", command);
 659                                         continue;
 660                                 }
 661                                 lastWrittenTransaction_ = transaction;
 662                         }
 663                 }
 664         }
 665
 666         // Log this trancation.
 667         LoggingController* logger = [(AppDelegate*)[NSApp delegate] loggingController];
 668         LogEntry* log = [logger recordSend:command];
 669         log.lastWrittenTransactionID = lastWrittenTransaction_;
 670         log.lastReadTransactionID = lastReadTransaction_;
 671 }
 672
 673 - (void)handleResponse:(NSXMLDocument*)response
 674 {
 675         // Check and see if there's an error.
 676         NSArray* error = [[response rootElement] elementsForName:@"error"];
 677         if ([error count] > 0)
 678         {
 679                 NSLog(@"Xdebug error: %@", error);
 680                 [delegate errorEncountered:[[[[error objectAtIndex:0] children] objectAtIndex:0] stringValue]];
 681         }
 682
 683         if ([[[response rootElement] name] isEqualToString:@"init"])
 684         {
 685                 [self initReceived:response];
 686                 return;
 687         }
 688
 689         NSString* callbackStr = [callTable_ objectForKey:[NSNumber numberWithInt:lastReadTransaction_]];
 690         if (callbackStr)
 691         {
 692                 SEL callback = NSSelectorFromString(callbackStr);
 693                 [self performSelector:callback withObject:response];
 694         }
 695
 696         [self sendQueuedWrites];
 697 }
 698
 699 // Specific Response Handlers //////////////////////////////////////////////////
 700 #pragma mark Response Handlers
 701
 702 /**
 703  * Initial packet received. We've started a brand-new connection to the engine.
 704  */
 705 - (void)initReceived:(NSXMLDocument*)response
 706 {
 707         // Register any breakpoints that exist offline.
 708         for (Breakpoint* bp in [[BreakpointManager sharedManager] breakpoints])
 709                 [self addBreakpoint:bp];
 710
 711         // Load the debugger to make it look active.
 712         [delegate debuggerConnected];
 713
 714         // TODO: update the status.
 715 }
 716
 717 /**
 718  * Receiver for status updates. This just freshens up the UI.
 719  */
 720 - (void)updateStatus:(NSXMLDocument*)response
 721 {
 722         self.status = [[[[response rootElement] attributeForName:@"status"] stringValue] capitalizedString];
 723         if (status == nil || [status isEqualToString:@"Stopped"] || [status isEqualToString:@"Stopping"])
 724         {
 725                 connected = NO;
 726                 [self close];
 727                 [delegate debuggerDisconnected];
 728
 729                 self.status = @"Stopped";
 730         }
 731 }
 732
 733 /**
 734  * Step in/out/over and run all take this path. We first get the status of the
 735  * debugger and then request fresh stack information.
 736  */
 737 - (void)debuggerStep:(NSXMLDocument*)response
 738 {
 739         [self updateStatus:response];
 740         if (!connected)
 741                 return;
 742
 743         // If this is the run command, tell the delegate that a bunch of updates
 744         // are coming. Also remove all existing stack routes and request a new stack.
 745         // TODO: figure out if we can not clobber the stack every time.
 746         NSString* command = [[[response rootElement] attributeForName:@"command"] stringValue];
 747         if (YES || [command isEqualToString:@"run"])
 748         {
 749                 if ([delegate respondsToSelector:@selector(clobberStack)])
 750                         [delegate clobberStack];
 751                 [stackFrames_ removeAllObjects];
 752                 stackFirstTransactionID_ = [[self sendCommandWithCallback:@selector(rebuildStack:) format:@"stack_depth"] intValue];
 753         }
 754 }
 755
 756 /**
 757  * We ask for the stack_depth and now we clobber the stack and start rebuilding
 758  * it.
 759  */
 760 - (void)rebuildStack:(NSXMLDocument*)response
 761 {
 762         NSInteger depth = [[[[response rootElement] attributeForName:@"depth"] stringValue] intValue];
 763
 764         if (stackFirstTransactionID_ == [self transactionIDFromResponse:response])
 765                 stackDepth_ = depth;
 766
 767         // We now need to alloc a bunch of stack frames and get the basic information
 768         // for them.
 769         for (NSInteger i = 0; i < depth; i++)
 770         {
 771                 // Use the transaction ID to create a routing path.
 772                 NSNumber* routingID = [self sendCommandWithCallback:@selector(getStackFrame:) format:@"stack_get -d %d", i];
 773                 [stackFrames_ setObject:[StackFrame alloc] forKey:routingID];
 774         }
 775 }
 776
 777 /**
 778  * The initial rebuild of the stack frame. We now have enough to initialize
 779  * a StackFrame object.
 780  */
 781 - (void)getStackFrame:(NSXMLDocument*)response
 782 {
 783         // Get the routing information.
 784         NSInteger routingID = [self transactionIDFromResponse:response];
 785         if (routingID < stackFirstTransactionID_)
 786                 return;
 787         NSNumber* routingNumber = [NSNumber numberWithInt:routingID];
 788
 789         // Make sure we initialized this frame in our last |-rebuildStack:|.
 790         StackFrame* frame = [stackFrames_ objectForKey:routingNumber];
 791         if (!frame)
 792                 return;
 793
 794         NSXMLElement* xmlframe = [[[response rootElement] children] objectAtIndex:0];
 795
 796         // Initialize the stack frame.
 797         [frame initWithIndex:[[[xmlframe attributeForName:@"level"] stringValue] intValue]
 798                         withFilename:[[xmlframe attributeForName:@"filename"] stringValue]
 799                           withSource:nil
 800                                   atLine:[[[xmlframe attributeForName:@"lineno"] stringValue] intValue]
 801                           inFunction:[[xmlframe attributeForName:@"where"] stringValue]
 802                    withVariables:nil];
 803
 804         // Get the source code of the file. Escape % in URL chars.
 805         NSString* escapedFilename = [frame.filename stringByReplacingOccurrencesOfString:@"%" withString:@"%%"];
 806         NSNumber* transaction = [self sendCommandWithCallback:@selector(setSource:) format:@"source -f %@", escapedFilename];
 807         [callbackContext_ setObject:routingNumber forKey:transaction];
 808
 809         // Get the names of all the contexts.
 810         transaction = [self sendCommandWithCallback:@selector(contextsReceived:) format:@"context_names -d %d", frame.index];
 811         [callbackContext_ setObject:routingNumber forKey:transaction];
 812
 813         if ([delegate respondsToSelector:@selector(newStackFrame:)])
 814                 [delegate newStackFrame:frame];
 815 }
 816
 817 /**
 818  * Callback for setting the source of a file while rebuilding a specific stack
 819  * frame.
 820  */
 821 - (void)setSource:(NSXMLDocument*)response
 822 {
 823         NSNumber* transaction = [NSNumber numberWithInt:[self transactionIDFromResponse:response]];
 824         if ([transaction intValue] < stackFirstTransactionID_)
 825                 return;
 826         NSNumber* routingNumber = [callbackContext_ objectForKey:transaction];
 827         if (!routingNumber)
 828                 return;
 829
 830         [callbackContext_ removeObjectForKey:transaction];
 831         StackFrame* frame = [stackFrames_ objectForKey:routingNumber];
 832         if (!frame)
 833                 return;
 834
 835         frame.source = [[response rootElement] value];
 836
 837         if ([delegate respondsToSelector:@selector(sourceUpdated:)])
 838                 [delegate sourceUpdated:frame];
 839 }
 840
 841 /**
 842  * Enumerates all the contexts of a given stack frame. We then in turn get the
 843  * contents of each one of these contexts.
 844  */
 845 - (void)contextsReceived:(NSXMLDocument*)response
 846 {
 847         // Get the stack frame's routing ID and use it again.
 848         NSNumber* receivedTransaction = [NSNumber numberWithInt:[self transactionIDFromResponse:response]];
 849         if ([receivedTransaction intValue] < stackFirstTransactionID_)
 850                 return;
 851         NSNumber* routingID = [callbackContext_ objectForKey:receivedTransaction];
 852         if (!routingID)
 853                 return;
 854
 855         // Get the stack frame by the |routingID|.
 856         StackFrame* frame = [stackFrames_ objectForKey:routingID];
 857
 858         NSXMLElement* contextNames = [response rootElement];
 859         for (NSXMLElement* context in [contextNames children])
 860         {
 861                 NSInteger cid = [[[context attributeForName:@"id"] stringValue] intValue];
 862
 863                 // Fetch each context's variables.
 864                 NSNumber* transaction = [self sendCommandWithCallback:@selector(variablesReceived:)
 865                                                                                                            format:@"context_get -d %d -c %d", frame.index, cid];
 866                 [callbackContext_ setObject:routingID forKey:transaction];
 867         }
 868 }
 869
 870 /**
 871  * Receives the variables from the context and attaches them to the stack frame.
 872  */
 873 - (void)variablesReceived:(NSXMLDocument*)response
 874 {
 875         // Get the stack frame's routing ID and use it again.
 876         NSInteger transaction = [self transactionIDFromResponse:response];
 877         if (transaction < stackFirstTransactionID_)
 878                 return;
 879         NSNumber* receivedTransaction = [NSNumber numberWithInt:transaction];
 880         NSNumber* routingID = [callbackContext_ objectForKey:receivedTransaction];
 881         if (!routingID)
 882                 return;
 883
 884         // Get the stack frame by the |routingID|.
 885         StackFrame* frame = [stackFrames_ objectForKey:routingID];
 886
 887         NSMutableArray* variables = [NSMutableArray array];
 888
 889         // Merge the frame's existing variables.
 890         if (frame.variables)
 891                 [variables addObjectsFromArray:frame.variables];
 892
 893         // Add these new variables.
 894         NSArray* addVariables = [[response rootElement] children];
 895         if (addVariables)
 896                 [variables addObjectsFromArray:addVariables];
 897
 898         frame.variables = variables;
 899 }
 900
 901 /**
 902  * Callback from a |-getProperty:| request.
 903  */
 904 - (void)propertiesReceived:(NSXMLDocument*)response
 905 {
 906         NSInteger transaction = [self transactionIDFromResponse:response];
 907
 908         /*
 909          <response>
 910                  <property> <!-- this is the one we requested -->
 911                          <property ... /> <!-- these are what we want -->
 912                  </property>
 913          </repsonse>
 914          */
 915
 916         // Detach all the children so we can insert them into another document.
 917         NSXMLElement* parent = (NSXMLElement*)[[response rootElement] childAtIndex:0];
 918         NSArray* children = [parent children];
 919         [parent setChildren:nil];
 920
 921         [delegate receivedProperties:children forTransaction:transaction];
 922 }
 923
 924 /**
 925  * Callback for setting a breakpoint.
 926  */
 927 - (void)breakpointReceived:(NSXMLDocument*)response
 928 {
 929         NSNumber* transaction = [NSNumber numberWithInt:[self transactionIDFromResponse:response]];
 930         Breakpoint* bp = [callbackContext_ objectForKey:transaction];
 931         if (!bp)
 932                 return;
 933
 934         [callbackContext_ removeObjectForKey:callbackContext_];
 935         [bp setDebuggerId:[[[[response rootElement] attributeForName:@"id"] stringValue] intValue]];
 936 }
 937
 938 #pragma mark Private
 939
 940 /**
 941  * This will send a command to the debugger engine. It will append the
 942  * transaction ID automatically. It accepts a NSString command along with a
 943  * a variable number of arguments to substitute into the command, a la
 944  * +[NSString stringWithFormat:]. Returns the transaction ID as a NSNumber.
 945  */
 946 - (NSNumber*)sendCommandWithCallback:(SEL)callback format:(NSString*)format, ...
 947 {
 948         // Collect varargs and format command.
 949         va_list args;
 950         va_start(args, format);
 951         NSString* command = [[NSString alloc] initWithFormat:format arguments:args];
 952         va_end(args);
 953
 954         NSNumber* callbackKey = [NSNumber numberWithInt:transactionID++];
 955         if (callback)
 956                 [callTable_ setObject:NSStringFromSelector(callback) forKey:callbackKey];
 957
 958         [self send:[NSString stringWithFormat:@"%@ -i %@", [command autorelease], callbackKey]];
 959
 960         return callbackKey;
 961 }
 962
 963 /**
 964  * Checks if there are unsent commands in the |queuedWrites_| queue and sends
 965  * them if it's OK to do so. This will not block.
 966  */
 967 - (void)sendQueuedWrites
 968 {
 969         if (!connected)
 970                 return;
 971
 972         [writeQueueLock_ lock];
 973         if (lastReadTransaction_ >= lastWrittenTransaction_ && [queuedWrites_ count] > 0)
 974         {
 975                 NSString* command = [queuedWrites_ objectAtIndex:0];
 976
 977                 // We don't want to block because this is called from the main thread.
 978                 // |-performSend:| busy waits when the stream is not ready. Bail out
 979                 // before we do that becuase busy waiting is BAD.
 980                 if (CFWriteStreamCanAcceptBytes(writeStream_))
 981                 {
 982                         [self performSend:command];
 983                         [queuedWrites_ removeObjectAtIndex:0];
 984                 }
 985         }
 986         [writeQueueLock_ unlock];
 987 }
 988
 989 /**
 990  * Given a file path, this returns a file:// URI and escapes any spaces for the
 991  * debugger engine.
 992  */
 993 - (NSString*)escapedURIPath:(NSString*)path
 994 {
 995         // Custon GDBp paths are fine.
 996         if ([[path substringToIndex:4] isEqualToString:@"gdbp"])
 997                 return path;
 998
 999         // Create a temporary URL that will escape all the nasty characters.
1000         NSURL* url = [NSURL fileURLWithPath:path];
1001         NSString* urlString = [url absoluteString];
1002
1003         // Remove the host because this is a file:// URL;
1004         urlString = [urlString stringByReplacingOccurrencesOfString:[url host] withString:@""];
1005
1006         // Escape % for use in printf-style NSString formatters.
1007         urlString = [urlString stringByReplacingOccurrencesOfString:@"%" withString:@"%%"];
1008         return urlString;
1009 }
1010
1011 /**
1012  * Returns the transaction_id from an NSXMLDocument.
1013  */
1014 - (NSInteger)transactionIDFromResponse:(NSXMLDocument*)response
1015 {
1016         return [[[[response rootElement] attributeForName:@"transaction_id"] stringValue] intValue];
1017 }
1018
1019 /**
1020  * Scans a command string for the transaction ID component. If it is not found,
1021  * returns NSNotFound.
1022  */
1023 - (NSInteger)transactionIDFromCommand:(NSString*)command
1024 {
1025         NSRange occurrence = [command rangeOfString:@"-i "];
1026         if (occurrence.location == NSNotFound)
1027                 return NSNotFound;
1028         NSString* transaction = [command substringFromIndex:occurrence.location + occurrence.length];
1029         return [transaction intValue];
1030 }
1031
1032 @end