TFUSBController.m

   1 //
   2 //  TFUSBController.m
   3 //  MacTF
   4 //
   5 //  Created by Nathan Oates on Sun Aug 01 2004.
   6 //  Copyright (c) 2004-7 Nathan Oates nathan@noates.com All rights reserved.
   7 //
   8
   9 /* This file was modified by Kalle Olavi Niemitalo on 2007-10-18.  */
  10
  11 // includes code based on uproar, license noted below:
  12 //  uproar 0.1
  13 //  Copyright (c) 2001 Kasima Tharnpipitchai <me@kasima.org>
  14
  15 /*
  16  *
  17  * This source code is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU Public License as published
  19  * by the Free Software Foundation; either version 2 of the License,
  20  * or (at your option) any later version.
  21  *
  22  * This source code is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  25  * Please refer to the GNU Public License for more details.
  26  *
  27  * You should have received a copy of the GNU Public License along with
  28  * this source code; if not, write to:
  29  * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30  */
  31
  32 /* Much of the code that initializes and closes the device is from Apple
  33  * and is released under the license below.
  34  */
  35
  36 /*
  37  * © Copyright 2001 Apple Computer, Inc. All rights reserved.
  38  *
  39  * IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc. (“Apple”) in
  40  * consideration of your agreement to the following terms, and your use, installation,
  41  * modification or redistribution of this Apple software constitutes acceptance of these
  42  * terms.  If you do not agree with these terms, please do not use, install, modify or
  43  * redistribute this Apple software.
  44  *
  45  * In consideration of your agreement to abide by the following terms, and subject to these
  46  * terms, Apple grants you a personal, non exclusive license, under Apple’s copyrights in this
  47  * original Apple software (the “Apple Software”), to use, reproduce, modify and redistribute
  48  * the Apple Software, with or without modifications, in source and/or binary forms; provided
  49  * that if you redistribute the Apple Software in its entirety and without modifications, you
  50  * must retain this notice and the following text and disclaimers in all such redistributions
  51  * of the Apple Software.  Neither the name, trademarks, service marks or logos of Apple
  52  * Computer, Inc. may be used to endorse or promote products derived from the Apple Software
  53  * without specific prior written permission from Apple. Except as expressly stated in this
  54  * notice, no other rights or licenses, express or implied, are granted by Apple herein,
  55  * including but not limited to any patent rights that may be infringed by your derivative
  56  * works or by other works in which the Apple Software may be incorporated.
  57  *
  58  * The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO WARRANTIES,
  59  * EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-
  60  * INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE
  61  * SOFTWARE OR ITS USE AND OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
  62  *
  63  * IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL
  64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  65  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE,
  66  * REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND
  67  * WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR
  68  * OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  69  */
  70
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <unistd.h>
  75
  76 #include <mach/mach.h>
  77 #include <IOKit/IOCFPlugIn.h>
  78 #include <CoreFoundation/CFNumber.h>
  79
  80 #import "DataHandler.h"
  81 #import "TFUSBController.h"
  82 #import "TFUSBControllerCommunicationBlock.h"
  83 #import "UIElements.h"
  84
  85 static void hexDump(UInt8 *buf, int len);
  86 static int doSend(IOUSBDeviceInterface197 **dev,
  87         IOUSBInterfaceInterface197 **intf, UInt8 *outBuf, UInt32 len, int type);
  88 static int doRecv(IOUSBDeviceInterface197 **dev,
  89         IOUSBInterfaceInterface197 **intf, UInt8 *inBuf, UInt32 dataLen, int type);
  90 static int dealWithInterface(io_service_t usbInterfaceRef,
  91         USBDeviceContext *device);
  92 static int dealWithDevice(io_service_t usbDeviceRef, USBDeviceContext *device);
  93 static int initDevice(USBDeviceContext *device);
  94
  95 static int debug;
  96 static int rate;
  97 static int kBlockSize;
  98 static int connectedSpeed;
  99
 100 @interface TFUSBController (PrivateMethods)
 101
 102 // Low-level USB
 103 - (NSData*) sendCommand:(NSData*) fullyPackagedCommand
 104         toDevice:(USBDeviceContext*)device expectResponse:(BOOL) getResponse
 105         careForReturn:(BOOL) careFactor;
 106
 107 // Protocol message sequences
 108 - (id) getFileListForPath:(NSString*)path;
 109 - (void) turnTurboOn:(BOOL) turnOn;
 110 - (void) renameFile:(NSString*) oldName withName:(NSString*)newName atPath:(NSString*)currentPath;
 111 - (void) makeFolder:(NSString*)newName atPath:(NSString*)currentPath;
 112 - (void) checkUSB:(USBDeviceContext*)device;
 113
 114 // User interface
 115 - (UIElements*) uiElements;
 116 - (void) updateProgress:(NSDictionary*) inDict;
 117 - (NSString*) elapsedTime:(NSTimeInterval) totalSeconds;
 118
 119 // Queue management
 120 - (BOOL) hasPriorityTransfer;
 121 - (NSDictionary*) nextTransferAndQueue:(NSMutableArray**)queue;
 122 - (void) removeTransfer:(NSDictionary*)transfer fromQueue:(NSMutableArray*)queue;
 123
 124 @end
 125
 126 #define         TopfieldVendorID        4571
 127    //1317 for HC
 128    //0x138c for humax
 129    //4571 for toppy
 130 #define         TF5kProdID      4096
 131 //42514 for HC
 132 //0x02ad for humax
 133 //4096 for toppy
 134
 135 // ---------------------------------------------------------------------------
 136 // Functions outside TFUSBController
 137 // ---------------------------------------------------------------------------
 138
 139 static void
 140 hexDump(UInt8 *buf, int len)
 141 {
 142         int row, col, maxrows;
 143
 144         maxrows = len/16;
 145         if (len % 16) maxrows++;
 146         for (row=0; row< maxrows; row++) {
 147                 for (col=0; col<16; col++) {
 148                         if (!(col%2)) printf(" ");
 149                         printf("%02x", buf[row*16 + col] & 0xff);
 150                 }
 151                 printf("\t");
 152                 for (col=0; col<16; col++) {
 153                         if ((buf[row*16 + col]>32) && (buf[row*16 + col]<126)) {
 154                                 printf("%c", buf[row*16 + col]);
 155                         }
 156                         else { printf("."); }
 157                 }
 158                 printf("\n");
 159         }
 160 }
 161
 162 static int
 163 doSend(IOUSBDeviceInterface197 **dev, IOUSBInterfaceInterface197 **intf,
 164         UInt8 *outBuf, UInt32 len, int type)
 165 {
 166         IOReturn        err;
 167         UInt32          sendLen;
 168
 169                 if (debug == 1){
 170                         printf(("sending:\n"));
 171             hexDump(outBuf, len);
 172                 }
 173                 sendLen = ((len/kBlockSize))*kBlockSize;
 174         if (len % kBlockSize)
 175             sendLen += kBlockSize;
 176         if ((sendLen % 0x200) == 0)
 177                 sendLen += kBlockSize;
 178
 179         err = (*intf)->WritePipeTO(intf, 1, outBuf, sendLen, 1000, 20000);
 180         if (err) {
 181                 printf("write err: %08x\n", err);
 182                 return err;
 183         }
 184         return err;
 185 }
 186
 187 static int
 188 doRecv(IOUSBDeviceInterface197 **dev, IOUSBInterfaceInterface197 **intf,
 189         UInt8 *inBuf, UInt32 dataLen, int type)
 190 {
 191         IOReturn        err;
 192         UInt32          len;
 193
 194         if (dataLen > kMaxXferSize) return 1;
 195
 196         len = (dataLen/kBlockSize) * kBlockSize;
 197         if (dataLen % kBlockSize)
 198                 len += kBlockSize;
 199
 200                 err = (*intf)->ReadPipeTO(intf, 2, (void *)inBuf, &len,  1000, 20000);
 201                 if (err) {
 202                 printf("read err 2: %08x\n", err);
 203                                 printf("resetting\n");
 204                                 err = (*intf)->ClearPipeStallBothEnds(intf, 2);
 205                         return err;
 206         }
 207
 208         if (debug == 1) {
 209           printf(("receiving: \n"));
 210                         hexDump(inBuf, len);
 211                 }
 212         return err;
 213 }
 214
 215 static int
 216 dealWithInterface(io_service_t usbInterfaceRef, USBDeviceContext *device)
 217 {
 218     IOReturn                            err;
 219     IOCFPlugInInterface                 **iodev;                // requires <IOKit/IOCFPlugIn.h>
 220     IOUSBInterfaceInterface197          **intf;
 221     IOUSBDeviceInterface197             **dev;
 222     SInt32                              score;
 223         UInt8                           numPipes, confNum, dSpeed;
 224
 225
 226     err = IOCreatePlugInInterfaceForService(usbInterfaceRef, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score);
 227     if (err || !iodev)
 228     {
 229         printf("dealWithInterface: unable to create plugin. ret = %08x, iodev = %p\n", err, iodev);
 230         return kUproarDeviceErr;
 231     }
 232     err = (*iodev)->QueryInterface(iodev, CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID), (LPVOID)&(device->intf));
 233     (*iodev)->Release(iodev);                           // done with this
 234     intf = device->intf;
 235     if (err || !intf)
 236     {
 237         printf("dealWithInterface: unable to create a device interface. ret = %08x, intf = %p\n", err, intf);
 238         return kUproarDeviceErr;
 239     }
 240
 241     dev = device->dev;
 242     err = (*intf)->USBInterfaceOpen(intf);
 243     if (err)
 244     {
 245         printf("dealWithInterface: unable to open interface. ret = %08x\n", err);
 246         return kUproarDeviceErr;
 247     }
 248     err = (*intf)->GetNumEndpoints(intf, &numPipes);
 249     if (err)
 250     {
 251         printf("dealWithInterface: unable to get number of endpoints. ret = %08x\n", err);
 252         return kUproarDeviceErr;
 253     }
 254
 255     printf("dealWithInterface: found %d pipes\n", numPipes);
 256
 257     err = (*intf)->GetConfigurationValue(intf, &confNum);
 258     err = (*dev)->GetDeviceSpeed(dev, &dSpeed);
 259         if (dSpeed == 2) {
 260                 kBlockSize = 0x40;
 261         } else {
 262                 kBlockSize = 0x4;
 263         }
 264     printf("confnum: %08x, dspeed: %08x, blockS:%i\n", confNum, dSpeed, kBlockSize);
 265     connectedSpeed = dSpeed;
 266     return kUproarSuccess;
 267 }
 268
 269
 270 static int
 271 dealWithDevice(io_service_t usbDeviceRef, USBDeviceContext *device)
 272 {
 273     IOReturn                            err;
 274     IOCFPlugInInterface                 **iodev;                // requires <IOKit/IOCFPlugIn.h>
 275     IOUSBDeviceInterface197             **dev;
 276     SInt32                              score;
 277     UInt8                               numConf;
 278     IOUSBConfigurationDescriptorPtr     confDesc;
 279     IOUSBFindInterfaceRequest           interfaceRequest;
 280     io_iterator_t                       iterator;
 281     io_service_t                        usbInterfaceRef;
 282     int                                 found=0;
 283
 284
 285     err = IOCreatePlugInInterfaceForService(usbDeviceRef, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &iodev, &score);
 286     if (err || !iodev)
 287     {
 288         printf("dealWithDevice: unable to create plugin. ret = %08x, iodev = %p\n", err, iodev);
 289         return kUproarDeviceErr;
 290     }
 291     err = (*iodev)->QueryInterface(iodev, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID)&(device->dev));
 292     (*iodev)->Release(iodev);
 293
 294     dev = device->dev;
 295     if (err || !dev)
 296     {
 297         printf("dealWithDevice: unable to create a device interface. ret = %08x, dev = %p\n", err, dev);
 298         return kUproarDeviceErr;
 299     }
 300     err = (*dev)->USBDeviceOpen(dev);
 301     if (err)
 302     {
 303         printf("dealWithDevice: unable to open device. ret = %08x\n", err);
 304         return kUproarDeviceErr;
 305     }
 306     err = (*dev)->GetNumberOfConfigurations(dev, &numConf);
 307     if (err || !numConf)
 308     {
 309         printf("dealWithDevice: unable to obtain the number of configurations. ret = %08x\n", err);
 310         return kUproarDeviceErr;
 311     }
 312     printf("dealWithDevice: found %d configurations\n", numConf);
 313     err = (*dev)->GetConfigurationDescriptorPtr(dev, 0, &confDesc);     // get the first config desc (index 0)
 314     if (err)
 315     {
 316         printf("dealWithDevice:unable to get config descriptor for index 0\n");
 317         return kUproarDeviceErr;
 318     }
 319     err = (*dev)->SetConfiguration(dev, confDesc->bConfigurationValue);
 320     if (err)
 321     {
 322         printf("dealWithDevice: unable to set the configuration\n");
 323         return kUproarDeviceErr;
 324     }
 325
 326     interfaceRequest.bInterfaceClass = kIOUSBFindInterfaceDontCare;             // requested class
 327     interfaceRequest.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;          // requested subclass
 328     interfaceRequest.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;          // requested protocol
 329     interfaceRequest.bAlternateSetting = kIOUSBFindInterfaceDontCare;           // requested alt setting
 330
 331     err = (*dev)->CreateInterfaceIterator(dev, &interfaceRequest, &iterator);
 332     if (err)
 333     {
 334         printf("dealWithDevice: unable to create interface iterator\n");
 335         return kUproarDeviceErr;
 336     }
 337
 338     while (usbInterfaceRef = IOIteratorNext(iterator))
 339     {
 340         printf("found interface: %p\n", (void*)usbInterfaceRef);
 341         err = dealWithInterface(usbInterfaceRef, device);
 342         IOObjectRelease(usbInterfaceRef);       // no longer need this reference
 343         found = 1;
 344     }
 345
 346     IOObjectRelease(iterator);
 347     iterator = 0;
 348     if ((!found) || (err))
 349         return kUproarDeviceErr;
 350     else
 351         return kUproarSuccess;
 352 }
 353
 354 static int
 355 initDevice(USBDeviceContext *device)
 356 {
 357     mach_port_t         masterPort = 0;
 358     kern_return_t               err;
 359     CFMutableDictionaryRef      matchingDictionary = 0;         // requires <IOKit/IOKitLib.h>
 360     short                       idVendor = TopfieldVendorID;
 361     short                       idProduct = TF5kProdID;
 362     CFNumberRef                 numberRef;
 363     io_iterator_t               iterator = 0;
 364     io_service_t                usbDeviceRef;
 365     int                         found =0;
 366
 367     err = IOMasterPort(bootstrap_port, &masterPort);
 368
 369     if (err)
 370     {
 371         printf("Anchortest: could not create master port, err = %08x\n", err);
 372         return err;
 373     }
 374     matchingDictionary = IOServiceMatching(kIOUSBDeviceClassName);      // requires <IOKit/usb/IOUSBLib.h>
 375     if (!matchingDictionary)
 376     {
 377         printf("Anchortest: could not create matching dictionary\n");
 378         return -1;
 379     }
 380     numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberShortType, &idVendor);
 381     if (!numberRef)
 382     {
 383         printf("Anchortest: could not create CFNumberRef for vendor\n");
 384         return -1;
 385     }
 386     CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBVendorName), numberRef);
 387     CFRelease(numberRef);
 388     numberRef = 0;
 389     numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberShortType, &idProduct);
 390     if (!numberRef)
 391     {
 392         printf("Anchortest: could not create CFNumberRef for product\n");
 393         return -1;
 394     }
 395     CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBProductName), numberRef);
 396     CFRelease(numberRef);
 397     numberRef = 0;
 398
 399     err = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator);
 400     matchingDictionary = 0;                     // this was consumed by the above call
 401
 402     while (usbDeviceRef = IOIteratorNext(iterator))
 403     {
 404         printf("Found device %p\n", (void*)usbDeviceRef);
 405         err = dealWithDevice(usbDeviceRef, device);
 406         IOObjectRelease(usbDeviceRef);                  // no longer need this reference
 407         found = 1;
 408     }
 409
 410
 411     IOObjectRelease(iterator);
 412     iterator = 0;
 413     mach_port_deallocate(mach_task_self(), masterPort);
 414     if ((!found) || (err))
 415         return kUproarDeviceErr;
 416     else
 417         return kUproarSuccess;
 418 }
 419
 420 // ---------------------------------------------------------------------------
 421 // PrivateMethods: Low-level USB
 422 // ---------------------------------------------------------------------------
 423
 424 @implementation TFUSBController (PrivateMethods)
 425
 426 - (NSData*) sendCommand:(NSData*) fullyPackagedCommand
 427                 toDevice:(USBDeviceContext*)device expectResponse:(BOOL) getResponse
 428                 careForReturn:(BOOL) careFactor{
 429         IOReturn        err;
 430         int cmdLength = [fullyPackagedCommand length];
 431         unsigned char outBuffer[cmdLength];
 432         memset(outBuffer, 0, cmdLength);
 433 //      NSLog(@"send: %@", [fullyPackagedCommand description]);
 434         [fullyPackagedCommand getBytes:outBuffer];
 435
 436         err = doSend(device->dev, device->intf, outBuffer, cmdLength, 2);
 437         if (err)
 438                 NSLog(@"sendError: %08x\n");
 439
 440         if (! getResponse) return nil;
 441
 442         int inLen = 0xFFFF; // i think this is biggest needed?
 443         unsigned char inBuf[inLen];
 444         memset(inBuf, 0, inLen);
 445         err = doRecv(device->dev, device->intf, inBuf, inLen, 2);
 446         if (err)
 447                 NSLog(@"inError: %08x\n", err);
 448
 449         if (! careFactor) return nil;
 450         NSMutableData* data = [NSMutableData dataWithBytes:inBuf length:inLen];
 451         data = [self swap:data];
 452         inLen = inBuf[1]*256 + inBuf[0]; // work out how long the response really is. NB data is flipped, but inBuf still isn't
 453         return [data subdataWithRange:(NSRange) {0,inLen}];
 454 }
 455
 456 // ---------------------------------------------------------------------------
 457 // PrivateMethods: Protocol message sequences
 458 // ---------------------------------------------------------------------------
 459
 460 - (id) getFileListForPath:(NSString*) path {
 461         if (myContext == nil)
 462                 return nil;
 463
 464         NSData* hddListCmd = [self prepareCmdHddDirWithPath:path];
 465         if (hddListCmd == nil)
 466                 return nil;
 467
 468         [self checkUSB:myContext]; // sends cancel and waits for response
 469         int contiguousErrors = 0;
 470         [[dh fileList] removeAllObjects];
 471         NSData* response = [self sendCommand:hddListCmd toDevice:myContext
 472                 expectResponse:YES careForReturn:YES];
 473         while (response != nil && contiguousErrors++ < 5) {
 474                 const UInt32 eCode = [self checkCommunicationBlock:response];
 475                 if (eCode != USB_OK) {
 476                         response = [self sendCommand:[self prepareFailWithECode:eCode]
 477                                 toDevice:myContext expectResponse:YES careForReturn:YES];
 478                 } else switch ([self cmdFromCommunicationBlock:response]) {
 479                 case USB_Fail:
 480 //                      [statusField setStringValue:NSLocalizedString(@"LAST_ERROR", @"Error on last command.")];
 481                         [[dh fileList] removeAllObjects];
 482                         response = [self sendCommand:hddListCmd toDevice:myContext
 483                                 expectResponse:YES careForReturn:YES];
 484                         break;
 485                 case USB_DataHddDir:
 486                         contiguousErrors = 0;
 487                         size_t i;
 488                         // Swapping sometimes adds a byte of padding.  The following uses
 489                         // only complete 144-byte structures and so ignores such padding.
 490                         for (i=0; 8+(i+1)*114 <= [response length]; i++) {
 491                                 NSData* typeFile = [response subdataWithRange:(NSRange) {8+i*114,114}];
 492                                 NSMutableDictionary* tfFile = [dh getTFFileFromSwappedHexData:typeFile];
 493                                 if (![[tfFile objectForKey:@"name"] isEqualToString:@".."]) {
 494                                         [dh convertRawDataToUseful:tfFile];
 495                                         [[dh fileList] addObject:tfFile];
 496                                 }
 497                         }
 498                         response = [self sendCommand:[self prepareSuccess]
 499                                 toDevice:myContext expectResponse:YES careForReturn:YES];
 500                         break;
 501                 case USB_DataHddDirEnd:
 502                         contiguousErrors = 0;
 503                         response = nil;
 504                         break;
 505                 default:
 506                         [self checkUSB:myContext]; // cancel whatever is going on
 507                         [[dh fileList] removeAllObjects];
 508                         response = [self sendCommand:hddListCmd toDevice:myContext
 509                                 expectResponse:YES careForReturn:YES];
 510                         break;
 511                 }
 512         }
 513
 514         [tableView reloadData];
 515         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]];
 516         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]]; //twice so get the same sort as before
 517         return nil;
 518 }
 519
 520 - (void) turnTurboOn:(BOOL) turnOn {
 521         if (![[[self uiElements] isConnected] intValue]) return;
 522         [self checkUSB:myContext];
 523         NSData* turboCommand = [self prepareCmdTurboWithMode:(turnOn ? 1 : 0)];
 524         [self sendCommand:turboCommand toDevice:myContext expectResponse:YES careForReturn:NO];
 525 }
 526
 527 - (void) renameFile:(NSString*) oldName withName:(NSString*)newName atPath:(NSString*)currentPath {
 528         NSLog(@"%@,%@,%@", oldName, newName, currentPath);
 529         [self checkUSB:myContext];
 530         NSString* oldFname = [self fnameForFile:oldName atPath:currentPath];
 531         NSString* newFname = [self fnameForFile:newName atPath:currentPath];
 532         NSData* fileRenCmd = [self prepareCmdHddRenameFromFname:oldFname toFname:newFname];
 533         [self sendCommand:fileRenCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 534 }
 535
 536 - (void) makeFolder:(NSString*)newName atPath:(NSString*)currentPath {
 537         [self checkUSB:myContext];
 538         NSString* fname = [self fnameForFile:newName atPath:currentPath];
 539         NSData* newFoldCmd = [self prepareCmdHddCreateDirWithFname:fname];
 540         NSData* usbCancel = [self prepareCancel];
 541         [self sendCommand:usbCancel toDevice:myContext expectResponse:YES careForReturn:NO];
 542         [self sendCommand:newFoldCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 543 }
 544
 545 - (void) checkUSB:(USBDeviceContext*)device {
 546         NSData* usbCancel = [self prepareCancel];
 547         NSData* data = [self sendCommand:usbCancel toDevice:device expectResponse:YES careForReturn:YES];
 548         const UInt32 rW_bigendian = EndianU32_NtoB(USB_Success);
 549         int i = 0;
 550         NSData* responseWanted = [NSData dataWithBytes:&rW_bigendian length:4];
 551         while ((data == nil || [data length] < 8) && i < 8) {
 552                 NSLog (@"incorrect response");
 553                 i++;
 554                 data = [self sendCommand:usbCancel toDevice:device expectResponse:YES careForReturn:YES];
 555         }
 556         if (!i<=8) {
 557                 // tell someone that no longer connected here??
 558                 return;
 559                 }
 560         NSData* responseToCheck = [data subdataWithRange:(NSRange) {4,4}];
 561         if (![responseWanted isEqualToData:responseToCheck]) {
 562                 [self sendCommand:usbCancel toDevice:device expectResponse:YES careForReturn:NO]; // send reset again
 563         }
 564 }
 565
 566 // ---------------------------------------------------------------------------
 567 // PrivateMethods: User interface
 568 // ---------------------------------------------------------------------------
 569
 570 - (UIElements*) uiElements {
 571         return [NSApp delegate];
 572 }
 573
 574 -(void) updateProgress:(NSDictionary*) inDict {
 575         NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
 576         double offset = [[inDict objectForKey:@"offset"] doubleValue];
 577         double size = [[inDict objectForKey:@"size"] doubleValue];
 578         NSDate* startTime = [inDict objectForKey:@"startTime"];
 579         [progressBar setDoubleValue:((double)offset/size*100)];
 580         [progressBar displayIfNeeded];
 581         [progressTime setStringValue:[self elapsedTime:[[NSDate date] timeIntervalSinceDate:startTime]]];
 582         [progressTime displayIfNeeded];
 583         [pool release];
 584 }
 585
 586 - (NSString*) elapsedTime:(NSTimeInterval) totalSeconds {
 587         char hp = 20;
 588         char mp = 20;
 589         char sp = 20; //padding
 590         int hours = (totalSeconds / 3600);  // returns number of whole hours fitted in totalSecs
 591         if (hours < 10)
 592                 hp = 48;
 593         int minutes = ((totalSeconds / 60) - hours*60);  // Whole minutes
 594         if (minutes < 10)
 595                 mp = 48;
 596         int seconds = ((long) totalSeconds % 60);       // Here we can use modulo to get num secs NOT fitting in whole minutes (60 secs)
 597         if (seconds < 10)
 598                 sp = 48;
 599         return [NSString stringWithFormat:@"%c%i:%c%i:%c%i", hp, hours, mp, minutes, sp, seconds];
 600 }
 601
 602 // ---------------------------------------------------------------------------
 603 // Queues
 604 // ---------------------------------------------------------------------------
 605
 606 - (BOOL) hasPriorityTransfer {
 607         BOOL ret;
 608         @synchronized (self) {
 609                 ret = ([priorityTransferQueue count] > 0);
 610         }
 611         return ret;
 612 }
 613
 614 - (NSDictionary*) nextTransferAndQueue:(NSMutableArray**)queueOut {
 615         NSDictionary* transfer = nil;
 616         NSMutableArray* queue = nil;
 617
 618         @synchronized (self) {
 619                 if ([priorityTransferQueue count] > 0) {
 620                         queue = priorityTransferQueue;
 621                         transfer = [queue objectAtIndex:0];
 622                 } else if ([transferQueue count] > 0) {
 623                         queue = transferQueue;
 624                         transfer = [queue objectAtIndex:0];
 625                 }
 626                 if (transfer != nil)
 627                         [[transfer retain] autorelease];
 628         }
 629
 630         *queueOut = queue;
 631         return transfer;
 632 }
 633
 634 - (void) removeTransfer:(NSDictionary*)transfer
 635         fromQueue:(NSMutableArray*)queue
 636 {
 637         @synchronized (self) {
 638                 [queue removeObjectIdenticalTo:transfer];
 639         }
 640 }
 641
 642 @end
 643
 644 // ---------------------------------------------------------------------------
 645 // Low-level USB
 646 // ---------------------------------------------------------------------------
 647
 648 @implementation TFUSBController
 649
 650 - (void) closeDevice:(USBDeviceContext *)device
 651 {
 652     IOUSBInterfaceInterface197  **intf;
 653     IOUSBDeviceInterface197     **dev;
 654     IOReturn                    err;
 655
 656     intf = device->intf;
 657     dev = device->dev;
 658
 659     err = (*intf)->USBInterfaceClose(intf);
 660     if (err)
 661     {
 662         printf("dealWithInterface: unable to close interface. ret = %08x\n", err);
 663     }
 664     err = (*intf)->Release(intf);
 665     if (err)
 666     {
 667         printf("dealWithInterface: unable to release interface. ret = %08x\n", err);
 668     }
 669
 670     err = (*dev)->USBDeviceClose(dev);
 671     if (err)
 672     {
 673         printf("dealWithDevice: error closing device - %08x\n", err);
 674         (*dev)->Release(dev);
 675     }
 676     err = (*dev)->Release(dev);
 677     if (err)
 678     {
 679         printf("dealWithDevice: error releasing device - %08x\n", err);
 680     }
 681 }
 682
 683 - (USBDeviceContext*) initializeUSB {
 684         USBDeviceContext        *device;
 685         int                     err;
 686         kBlockSize = 0x08;
 687         device = malloc(sizeof(USBDeviceContext));
 688         err = initDevice(device);
 689         if (err) {
 690                 printf("Could not connect to Topfield\n");
 691                 return nil;
 692         }
 693         printf("\n\n");
 694         printf("Connected to Topfield\n\n");
 695         myContext = device;
 696         return device;
 697 }
 698
 699 // ---------------------------------------------------------------------------
 700 // Protocol message sequences
 701 // ---------------------------------------------------------------------------
 702
 703 - (int) getFile:(NSDictionary*)fileInfo forPath:(NSString*)currentPath
 704                 toSaveTo:(NSString*)savePath beginAtOffset:(unsigned long long) offset
 705                 withLooping:(BOOL)looping existingTime:(NSTimeInterval)existingTime {
 706 //      [progressBar setDoubleValue:0];
 707 //      [progressTime setDoubleValue:0];
 708         NSString* nameOnToppy = [fileInfo objectForKey:@"name"];
 709         [[[self uiElements] currentlyField] setStringValue:
 710                 [NSLocalizedString(@"DOWNLOADING", @"Downloading: ") stringByAppendingString:nameOnToppy]];
 711         [[[self uiElements] connectLight] setImage:[NSImage imageNamed:@"blink.tiff"]];
 712         [[[self uiElements] currentlyField] displayIfNeeded];
 713         //construct file send request
 714         NSNumber* fileSize = [fileInfo objectForKey:@"fileSize"];
 715
 716         //prepackage commands to send
 717         NSData* fileSendCmd = [self prepareCmdHddFileSendWithDirection:USB_FileToHost
 718                 fname:[self fnameForFile:nameOnToppy atPath:currentPath]
 719                 offset:offset];
 720         NSData* usbSuccess = [self prepareSuccess];
 721         NSData* usbCancel = [self prepareCancel];
 722
 723         // send commands
 724
 725         if ([turboCB state])
 726                 [self turnTurboOn:YES];
 727         else
 728                 [self checkUSB:myContext]; //turbo has a check itself
 729         [self sendCommand:fileSendCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 730         //start timer
 731         NSDate* startTime = [NSDate date];
 732         startTime = [startTime addTimeInterval:(0-existingTime)];
 733         // send start request and get response
 734         NSData *data = [self sendCommand:usbSuccess toDevice:myContext expectResponse:YES careForReturn:YES];
 735         const UInt32 rW_bigendian = EndianU32_NtoB(USB_DataHddFileData);
 736         NSData *responseWanted = [NSData dataWithBytes:&rW_bigendian length:4];
 737         if ([data length] < 16) {
 738                 NSLog(@"Incorrect Data length");
 739                 return 1;
 740         }
 741         NSData *responseToCheck = [data subdataWithRange:(NSRange) {4,4}];
 742         if (![responseWanted isEqualToData:responseToCheck]) {
 743                 NSLog(@"Unexpected response from Toppy during download");
 744                 return 1;
 745         }
 746
 747         // clean up data and prepare path to save it
 748         NSData* header = [data subdataWithRange:(NSRange) {4,4}]; //cmd data
 749         NSData* finalData = [data subdataWithRange:(NSRange) {16,[data length]-16}];
 750
 751         // first initialize a file of the right name, as NSFileHandle requires an existing file to work on
 752         if (offset == 0)
 753                 [[NSData dataWithBytes:"\0" length:1] writeToFile:savePath atomically:NO]; // write 0x00 to initialize (overwritten later)
 754         NSFileHandle* outFile = [NSFileHandle fileHandleForWritingAtPath:savePath];
 755         [outFile seekToFileOffset:offset];
 756         [outFile writeData:finalData];
 757         if (looping) {  // loop for multiple data sends (ie files > 64k)
 758                 int updateRate = 8;
 759                 if ([fileSize isGreaterThan:[NSNumber numberWithDouble:1048576]]) {
 760                         updateRate = 24;
 761                         NSLog(@"large file detected - low GUI update rate");
 762                 }
 763                 int timesAround = 0;
 764                 const UInt32 test_bigendian = EndianU32_NtoB(USB_DataHddFileData);
 765                 double amountReceived = 0xfe00 + offset;
 766                 NSData* testData = [NSData dataWithBytes:&test_bigendian length:4];
 767                 while ([header isEqualToData:testData] && [[[self uiElements] isConnected] intValue]) {
 768                         if ([self hasPriorityTransfer]) {
 769                                 [self addTransfer:[NSDictionary dictionaryWithObjectsAndKeys:
 770                                                 fileInfo,@"filename", currentPath,@"path", savePath,@"savePath",
 771                                                 [NSNumber numberWithUnsignedLongLong:amountReceived],@"offset",
 772                                                 @"download",@"transferType", [NSNumber numberWithBool:YES],@"looping",
 773                                                 [NSNumber numberWithInt:[[NSDate date] timeIntervalSinceDate:startTime]],@"existingTime",
 774                                                 nil]
 775                                         atIndex:1]; // nb adding to index 1 as the current transfer lies at 0 and will be deleted soon
 776                                 // send reset again     just to make sure!
 777                                 [self sendCommand:usbCancel toDevice:myContext expectResponse:YES careForReturn:NO];
 778                                 [outFile closeFile];
 779                                 //now add the right modification date to the file
 780                                 [[NSFileManager defaultManager]
 781                                         changeFileAttributes:[NSDictionary
 782                                                 dictionaryWithObject:[fileInfo objectForKey:@"date"]
 783                                                 forKey:@"NSFileModificationDate"]
 784                                         atPath:savePath];
 785                                 [self turnTurboOn:NO];
 786                                 return 0;
 787                         }
 788                         timesAround ++;
 789                         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 790                         data = [self sendCommand:usbSuccess toDevice:myContext expectResponse:YES careForReturn:YES];
 791                         amountReceived += 0xfe00;
 792                         if (timesAround < 8 || timesAround % updateRate == 0) {
 793                                 [NSThread detachNewThreadSelector:@selector(updateProgress:) toTarget:self
 794                                         withObject:[NSDictionary dictionaryWithObjectsAndKeys:
 795                                                 [NSNumber numberWithDouble:(double)amountReceived], @"offset",
 796                                                 fileSize, @"size", startTime, @"startTime", nil]];
 797                         }
 798                         if ([data length] > 16){ //there is something to read
 799                                 header = [[data subdataWithRange:(NSRange) {4,4}] retain]; //cmd data
 800                                 NSData* finalData = [data subdataWithRange:(NSRange) {16,[data length]-16}];
 801                                 [outFile writeData:finalData];
 802                                 [outFile synchronizeFile];
 803                         }
 804                         else break;
 805                         [pool release];
 806                 }
 807         }
 808         [self sendCommand:usbCancel toDevice:myContext expectResponse:YES careForReturn:NO]; // send reset again        just to make sure!
 809         [outFile closeFile];
 810     //now add the right modification date to the file
 811         [[NSFileManager defaultManager]
 812                 changeFileAttributes:[NSDictionary
 813                         dictionaryWithObject:[fileInfo objectForKey:@"date"]
 814                         forKey:@"NSFileModificationDate"]
 815                 atPath:savePath];
 816         [self turnTurboOn:NO];
 817         if (looping) [[self uiElements] finishTransfer];
 818         return 0;
 819 }
 820
 821 - (void) uploadFile:(NSString*) fileToUpload ofSize:(long long) size
 822                 fromPath:(NSString*)curPath withAttributes:(NSData*) typeFile
 823                 atOffset:(unsigned long long)offset existingTime:(NSTimeInterval)existingTime {
 824         NSLog(@"upload: %@,%@,%qu", fileToUpload, curPath, offset);
 825         USBDeviceContext* dev = myContext;
 826         // prepare Send command
 827         NSMutableArray* array = [NSMutableArray arrayWithArray:[fileToUpload componentsSeparatedByString:@"/"]];
 828         NSMutableString* fname = [NSMutableString stringWithString:[array lastObject]];
 829         char dir = USB_FileToDevice;
 830         NSMutableData* build = [NSMutableData dataWithBytes:&dir length:1];
 831         short int nsize = [fname length]+[curPath length]+2;// one for slash, one for padding 0x00
 832         const UInt16 nsize_bigendian = EndianU16_NtoB(nsize);
 833         [build appendData:[NSData dataWithBytes:&nsize_bigendian length:2]];
 834         NSData* d = [curPath dataUsingEncoding:NSISOLatin1StringEncoding];
 835         [build appendData:d];
 836         dir = 0x5c; // 0x5c = "/"
 837         [build appendData:[NSData dataWithBytes:&dir length:1]];
 838         [build appendData:[fname dataUsingEncoding:NSISOLatin1StringEncoding]];// may need to pad to 95...
 839         if ([fname length] < 95)
 840                 [build increaseLengthBy:95-[fname length]];
 841         dir = 0x00;
 842         [build appendData:[NSData dataWithBytes:&dir length:1]];
 843         UInt64 offset_bigendian = EndianU64_NtoB(offset);
 844         [build appendData:[NSData dataWithBytes:&offset_bigendian length:8]];
 845
 846         // prepackage commands to send
 847         NSData* fileSendCmd = [self prepareCommand:USB_CmdHddFileSend withData:build];
 848         NSData* fileStartCmd = [self prepareCommand:USB_DataHddFileStart withData:typeFile];
 849         NSData* fileEndCmd = [self prepareDataHddFileEnd];
 850
 851         //start timer
 852         NSDate* startTime = [NSDate date];
 853         startTime = [startTime addTimeInterval:(0-existingTime)];
 854         //send commands
 855         if ([turboCB state])
 856                 [self turnTurboOn:YES];
 857         else
 858                 [self checkUSB:dev];
 859         // now the proper commands
 860         NSData *data = [self sendCommand:fileSendCmd toDevice:dev expectResponse:YES careForReturn:YES];
 861         data = [self sendCommand:fileStartCmd toDevice:dev expectResponse:YES careForReturn:YES];
 862         const UInt32 rW_bigendian = EndianU32_NtoB(USB_Success);
 863         NSData* responseWanted = [NSData dataWithBytes:&rW_bigendian length:4];
 864         NSData* responseToCheck = nil;
 865
 866         NSFileHandle* fileHandle = [NSFileHandle fileHandleForReadingAtPath:fileToUpload];
 867         [fileHandle seekToFileOffset:offset];
 868         do {
 869                 if ([self hasPriorityTransfer]) {
 870                         //break out and create a new transfer to continue it
 871                         NSLog(@"pausing upload");
 872                         [self addTransfer:[NSDictionary dictionaryWithObjectsAndKeys:
 873                                         fileToUpload,@"filename",
 874                                         [NSNumber numberWithUnsignedLongLong:size],@"fileSize",
 875                                         curPath,@"path",typeFile,@"attributes",@"upload",@"transferType",
 876                                         [NSNumber numberWithUnsignedLongLong:offset],@"offset",
 877                                         [NSNumber numberWithInt:[[NSDate date] timeIntervalSinceDate:startTime]],@"existingTime",
 878                                         nil]
 879                                 atIndex:1]; //nb use index 1 as current transfer is at 0 and will be deleted
 880                         [self turnTurboOn:NO];
 881                         break;
 882                 } else {
 883                 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 884                 offset_bigendian = EndianU64_NtoB(offset);
 885                 NSMutableData* fileData = [NSMutableData dataWithBytes:&offset_bigendian length:8];
 886                 [fileData appendData:[fileHandle readDataOfLength:rate]];
 887                 offset += rate;
 888                 NSData* fileDataCmd = [self prepareCommand:USB_DataHddFileData withData:fileData];
 889                 data = [self sendCommand:fileDataCmd toDevice:dev expectResponse:YES careForReturn:YES];
 890                 if ([data length] >= 8)
 891                         responseToCheck = [data subdataWithRange:(NSRange) {4,4}];
 892                 else responseToCheck = nil;
 893                 if (responseToCheck == nil || ![responseWanted isEqualToData:responseToCheck])
 894                         break;
 895                 [NSThread detachNewThreadSelector:@selector(updateProgress:) toTarget:self
 896                         withObject:[NSDictionary dictionaryWithObjectsAndKeys:
 897                                 [NSNumber numberWithDouble:(double)offset], @"offset",
 898                                 [NSNumber numberWithDouble:(double)size], @"size",
 899                                 startTime, @"startTime", nil]];
 900                 [pool release];
 901                 }
 902         } while (offset < size && [[[self uiElements] isConnected] intValue]);
 903         if ([[[self uiElements] isConnected] intValue])
 904                 data = [self sendCommand:fileEndCmd toDevice:dev expectResponse:YES careForReturn:YES];
 905         [fileHandle closeFile];
 906         [[self uiElements] goToPath:[[self uiElements]currentPath]];
 907         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]];
 908         [[self uiElements] tableView:tableView didClickTableColumn:[[self uiElements]selectedColumn]]; //twice so get the same sort as before
 909         [self turnTurboOn:NO];
 910         [[self uiElements] finishTransfer];
 911 }
 912
 913 - (void) deleteFile:(NSDictionary*)fileInfo fromPath:(NSString*)currentPath {
 914         [self checkUSB:myContext];
 915         NSString* fname = [self fnameForFile:[fileInfo objectForKey:@"name"]
 916                 atPath:currentPath];
 917         NSData* fileDelCmd = [self prepareCmdHddDelWithFname:fname];
 918         [self sendCommand:fileDelCmd toDevice:myContext expectResponse:YES careForReturn:NO];
 919 }
 920
 921 // ---------------------------------------------------------------------------
 922 // Queue management
 923 // ---------------------------------------------------------------------------
 924
 925 - (void) addPriorityTransfer:(id)newTransfer {
 926         @synchronized (self) {
 927                 [priorityTransferQueue addObject:newTransfer];
 928                 NSLog(@"%i,p:%i-%@",[transferQueue count],[priorityTransferQueue count],[newTransfer objectForKey:@"transferType"]);
 929         }
 930 }
 931
 932 - (void) addTransfer:(id)newTransfer atIndex:(int)front { //-1 for at end
 933         @synchronized (self) {
 934                 if (front>=0) [transferQueue insertObject:newTransfer atIndex:front];
 935                 else [transferQueue addObject:newTransfer];
 936                 NSLog(@"%i,p:%i",[transferQueue count],[priorityTransferQueue count]);
 937         }
 938 }
 939
 940 - (void) clearQueues {
 941         @synchronized (self) {
 942                 [priorityTransferQueue removeAllObjects];
 943                 [transferQueue removeAllObjects];
 944                 [pausedQueue removeAllObjects];
 945         }
 946 }
 947
 948 - (BOOL) hasCurrentTransfer {
 949         BOOL ret;
 950         @synchronized (self) {
 951                 ret = ([transferQueue count] > 0);
 952         }
 953         return ret;
 954 }
 955
 956 - (id) currentTransferInfo {
 957         id transfer = nil;
 958         @synchronized (self) {
 959                 if ([transferQueue count] > 0) {
 960                         transfer = [transferQueue objectAtIndex:0];
 961                         // Make a copy of the object so that it can be safely manipulated
 962                         // in a different thread from the original.
 963                         transfer = [[transfer copy] autorelease];
 964                 }
 965         }
 966         return transfer;
 967 }
 968
 969 - (id) firstPausedTransferInfo {
 970         id transfer = nil;
 971         @synchronized (self) {
 972                 if ([pausedQueue count] > 0) {
 973                         transfer = [pausedQueue objectAtIndex:0];
 974                         // Make a copy of the object so that it can be safely manipulated
 975                         // in a different thread from the original.
 976                         transfer = [[transfer copy] autorelease];
 977                 }
 978         }
 979         return transfer;
 980 }
 981
 982 - (void) transfer:(id)sender {
 983         while ([[[self uiElements] isConnected] intValue]) {
 984                 NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
 985                 NSMutableArray* queue = nil;
 986                 NSDictionary* currentTransfer = [self nextTransferAndQueue:&queue];
 987                 if (currentTransfer != nil) {
 988                         NSString* transferType = [currentTransfer objectForKey:@"transferType"];
 989                         if ([transferType isEqualToString:@"fileList"]) {
 990                                 [self getFileListForPath:[currentTransfer objectForKey:@"path"]];
 991                         }
 992                         else if ([transferType isEqualToString:@"turbo"]) {
 993                 //              [self turnTurboOn:[[currentTransfer objectForKey:@"turboOn"] boolValue]];
 994                         }
 995                         else if ([transferType isEqualToString:@"rename"]) {
 996                                 [self renameFile:[currentTransfer objectForKey:@"oldName"]
 997                                         withName:[currentTransfer objectForKey:@"newName"]
 998                                         atPath:[currentTransfer objectForKey:@"path"]];
 999                         }
1000                         else if ([transferType isEqualToString:@"newFolder"]) {
1001                                 [self makeFolder:[currentTransfer objectForKey:@"newName"] atPath:[currentTransfer objectForKey:@"path"]];
1002                         }
1003                         else if ([transferType isEqualToString:@"delete"]) {
1004                                 [self deleteFile:[currentTransfer objectForKey:@"file"] fromPath:[currentTransfer objectForKey:@"path"]];
1005                         }
1006                         else if ([transferType isEqualToString:@"pause"]) {
1007                                 @synchronized (self) {
1008                                         if ([transferQueue count] != 0) {
1009                                                 NSArray* toPause = [transferQueue filteredArrayUsingPredicate:
1010                                                         [NSPredicate predicateWithFormat:@"(filename = %@)",
1011                                                                 [currentTransfer objectForKey:@"filename"]]];
1012                                                 if ([toPause count] > 1) NSLog(@"multiple pauses?");
1013                                                 else {
1014                                                         [pausedQueue addObjectsFromArray:toPause];
1015                                                         [transferQueue removeObjectsInArray:toPause];
1016                                                 }
1017                                         }
1018                                 }
1019                         }
1020                         else if ([transferType isEqualToString:@"resume"]) {
1021                                 @synchronized (self) {
1022                                         if ([pausedQueue count] != 0) {
1023                                                 NSArray* toResume = [pausedQueue filteredArrayUsingPredicate:
1024                                                         [NSPredicate predicateWithFormat:@"(filename = %@)",
1025                                                                 [currentTransfer objectForKey:@"filename"]]];
1026                                                 if ([toResume count] > 1) NSLog(@"multiple resumes?");
1027                                                 else {
1028                                                         [transferQueue addObjectsFromArray:toResume];
1029                                                         [pausedQueue removeObjectsInArray:toResume];
1030                                                 }
1031                                         }
1032                                 }
1033                         }
1034                         else if ([transferType isEqualToString:@"download"]) {
1035                                 [self getFile:[currentTransfer objectForKey:@"filename"]
1036                                         forPath:[currentTransfer objectForKey:@"path"]
1037                                         toSaveTo:[currentTransfer objectForKey:@"savePath"]
1038                                         beginAtOffset:[[currentTransfer objectForKey:@"offset"] unsignedLongLongValue]
1039                                         withLooping:[[currentTransfer objectForKey:@"looping"] boolValue]
1040                                         existingTime:[[currentTransfer objectForKey:@"existingTime"] intValue]];
1041                         }
1042                         else if ([transferType isEqualToString:@"upload"]) {
1043                                 [self uploadFile:[currentTransfer objectForKey:@"filename"]
1044                                         ofSize:[[currentTransfer objectForKey:@"fileSize"] unsignedLongLongValue]
1045                                         fromPath:[currentTransfer objectForKey:@"path"]
1046                                         withAttributes:[currentTransfer objectForKey:@"attributes"]
1047                                         atOffset:[[currentTransfer objectForKey:@"offset"] unsignedLongLongValue]
1048                                         existingTime:[[currentTransfer objectForKey:@"existingTime"] intValue]];
1049                         }
1050                         else {
1051                                 NSLog(@"Unrecognized transfer type: %@", transferType);
1052                         }
1053                         [self removeTransfer:currentTransfer fromQueue:queue];
1054                 }
1055                 else usleep(100);
1056                 [pool release];
1057         }
1058 }
1059
1060 // ---------------------------------------------------------------------------
1061 // User interface
1062 // ---------------------------------------------------------------------------
1063
1064 -(void) setProgressBar:(NSProgressIndicator*)bar time:(NSTextField*)timeField turbo:(NSButton*)turbo{
1065         progressBar = bar;
1066         progressTime = timeField;
1067         turboCB = turbo;
1068 }
1069
1070 - (void) setDH:(id)newDH tableView:(id)tv {
1071         dh = newDH;
1072         tableView = tv;
1073 }
1074
1075 // ---------------------------------------------------------------------------
1076 // Miscellaneous
1077 // ---------------------------------------------------------------------------
1078
1079 -(id) init {
1080         if (self = [super init]) {
1081                 debug = 0;
1082                 rate = 0xfe00;
1083                 transferQueue = [[NSMutableArray arrayWithCapacity:1] retain];
1084                 pausedQueue = [[NSMutableArray arrayWithCapacity:1] retain];
1085                 priorityTransferQueue = [[NSMutableArray arrayWithCapacity:1] retain];
1086         }
1087         return self;
1088 }
1089
1090 - (int) getSpeed {
1091         return connectedSpeed;
1092 }
1093
1094 -(void) setDebug:(int)mode {
1095         debug = mode;
1096         NSLog(@"Debug level: %i", debug);
1097 }
1098
1099 -(void) setRate:(int) newRate {
1100         rate = newRate;
1101         NSLog(@"New rate set: %i", rate);
1102 }
1103
1104 @end