Instance Methods
(void)	- closeConnection

(BOOL)	- sendBytes:count:

(void)	- sendDictionary:

(void)	- sendPacket:withParameters:

(void)	- sendPacket:withValue:forParameter:

(void)	- readData

(void)	- dispatchPacket:ofType:

(void)	- handleApproveConnectionPacket:

(void)	- handleRejectConnectionPacket:

(void)	- handleCloseConnectionPacket:

(void)	- handleNoteConfigurationChangePacket:

(void)	- handlePerformCommandPacket:

(void)	- handleRequestConfigurationValuePacket:

(void)	- handlePingPacket:

(void)	- handlePongPacket:

(void)	- disconnectFromServerWithMessage:

(void)	- breakConnectionWithMessage:

(void)	- breakConnectionWithBadStream:

Detailed Description

Definition at line 68 of file OODebugTCPConsoleClient.m.

Method Documentation

◆ breakConnectionWithBadStream:

- (void) breakConnectionWithBadStream: (NSStream *) stream

Extends class OODebugTCPConsoleClient.

Definition at line 681 of file OODebugTCPConsoleClient.m.

                                     :(NSStream *)stream
{
    NSString                *errorDesc = nil;
    NSError                 *error = nil;
    
    error = [stream streamError];
    errorDesc = [error localizedDescription];
    if (errorDesc == nil)  errorDesc = [error description];
    if (errorDesc == nil)  errorDesc = @"bad stream.";
    [self breakConnectionWithMessage:[NSString stringWithFormat:
       @"Connection to debug console failed: '%@' (outStream status: %li, inStream status: %li).",
        errorDesc, [_outStream streamStatus], [_inStream streamStatus]]];
}

References OODebugTCPConsoleClient::breakConnectionWithMessage:, and nil.

Here is the call graph for this function:

◆ breakConnectionWithMessage:

- (void) breakConnectionWithMessage: (NSString *) message

Extends class OODebugTCPConsoleClient.

Definition at line 658 of file OODebugTCPConsoleClient.m.

                                   :(NSString *)message
{
    [self closeConnection];
    
    if (_status != kOOTCPClientConnectionRefused)  _status = kOOTCPClientDisconnected;
    
    if ([message length] > 0)
    {
        OOLog(@"debugTCP.disconnect", @"No connection to debug console: \"%@\"", message);
    }
    else
    {
        OOLog(@"debugTCP.disconnect", @"%@", @"Debug console not connected."); 
    }
    
#if 0
    // Disconnecting causes crashiness for reasons I don't understand, and isn't very important anyway.
    [_monitor disconnectDebugger:self message:message];
    _monitor = nil;
#endif
}

References OODebugTCPConsoleClient::closeConnection, kOOTCPClientConnectionRefused, kOOTCPClientDisconnected, nil, and OOLog.

Here is the call graph for this function:

◆ closeConnection

- (void) closeConnection

Extends class OODebugTCPConsoleClient.

Definition at line 322 of file OODebugTCPConsoleClient.m.

{
    [_inStream close];
    [_inStream setDelegate:nil];
    [_inStream release];
    _inStream = nil;
    
    [_outStream close];
    [_outStream setDelegate:nil];
    [_outStream release];
    _outStream = nil;
    
    [_host release];
    _host = nil;
}

References closeConnection, and nil.

Referenced by closeConnection.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnectFromServerWithMessage:

- (void) disconnectFromServerWithMessage: (NSString *) message

Extends class OODebugTCPConsoleClient.

Definition at line 644 of file OODebugTCPConsoleClient.m.

                                        :(NSString *)message
{
    if (StatusIsSendable(_status))
    {
        [self sendPacket:kOOTCPPacket_CloseConnection
                withValue:message
             forParameter:kOOTCPMessage];
    }
    [self closeConnection];
    
    _status = kOOTCPClientDisconnected;
}

References OODebugTCPConsoleClient::closeConnection, kOOTCPClientDisconnected, OODebugTCPConsoleClient::sendPacket:withValue:forParameter:, and StatusIsSendable().

Here is the call graph for this function:

◆ dispatchPacket:ofType:

- (void) dispatchPacket:		(NSDictionary *)	packet
ofType:		(NSString *)	packetType

Extends class OODebugTCPConsoleClient.

