(root)/iphone/tappity : 52 : tappity/source/Tappity.m

@interface Tappity (Private)

- (void) dataReceived: (NSData*) data;

@end

 

- (BOOL) threadActive: (id) key

{

        return [[activeThreads objectForKey: key] boolValue];

}

 

- (void) threadWillExit: (id) key

{

        @synchronized (self)

        {

                [activeThreads removeObjectForKey: key];

                

                if (![activeThreads count])

                {

                        close(commsSocket);

                        commsSocket = -1;

                        

                        

                }

        }

}

 

- (void) receivingThread: (id) info

{

        NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

 

        @synchronized(self)

        {

                [self retain];

        }

 

        while ([self threadActive: info])

        {

                struct timeval tv;

                fd_set readfds;

                fd_set writefds;

                fd_set errorfds;

                int socket = -1;

                int maxSocket = -1;

                

                @synchronized(self)

                {

                        socket = commsSocket;

                }

 

                tv.tv_sec = 1;

                tv.tv_usec = 0;

 

                FD_ZERO(&readfds);

                FD_ZERO(&writefds);

                FD_ZERO(&errorfds);

 

                FD_SET(socket, &readfds);

                FD_SET(socket, &errorfds);

                maxSocket = MAX(maxSocket, socket);

                

                if (maxSocket < 0)

                {

                        //printf("No sockets, sleeping for a bit...\n");

                        usleep(1000000);

                        continue;

                }

 

                if (select(maxSocket+1, &readfds, &writefds, &errorfds, &tv) < 0)

                {

                        perror("select");

                        break;

                }

 

                if (FD_ISSET(socket, &readfds))

                {

                        //NSLog(@"receiving...");

                        if (!expectedMessageSize)

                        {

                                uint32_t header[2] = {0,0};

                                int actuallyRead = 0;

                        

                                actuallyRead = recv(socket, header, 8, MSG_PEEK);

                                

                                if (actuallyRead == 8)

                                {

                                        actuallyRead = recv(socket, header, 8, 0);

                                        expectedMessageSize = ntohl(header[1]);

                                        currentMessageId = ntohl(header[0]);

                                        currentData = [[NSMutableData alloc] initWithLength: expectedMessageSize];

                                }

                                else if (actuallyRead == -1)

                                {

                                        //close(commsSocket);

                                        //self->commsSocket = 0;

                                        if (errno != ETIMEDOUT)

                                        {

                                                printf("Connection dropped with error.\n");

                                                break;

                                        }

                                }

                                else if (actuallyRead == 0)

                                {

                                        printf("remote socket closed.\n");

                                        break;

                                }

                        }

                        else

                        {

                                size_t readAmount = expectedMessageSize - currentlyRead;

                                int actuallyRead = 0;

                        

                                actuallyRead = recv(socket, [currentData mutableBytes] + currentlyRead, readAmount, 0);

                                if (actuallyRead == -1)

                                {

                                        printf("Connection dropped with error.\n");

                                        break;

                                }

                                else if (actuallyRead == 0)

                                {

                                        printf("remote socket closed.\n");

                                        break;

                                }

 

                                currentlyRead += actuallyRead;

                                

                                if (currentlyRead == expectedMessageSize)

                                {

                                        @synchronized(self)

                                        {

                                                expectedMessageSize = 0;

                                                /*

                                                if (!receivedPackets)

                                                        receivedPackets = [[NSMutableArray alloc] init];

                                                [receivedPackets addObject: currentData];

                                                [currentData release];

                                                */

                                                

                                        }

 

                                        if (receiveDataOnMainThread)

                                                [self performSelectorOnMainThread: @selector(dataReceived:) withObject: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: currentMessageId], TapIdKey, currentData, TapDataKey, nil] waitUntilDone: NO];

                                        else

                                                [self dataReceived: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: currentMessageId], TapIdKey, currentData, TapDataKey, nil]];

 

                                        currentData = nil;

                                        currentlyRead = 0;

                                }

                        }

 

                }

        }

        

        [self threadWillExit: info];

 

        @synchronized(self)

        {

                [self release];

        }

 

        [info release];

        [pool drain];

}

 

 

- (void) runThreadWithSelector: (SEL) selector

{

        @synchronized(self)

        {

                if (!activeThreads)

                        activeThreads = [[NSMutableDictionary alloc] init];

                id number = [NSNumber numberWithInt: threadIds++];

 

                [activeThreads setObject: [NSNumber numberWithBool: YES] forKey: number];

                [NSThread detachNewThreadSelector: selector toTarget: self withObject: [number retain]];

        }

}

 

- (void) sendData: (NSData*) tapData withIdentifier: (NSInteger) messageId

{               

        [sendLock lock];

 

        if (!sendQueue)

                sendQueue = [[NSMutableArray alloc] init];

 

        [sendQueue addObject: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInteger: messageId], TapIdKey, tapData, TapDataKey, nil]];

        

        [sendLock signal];

        [sendLock unlock];

                

}

 

 

- (void) sendingThread: (id) info

{

        NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

 

        @synchronized(self)

        {

                [self retain];

        }

 

        while ([self threadActive: info])

        {

                [sendLock lock];

                        while (![sendQueue count])

                                [sendLock wait];

                                

                //NSLog(@"sending");

                

                NSDictionary* dict = [[sendQueue objectAtIndex: 0] retain];

                NSData* data = [dict objectForKey: TapDataKey];

                uint32_t messageId = [[dict objectForKey: TapIdKey] intValue];

                [sendQueue removeObjectAtIndex: 0];

                

                [sendLock unlock];

 

                size_t sizeToSend = 8;

                size_t dataSent = 0;

                uint32_t header[2] = {htonl(messageId), htonl([data length])};

                int err = 0;

                int socket = -1;

 

                @synchronized(self)

                {

                        socket = commsSocket;

                }

 

                while (dataSent < sizeToSend)

                {

                        if ((err = send(socket, header + dataSent, sizeToSend - dataSent, 0)) == -1)

                        {

                                perror("send");

                                break;

                        }

                        else

                                dataSent += err;

                }

                

                if (err != -1)

                {

                        sizeToSend = [data length];

                        dataSent = 0;

                        while (dataSent < sizeToSend)

                        {

                                if ((err = send(socket, [data bytes] + dataSent, sizeToSend - dataSent, 0)) == -1)

                                {

                                        perror("send");

                                        break;

                                }

                                else

                                        dataSent += err;

                                        

                        }

                }

                [dict release];

                

                if (err == -1)

                        break;

                

        }

        

 

        [self threadWillExit: info];

 

        @synchronized(self)

        {

                [self release];

        }

 

        [info release];

        [pool drain];

}