iOS ftp上传文件

one:

#import "ViewController.h"

#import "CFNetwork.h"

#import "AssetsLibrary.h"

enum {

    BufferSize = 32768

};

@interface
ViewController ()

{

    uint8_t buffer[BufferSize];

    size_t  bufferOffset;

    size_t  bufferLimit;

}

@property (nonatomic,strong)NSURL *url;

@property (nonatomic,strong)NSString *account;

@property (nonatomic,strong)NSString *password;

@property (nonatomic,retain)NSInputStream  *fileStream;

@property (nonatomic,retain)NSOutputStream *networkStream;

@property (nonatomic,strong)NSString *path;

@end

@implementation ViewController

- (void)viewDidLoad {

    [superviewDidLoad];

    

    self.url = [NSURLURLWithString:@"ftp://113.155.30.171"];

    self.account =@"XXX";

    self.password =@"XXXXX";

    self.path= [[NSBundlemainBundle]
pathForResource:@"testvideo"ofType:@"MOV"];

    NSLog(@"%@",self.path);

    // Do any additional setup after loading the view, typically from a nib.

}

- (void)didReceiveMemoryWarning {

    [superdidReceiveMemoryWarning];

    // Dispose of any resources that can be recreated.

}

- (void)stopSendWithStatus:(NSString *)statusString

{

    if (self.networkStream !=nil) {

        [self.networkStreamremoveFromRunLoop:[NSRunLoopcurrentRunLoop]
forMode:NSDefaultRunLoopMode];

        self.networkStream.delegate =nil;

        [self.networkStreamclose];

        self.networkStream =nil;

    }

    if (self.fileStream !=nil) {

        [self.fileStreamclose];

        self.fileStream =nil;

    }

    

}

- (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)eventCode

// An NSStream delegate callback that's called when events happen on our

// network stream.

{

#pragma unused(aStream)

    assert(aStream ==
self.networkStream);

    

    switch (eventCode) {

        caseNSStreamEventOpenCompleted: {

            NSLog(@"begin");

        } break;

        caseNSStreamEventHasBytesAvailable: {

            assert(NO);    // should never happen for the output stream

        } break;

        caseNSStreamEventHasSpaceAvailable: {

            

            

            // If we don't have any data buffered, go read the next chunk of data.

            

            if (bufferLimit ==bufferOffset) {

                NSInteger   bytesRead;

                

                bytesRead = [self.fileStreamread:buffermaxLength:BufferSize];

                

                if (bytesRead == -1) {

                    [self
stopSendWithStatus:@"File read error"];

                } else
if (bytesRead == 0) {

                    [self
stopSendWithStatus:nil];

                    NSLog(@"finish");

                } else {

                    bufferOffset =
0;

                    bufferLimit  = bytesRead;

                }

            }

            

            // If we're not out of data completely, send the next chunk.

            

            if (bufferOffset !=bufferLimit) {

                NSInteger   bytesWritten;

                bytesWritten = [self.networkStreamwrite:&buffer[bufferOffset]maxLength:bufferLimit
-bufferOffset];

                assert(bytesWritten !=
0);

                if (bytesWritten == -1) {

                    [self
stopSendWithStatus:@"Network write error"];

                } else {

                    bufferOffset += bytesWritten;

                }

            }

        } break;

        caseNSStreamEventErrorOccurred: {

            [selfstopSendWithStatus:@"Stream open error"];

        } break;

        caseNSStreamEventEndEncountered: {

            // ignore

        } break;

        default: {

            assert(NO);

        } break;

    }

    

    

 

}

-(void) stopSendWithStatus

{

    if(self.networkStream !=nil){

        [self.networkStreamremoveFromRunLoop:[NSRunLoopcurrentRunLoop]
forMode:NSDefaultRunLoopMode];

    self.networkStream.delegate =nil;

    [self.networkStreamclose];

    self.networkStream =nil;

    }

    if(self.fileStream !=nil)

    {

        [self.fileStreamclose];

        self.fileStream =nil;

    }

}

#pragma mark 系统视频路径

-(void) getSystem