Definition at line 485 of file OODebugTCPConsoleClient.m.

                       :(NSDictionary *)packet ofType:(NSString *)packetType
{
    if (packet == nil || packetType == nil)  return;
    
#define PACKET_CASE(x) else if ([packetType isEqualToString:kOOTCPPacket_##x])  { [self handle##x##Packet:packet]; }
    
    if (0) {}
    PACKET_CASE(ApproveConnection)
    PACKET_CASE(RejectConnection)
    PACKET_CASE(CloseConnection)
    PACKET_CASE(NoteConfigurationChange)
    PACKET_CASE(PerformCommand)
    PACKET_CASE(RequestConfigurationValue)
    PACKET_CASE(Ping)
    PACKET_CASE(Pong)
    else
    {
        OOLog(@"debugTCP.protocolError.unknownPacketType", @"Unhandled packet type %@.", packetType);
    }
}

References nil, OOLog, and PACKET_CASE.

◆ handleApproveConnectionPacket:

- (void) handleApproveConnectionPacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 507 of file OODebugTCPConsoleClient.m.

                                      :(NSDictionary *)packet
{
    NSMutableString         *connectedMessage = nil;
    NSString                *consoleIdentity = nil;
    NSString                *hostName = nil;
    
    if (_status == kOOTCPClientStartedConnectionStage2)
    {
        _status = kOOTCPClientConnected;
        
        // Build "Connected..." message with two optional parts, console identity and host name.
        connectedMessage = [NSMutableString stringWithString:@"Connected to debug console"];
        
        consoleIdentity = [packet oo_stringForKey:kOOTCPConsoleIdentity];
        if (consoleIdentity != nil)  [connectedMessage appendFormat:@" \"%@\"", consoleIdentity];
        
        hostName = [_host name];
        if ([hostName length] != 0 &&
            ![hostName isEqual:@"localhost"] &&
            ![hostName isEqual:@"127.0.0.1"] &&
            ![hostName isEqual:@"::1"])
        {
            [connectedMessage appendFormat:@" at %@", hostName];
        }
        
        OOLog(@"debugTCP.connected", @"%@.", connectedMessage);
    }
    else
    {
        OOLog(@"debugTCP.protocolError.outOfOrder", @"Got %@ packet from debug console in wrong context.", kOOTCPPacket_ApproveConnection);
    }   
}

References kOOTCPClientConnected, kOOTCPClientStartedConnectionStage2, kOOTCPPacket_ApproveConnection, nil, and OOLog.

◆ handleCloseConnectionPacket:

- (void) handleCloseConnectionPacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 560 of file OODebugTCPConsoleClient.m.

                                    :(NSDictionary *)packet
{
    NSString                *message = nil;
    
    if (!StatusIsSendable(_status))
    {
        OOLog(@"debugTCP.protocolError.outOfOrder", @"Got %@ packet from debug console in wrong context.", kOOTCPPacket_CloseConnection);
    }
    message = [packet oo_stringForKey:kOOTCPMessage];
    if (message == nil)  message = @"Console closed connection.";
    [self breakConnectionWithMessage:message];
}

References OODebugTCPConsoleClient::breakConnectionWithMessage:, kOOTCPPacket_CloseConnection, nil, OOLog, and StatusIsSendable().

Here is the call graph for this function:

◆ handleNoteConfigurationChangePacket:

- (void) handleNoteConfigurationChangePacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 574 of file OODebugTCPConsoleClient.m.

                                            :(NSDictionary *)packet
{
    NSDictionary            *configuration = nil;
    NSArray                 *removed = nil;
    NSEnumerator            *keyEnum = nil;
    NSString                *key = nil;
    id                      value = nil;
    
    if (_monitor == nil)  return;
    
    configuration = [packet oo_dictionaryForKey:kOOTCPConfiguration];
    if (configuration != nil)
    {
        for (keyEnum = [configuration keyEnumerator]; (key = [keyEnum nextObject]); )
        {
            value = [configuration objectForKey:key];
            [_monitor setConfigurationValue:value forKey:key];
        }
    }
    
    removed = [configuration oo_arrayForKey:kOOTCPRemovedConfigurationKeys];
    for (keyEnum = [removed objectEnumerator]; (key = [keyEnum nextObject]); )
    {
        [_monitor setConfigurationValue:nil forKey:key];
    }
}

References nil.

◆ handlePerformCommandPacket:

- (void) handlePerformCommandPacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 602 of file OODebugTCPConsoleClient.m.

                                   :(NSDictionary *)packet
{
    NSString                *message = nil;
    
    message = [packet oo_stringForKey:kOOTCPMessage];
    if (message != nil)  [_monitor performJSConsoleCommand:message];
}

References nil.

◆ handlePingPacket:

- (void) handlePingPacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 627 of file OODebugTCPConsoleClient.m.

                         :(NSDictionary *)packet
{
    id                      message = nil;
    
    message = [packet objectForKey:kOOTCPMessage];
    [self sendPacket:kOOTCPPacket_Pong
            withValue:message
         forParameter:kOOTCPMessage];
}

References nil, and OODebugTCPConsoleClient::sendPacket:withValue:forParameter:.

Here is the call graph for this function:

◆ handlePongPacket:

- (void) handlePongPacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 638 of file OODebugTCPConsoleClient.m.

638 :(NSDictionary *)packet

639{

640 // Do nothing; we don't currently send pings.

641}

◆ handleRejectConnectionPacket:

- (void) handleRejectConnectionPacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 541 of file OODebugTCPConsoleClient.m.

                                     :(NSDictionary *)packet
{
    NSString                *message = nil;
    
    if (_status == kOOTCPClientStartedConnectionStage2)
    {
        _status = kOOTCPClientConnectionRefused;
    }
    else
    {
        OOLog(@"debugTCP.protocolError.outOfOrder", @"Got %@ packet from debug console in wrong context.", kOOTCPPacket_RejectConnection);
    }
    
    message = [packet oo_stringForKey:kOOTCPMessage];
    if (message == nil)  message = @"Console refused connection.";
    [self breakConnectionWithMessage:message];
}

References OODebugTCPConsoleClient::breakConnectionWithMessage:, kOOTCPClientConnectionRefused, kOOTCPClientStartedConnectionStage2, kOOTCPPacket_RejectConnection, nil, and OOLog.

Here is the call graph for this function:

◆ handleRequestConfigurationValuePacket:

- (void) handleRequestConfigurationValuePacket: (NSDictionary *) packet

Extends class OODebugTCPConsoleClient.

Definition at line 611 of file OODebugTCPConsoleClient.m.

                                              :(NSDictionary *)packet
{
    NSString                *key = nil;
    id                      value = nil;
    
    key = [packet oo_stringForKey:kOOTCPConfigurationKey];
    if (key != nil)
    {
        value = [_monitor configurationValueForKey:key];
        [self debugMonitor:_monitor
 noteChangedConfigrationValue:value
                    forKey:key];
    }
}

References OODebugTCPConsoleClient::debugMonitor:noteChangedConfigrationValue:forKey:, and nil.

Here is the call graph for this function:

◆ readData

- (void) readData

Extends class OODebugTCPConsoleClient.

Definition at line 467 of file OODebugTCPConsoleClient.m.

{
    enum { kBufferSize = 16 << 10 };
    
    uint8_t                         buffer[kBufferSize];
    NSInteger                       length;
    NSData                          *data;
    
    length = [_inStream read:buffer maxLength:kBufferSize];
    while (length > 0)
    {
        data = [NSData dataWithBytesNoCopy:buffer length:length freeWhenDone:NO];
        OOTCPStreamDecoderReceiveData(_decoder, data);
        length = [_inStream read:buffer maxLength:kBufferSize];
    }
}

References OOTCPStreamDecoderReceiveData(), and readData.

Referenced by readData.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sendBytes:count:

- (BOOL) sendBytes:		(const void *)	bytes
count:		(size_t)	count

Extends class OODebugTCPConsoleClient.

Definition at line 339 of file OODebugTCPConsoleClient.m.

                  :(const void *)bytes count:(size_t)count
{
    if (bytes == NULL || count == 0)  return YES;
    if (!StatusIsSendable(_status) || _outStream == nil)  return NO;
    
    do
    {
        NSInteger written = [_outStream write:bytes maxLength:count];
        if (written < 1)  return NO;
        
        count -= written;
        bytes += written;
    }
    while (count > 0);
    
    return YES;
}

References count, nil, and StatusIsSendable().

Here is the call graph for this function:

◆ sendDictionary:

- (void) sendDictionary: (NSDictionary *) dictionary

Extends class OODebugTCPConsoleClient.

