Large File Transfer using Objective-C ( XCode )
This video shows how to code an Objective-C application to transfer Large file in small chunks.
Mac OS X Version: 10.10.5
Xcode Version: 7.1.1
Enjoy!!!
don’t forget to subscribe on YouTube as more code coming.
Watch above video, configure your project and use below code
GUIHandler.h
//
// GUIHandler.h
// TCPDataTransfer
//
// Created by Rahul Yadav on 30/12/15.
// Copyright © 2015 Rahul Yadav. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <Cocoa/Cocoa.h>
#import "ServerThread.h"
#import "ClientThread.h"
@interface GUIHandler : NSObject{
ServerThread *obj_server_thread;
ClientThread *obj_client_thread;
@public
__weak IBOutlet NSProgressIndicator *b_upload;
}
- (IBAction)StartServerNow:(id)sender;
- (IBAction)StopServerNow:(id)sender;
- (IBAction)ConnectToServerNow:(id)sender;
- (IBAction)DisconnectFromServer:(id)sender;
- (IBAction)SendDataToServer:(id)sender;
@end
GUIHandler.m
//
// GUIHandler.m
// TCPDataTransfer
//
// Created by Rahul Yadav on 30/12/15.
// Copyright © 2015 Rahul Yadav. All rights reserved.
//
#import "GUIHandler.h"
@implementation GUIHandler
- (IBAction)StartServerNow:(id)sender {
obj_server_thread=[[ServerThread alloc]init];
[obj_server_thread initializeServer];
[obj_server_thread start];
}
- (IBAction)StopServerNow:(id)sender {
[obj_server_thread StopServer];
[obj_server_thread cancel];
}
- (IBAction)ConnectToServerNow:(id)sender {
obj_client_thread=[[ClientThread alloc]init];
[obj_client_thread InitializeClient];
obj_client_thread->tx_recv=b_upload;
[obj_client_thread start];
}
- (IBAction)DisconnectFromServer:(id)sender {
[obj_client_thread DisconnectFromServer];
[obj_client_thread cancel];
}
- (IBAction)SendDataToServer:(id)sender {
//[obj_client_thread SendTCPDataPacket:[[tx_send_data stringValue]UTF8String]];
dispatch_async(dispatch_get_main_queue(), ^{
NSOpenPanel *opendlg=[NSOpenPanel openPanel];
[opendlg setCanChooseFiles:TRUE];
[opendlg beginWithCompletionHandler:^(NSInteger result) {
if(result==NSFileHandlingPanelOKButton){
obj_client_thread->rf=[NSFileHandle fileHandleForReadingAtPath:[[opendlg URL] path]];
obj_client_thread->file_length=[obj_client_thread->rf seekToEndOfFile];
NSString *data=[[[opendlg URL] path] lastPathComponent];
[obj_client_thread SendTCPDataPacket:[@"123" UTF8String] data_to_send:[data UTF8String] data_length:[data length]];
}
}];
});
}
@end
ServerThread.h
//
// ServerThread.h
// TCPDataTransfer
//
// Created by Rahul Yadav on 30/12/15.
// Copyright © 2015 Rahul Yadav. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <Cocoa/Cocoa.h>
#include <sys/socket.h>
#include <netinet/in.h>
@interface ServerThread : NSThread
{
CFSocketRef obj_server;
@public
}
-(void)initializeServer;
-(void)main;
-(void)StopServer;
@end
ServerThread.m
//
// ServerThread.m
// TCPDataTransfer
//
// Created by Rahul Yadav on 30/12/15.
// Copyright © 2015 Rahul Yadav. All rights reserved.
//
#import "ServerThread.h"
#import "ClientThread.h"
@implementation ServerThread
-(void)initializeServer{
CFSocketContext sctx={0,(__bridge void *)(self),NULL,NULL,NULL};
obj_server=CFSocketCreate(kCFAllocatorDefault, AF_INET, SOCK_STREAM, IPPROTO_TCP, kCFSocketAcceptCallBack, TCPServerCallBackHandler, &sctx);
int so_reuse_flag=1;
setsockopt(CFSocketGetNative(obj_server), SOL_SOCKET, SO_REUSEADDR, &so_reuse_flag, sizeof(so_reuse_flag));
setsockopt(CFSocketGetNative(obj_server), SOL_SOCKET, SO_REUSEPORT, &so_reuse_flag, sizeof(so_reuse_flag));
struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin_len=sizeof(sock_addr);
sock_addr.sin_family=AF_INET;
sock_addr.sin_port=htons(6658);
sock_addr.sin_addr.s_addr=INADDR_ANY;
CFDataRef dref=CFDataCreate(kCFAllocatorDefault, (UInt8*)&sock_addr, sizeof(sock_addr));
CFSocketSetAddress(obj_server, dref);
CFRelease(dref);
}
-(void)main{
CFRunLoopSourceRef loopref=CFSocketCreateRunLoopSource(kCFAllocatorDefault, obj_server, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), loopref, kCFRunLoopDefaultMode);
CFRelease(loopref);
CFRunLoopRun();
}
-(void)StopServer{
CFSocketInvalidate(obj_server);
CFRelease(obj_server);
CFRunLoopStop(CFRunLoopGetCurrent());
}
void TCPServerCallBackHandler(CFSocketRef s, CFSocketCallBackType callbacktype,CFDataRef address, const void *data,void *info){
switch (callbacktype) {
case kCFSocketAcceptCallBack:
{
ClientThread *obj_accepted_socket=[[ClientThread alloc]init];
[obj_accepted_socket InitializeNative:*(CFSocketNativeHandle*)data];
[obj_accepted_socket start];
}
break;
default:
break;
}
}
@end
ClientThread.h
//
// ClientThread.h
// TCPDataTransfer
//
// Created by Rahul Yadav on 30/12/15.
// Copyright © 2015 Rahul Yadav. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <Cocoa/Cocoa.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
@interface ClientThread : NSThread{
CFSocketRef obj_client;
@public
NSProgressIndicator* tx_recv;
NSFileHandle *rf;
long file_pointer;
long file_length;
}
-(void)InitializeClient;
-(void)InitializeNative:(CFSocketNativeHandle) native_socket;
-(void)main;
-(void)DisconnectFromServer;
-(void)SendTCPDataPacket:(const char *)cmd data_to_send:(const char*) data data_length:(long)target_data_length;
-(char*)ReadData:(int*)recv_data_length;
@end
ClientThread.m
//
// ClientThread.m
// TCPDataTransfer
//
// Created by Rahul Yadav on 30/12/15.
// Copyright © 2015 Rahul Yadav. All rights reserved.
//
#import "ClientThread.h"
@implementation ClientThread
-(void)InitializeClient{
CFSocketContext sctx={0,(__bridge void *)(self),NULL,NULL,NULL};
obj_client=CFSocketCreate(kCFAllocatorDefault, AF_INET, SOCK_STREAM, IPPROTO_TCP, kCFSocketConnectCallBack|kCFSocketReadCallBack, TCPClientCallBackHandler, &sctx);
struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin_len=sizeof(sock_addr);
sock_addr.sin_family=AF_INET;
sock_addr.sin_port=htons(6658);
inet_pton(AF_INET, "127.0.0.1", &sock_addr.sin_addr);
CFDataRef dref=CFDataCreate(kCFAllocatorDefault, (UInt8*)&sock_addr, sizeof(sock_addr));
CFSocketConnectToAddress(obj_client, dref, -1);
CFRelease(dref);
}
-(void)main{
CFRunLoopSourceRef loopref=CFSocketCreateRunLoopSource(kCFAllocatorDefault, obj_client, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), loopref, kCFRunLoopDefaultMode);
CFRelease(loopref);
CFRunLoopRun();
}
-(void)DisconnectFromServer{
CFSocketInvalidate(obj_client);
CFRelease(obj_client);
CFRunLoopStop(CFRunLoopGetCurrent());
}
-(void)SendTCPDataPacket:(const char *)cmd data_to_send:(const char*) data data_length:(long)target_data_length
{
int initialize[1]={2};//initialize
int separator[1]={4};
int target_length=snprintf(NULL, 0, "%ld",target_data_length);
char* data_length_char=malloc(target_length+1);
snprintf(data_length_char, target_length+1, "%ld",target_data_length);// this line of code convert (45 into "45")
int ele_count=(int)strlen(data_length_char);
long packet_length= 1+strlen(cmd)+ele_count+1+target_data_length;
UInt8 *packet=(UInt8*)malloc(packet_length * sizeof(UInt8));
memcpy(&packet[0], initialize, 1);
memcpy(&packet[0+1], cmd, strlen(cmd));
memcpy(&packet[0+1+strlen(cmd)],data_length_char , ele_count);
memcpy(&packet[0+1+strlen(cmd)+ele_count], separator, 1);
memcpy(&packet[0+1+strlen(cmd)+ele_count+1], data, target_data_length);
CFDataRef dref=CFDataCreate(kCFAllocatorDefault, packet, packet_length);
CFSocketSendData(obj_client, NULL, dref, -1);
free(packet);
free(data_length_char);
CFRelease(dref);
}
-(void)InitializeNative:(CFSocketNativeHandle) native_socket{
CFSocketContext sctx={0,(__bridge void *)(self),NULL,NULL,NULL};
obj_client=CFSocketCreateWithNative(kCFAllocatorDefault, native_socket, kCFSocketReadCallBack, TCPClientCallBackHandler, &sctx);
}
-(char*)ReadData:(int*)recv_data_length{
char *data_buff;
NSMutableString *buff_length=[[NSMutableString alloc]init];
char buf[1];
read(CFSocketGetNative(obj_client), &buf, 1 );
while ((int)*buf!=4) {
[buff_length appendFormat:@"%c", (char)(int)*buf];
read(CFSocketGetNative(obj_client), &buf, 1 );
}
int data_length=[[buff_length stringByTrimmingCharactersInSet:[[NSCharacterSet decimalDigitCharacterSet]invertedSet]]intValue];
*recv_data_length=data_length;
data_buff=(char*)malloc(data_length*sizeof(char));
ssize_t byte_read=0;
ssize_t byte_offset=0;
while (byte_offset<data_length) {
byte_read=read(CFSocketGetNative(obj_client), data_buff+byte_offset, 50);
byte_offset+=byte_read;
}
return data_buff;
}
void TCPClientCallBackHandler(CFSocketRef s, CFSocketCallBackType callbacktype,CFDataRef address, const void *data,void *info){
switch (callbacktype) {
case kCFSocketConnectCallBack:
if(data){
CFSocketInvalidate(s);
CFRelease(s);
CFRunLoopStop(CFRunLoopGetCurrent());
}
else{
NSLog(@"Client Connected to Server");
}
break;
case kCFSocketReadCallBack:{
char buf[1];
read(CFSocketGetNative(s), &buf, 1 );
if((int)*buf==2){
ClientThread * obj_client_ptr=(__bridge ClientThread*) info;
char cmd[3];
read(CFSocketGetNative(s), &cmd, 3 );
int iCmd;
int irecv_data_length;
sscanf(cmd, "%d",&iCmd);
char *recv_data=[obj_client_ptr ReadData:&irecv_data_length];
//[obj_client_ptr->tx_recv setStringValue:[NSString stringWithUTF8String:recv_data]];
switch (iCmd) {
case 123://server side
{
NSFileManager *fmng=[NSFileManager defaultManager];
[fmng createFileAtPath:[NSString stringWithFormat:@"/Users/rahulsnippet/Documents/%s",recv_data] contents:nil attributes:nil ];
obj_client_ptr->rf=[NSFileHandle fileHandleForWritingAtPath:[NSString stringWithFormat:@"/Users/rahulsnippet/Documents/%s",recv_data] ];
obj_client_ptr->file_pointer=0;
int target_length=snprintf(NULL, 0, "%ld",obj_client_ptr->file_pointer);
char* data_length_char=malloc(target_length+1);
snprintf(data_length_char, target_length+1, "%ld",obj_client_ptr->file_pointer);
[obj_client_ptr SendTCPDataPacket:[@"124" UTF8String] data_to_send:data_length_char data_length:strlen(data_length_char)];
}
break;
case 124://client side
{
sscanf(recv_data, "%ld",&obj_client_ptr->file_pointer);
if(obj_client_ptr->file_pointer!=obj_client_ptr->file_length){
[obj_client_ptr->rf seekToFileOffset:obj_client_ptr->file_pointer];
long chunck_size=obj_client_ptr->file_length-obj_client_ptr->file_pointer<20000?obj_client_ptr->file_length-obj_client_ptr->file_pointer:20000;
;
[obj_client_ptr SendTCPDataPacket:[@"125" UTF8String] data_to_send:[[obj_client_ptr->rf readDataOfLength:chunck_size] bytes] data_length:chunck_size];
[obj_client_ptr->tx_recv setDoubleValue:((double)obj_client_ptr->file_pointer+chunck_size/(double)obj_client_ptr->file_length)*100];
[obj_client_ptr->tx_recv setNeedsDisplay:YES];
}
else{
[obj_client_ptr SendTCPDataPacket:[@"126" UTF8String] data_to_send:[@"Close" UTF8String] data_length:5];
[obj_client_ptr->rf closeFile];
obj_client_ptr->rf=nil;
}
}break;
case 125:
{
[obj_client_ptr->rf seekToFileOffset:obj_client_ptr->file_pointer];
[obj_client_ptr->rf writeData:[NSData dataWithBytes:recv_data length:irecv_data_length]];
obj_client_ptr->file_pointer=[obj_client_ptr->rf offsetInFile];
int target_length=snprintf(NULL, 0, "%ld",obj_client_ptr->file_pointer);
char* data_length_char=malloc(target_length+1);
snprintf(data_length_char, target_length+1, "%ld",obj_client_ptr->file_pointer);
[obj_client_ptr SendTCPDataPacket:[@"124" UTF8String] data_to_send:data_length_char data_length:strlen(data_length_char)];
free(data_length_char);
}
break;
case 126:
{
[obj_client_ptr->rf closeFile];
obj_client_ptr->rf=nil;
}
break;
default:
break;
}
free(recv_data);
}
}
break;
default:
break;
}
}
@end
![Objective C TCP Socket with NSStream: Client [Cocoa Asynchronous Socket]](http://codevlog.in/wp-content/uploads/2016/06/AsyncSocketClient-520x245.jpg)