{

    NSString *path = [[NSSearchPathForDirectoriesInDomains(NSCachesDirectory,NSUserDomainMask,
YES)objectAtIndex:0]stringByAppendingPathComponent:@"VideoURL"];

    NSLog(@"%@",path);

}

-(IBAction)connect:(id)sender

{

    

    BOOL    success;

//    NSURL   *url;

    NSLog(@"path is %@",self.path);

    

    assert(self.path !=nil);

    assert([[NSFileManagerdefaultManager]
fileExistsAtPath:self.path]);

    assert(self.networkStream ==nil);

    assert(self.fileStream ==nil);

    success = (self.url !=nil);

    if (success) {

        self.url =CFBridgingRelease(

                                CFURLCreateCopyAppendingPathComponent(NULL, (__bridgeCFURLRef)
self.url, (__bridgeCFStringRef)
@"/123",true)

                                );

        success = (self.url !=nil);

    }

    

    if(! success)

        NSLog(@"invalid Url");

    else

    {

        self.fileStream = [NSInputStreaminputStreamWithFileAtPath:self.path];

        assert(self.fileStream !=nil);

        [self.fileStreamopen];

        self.networkStream =CFBridgingRelease(

                                               CFWriteStreamCreateWithFTPURL(NULL, (__bridgeCFURLRef)
self.url));

    }

    

    assert(self.networkStream !=nil);

    success =  [self.networkStreamsetProperty:self.accountforKey:(id)kCFStreamPropertyFTPUserName];

    assert(success);

    success =  [self.networkStreamsetProperty:self.passwordforKey:(id)kCFStreamPropertyFTPPassword];

    assert(success);

    

    self.networkStream.delegate =self;

    [self.networkStreamscheduleInRunLoop:[NSRunLoopmainRunLoop]
forMode:NSDefaultRunLoopMode];

    [self.networkStreamopen];

}

-(IBAction)upload:(id)sender

{

    self.url =CFBridgingRelease(CFURLCreateCopyAppendingPathComponent(NULL,
(CFURLRef)self.url, (CFStringRef)[self.pathlastPathComponent],
false));

    NSString *str = [self.urlabsoluteString];

    NSLog(@"STR IS %@",str);

    

    

    SCRFTPRequest *ftpRequest = [[SCRFTPRequestalloc]
initWithURL:[NSURLURLWithString:@"ftp://113.142.30.171"]

                                                     
toUploadFile: self.path];

    

    ftpRequest.username = 
self.account;

    ftpRequest.password = 
self.password;

    

    // Specify a custom upload file name (optional)

    ftpRequest.customUploadFileName = [self.pathlastPathComponent];

    

    // The delegate must implement the SCRFTPRequestDelegate protocol

    ftpRequest.delegate =
self;  

    

    [ftpRequest startRequest];

}

// Required delegate methods

- (void)ftpRequestDidFinish:(SCRFTPRequest *)request {

    

    NSLog(@"Upload finished.");

}

- (void)ftpRequest:(SCRFTPRequest *)request didFailWithError:(NSError *)error {

    

    NSLog(@"Upload failed: %@", [errorlocalizedDescription]);

}

// Optional delegate methods

- (void)ftpRequestWillStart:(SCRFTPRequest *)request {

    

    NSLog(@"Will transfer %d bytes.", request.fileSize);

}

- (void)ftpRequest:(SCRFTPRequest *)request didWriteBytes:(NSUInteger)bytesWritten {

    

    NSLog(@"Transferred: %d", bytesWritten);

}

- (void)ftpRequest:(SCRFTPRequest *)request didChangeStatus:(SCRFTPRequestStatus)status {

    

    switch (status) {

        caseSCRFTPRequestStatusOpenNetworkConnection:

            NSLog(@"Opened connection.");

            break;

        caseSCRFTPRequestStatusReadingFromStream:

            NSLog(@"Reading from stream...");

            break;

        caseSCRFTPRequestStatusWritingToStream:

            NSLog(@"Writing to stream...");

            break;

        caseSCRFTPRequestStatusClosedNetworkConnection:

            NSLog(@"Closed connection.");

            break;

        caseSCRFTPRequestStatusError:

            NSLog(@"Error occurred."); 

            break; 

    } 

}

@end