Definition at line 358 of file OODebugTCPConsoleClient.m.

                       :(NSDictionary *)dictionary
{
    NSData                  *data = nil;
    NSString                *errorDesc = NULL;
    size_t                  count;
    const uint8_t           *bytes = NULL;
    uint32_t                header;
    bool                    sentOK = YES;
    
    if (dictionary == nil || !StatusIsSendable(_status))  return;
    
    data = [NSPropertyListSerialization dataFromPropertyList:dictionary
                                                      format:NSPropertyListXMLFormat_v1_0
                                            errorDescription:&errorDesc];
    
    if (data == nil)
    {
        OOLog(@"debugTCP.conversionFailure", @"Could not convert dictionary to data for transmission to debug console: %@", errorDesc != NULL ? errorDesc : (NSString *)@"unknown error.");
#if OOLITE_RELEASE_PLIST_ERROR_STRINGS
        [errorDesc autorelease];
#endif
        return;
    }
    
    LogSendPacket(dictionary);
    
    count = [data length];
    if (count == 0)  return;
    header = htonl(count);
    
    bytes = [data bytes];
    
    /*  In testing, all bad stream errors were caused by the python console
        rejecting headers. Made the protocol a bit more fault tolerant.
        -- Kaks 2012.03.24
    */
    if (![self sendBytes:&header count:sizeof header])
    {
        OOLog(@"debugTCP.send.warning", @"%@", @"Error sending packet header, retrying.");
        // wait 8 milliseconds, resend the header
        [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:.008]];
        if (![self sendBytes:&header count:sizeof header])
        {
            //OOLog(@"debugTCP.send.warning", @"Error sending packet header, retrying one more time.");
            // wait 16 milliseconds, try to resend the header one last time!
            [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:.016]];
            if (![self sendBytes:&header count:sizeof header])
            {
                sentOK = NO;
            }
        }
    }
    
    if(sentOK && ![self sendBytes:bytes count:count])
    {
        OOLog(@"debugTCP.send.warning", @"%@", @"Error sending packet body, retrying.");
        // wait 8 milliseconds, try again.
        [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:.008]];
        if(![self sendBytes:bytes count:count])
        {
            sentOK = NO;
        }
    }
    
    if (!sentOK)
    {
        OOLog(@"debugTCP.send.error", @"The following packet could not be sent: %@", dictionary);
        if(![[OODebugMonitor sharedDebugMonitor] TCPIgnoresDroppedPackets])
        {
            [self breakConnectionWithBadStream:_outStream];
        }
    }
}

References OODebugTCPConsoleClient::breakConnectionWithBadStream:, count, LogSendPacket, nil, OOLog, and StatusIsSendable().

Here is the call graph for this function:

◆ sendPacket:withParameters:

- (void) sendPacket:		(NSString *)	packetType
withParameters:		(NSDictionary *)	parameters

Extends class OODebugTCPConsoleClient.

Definition at line 433 of file OODebugTCPConsoleClient.m.

                   :(NSString *)packetType
     withParameters:(NSDictionary *)parameters
{
    NSDictionary        *dict = nil;
    
    if (packetType == nil)  return;
    
    if (parameters != nil)
    {
        dict = [parameters dictionaryByAddingObject:packetType forKey:kOOTCPPacketType];
    }
    else
    {
        dict = [NSDictionary dictionaryWithObjectsAndKeys:packetType, kOOTCPPacketType, nil];
    }
    
    [self sendDictionary:dict];
}

References nil, and OODebugTCPConsoleClient::sendDictionary:.

Here is the call graph for this function:

◆ sendPacket:withValue:forParameter:

- (void) sendPacket:	(NSString *)	packetType
withValue:	(id)	value
forParameter:	(NSString *)	paramKey

Extends class OODebugTCPConsoleClient.

Definition at line 453 of file OODebugTCPConsoleClient.m.

                   :(NSString *)packetType
          withValue:(id)value
       forParameter:(NSString *)paramKey
{
    if (packetType == nil)  return;
    if (paramKey == nil)  value = nil;
    
    [self sendDictionary:[NSDictionary dictionaryWithObjectsAndKeys:
        packetType, kOOTCPPacketType,
        value, paramKey,
        nil]];
}

References nil, and OODebugTCPConsoleClient::sendDictionary:.

Here is the call graph for this function:

The documentation for this category was generated from the following file:

src/Core/Debug/OODebugTCPConsoleClient.m

Instance Methods

Detailed Description

Method Documentation

◆ breakConnectionWithBadStream:

◆ breakConnectionWithMessage:

◆ closeConnection

◆ disconnectFromServerWithMessage:

◆ dispatchPacket:ofType:

◆ handleApproveConnectionPacket:

◆ handleCloseConnectionPacket:

◆ handleNoteConfigurationChangePacket:

◆ handlePerformCommandPacket:

◆ handlePingPacket:

◆ handlePongPacket:

◆ handleRejectConnectionPacket:

◆ handleRequestConfigurationValuePacket:

◆ readData

◆ sendBytes:count:

◆ sendDictionary:

◆ sendPacket:withParameters:

◆ sendPacket:withValue:forParameter: