Is it possible to run client server communication using tcp/ip protocol in two systems?

int receive_audio(long long int socket)
{

	long int buffersize = 0, recv_size = 0, size = 0, read_size, write_size;

	char verify = '1';

	FILE *audio;

	//Find the size of the audio
	recv(socket, (char *)&size, sizeof(int), 0);

	//Send our verification signal
	send(socket, &verify, sizeof(char), 0);

	//Make sure that the size is bigger than 0
	if (size <= 0)
	{
		printf("Error has occurred. Size less than or equal to 0 \n");
		return -1;
	}

	audio = fopen("/home/sosdt009/Desktop/received.mp3", "w");

	if (audio == NULL)
	{
		printf("Error has occurred. audio file could not be opened \n");
		return -1;
	}

	//Loop while we have not received the entire file yet

	while (recv_size < size)
	{
		ioctl(socket, FIONREAD, &buffersize);

		//We check to see if there is data to be read from the socket 
		if (buffersize > 0)
		{
			char *pBuf = malloc(buffersize);
			if (!pBuf)
			{
				fprintf(stderr, "Memory Error. Cannot allocate!\n");
				exit(-1);
			}

			read_size = recv(socket, pBuf, buffersize, 0);
			if (read_size  < 0)
			{
				printf("%s", strerror(errno));
			}

			//Write the currently read data into our audio file
			write_size = fwrite(pBuf, 1, buffersize, audio);

			free(pBuf);

			//Increment the total number of bytes read
			recv_size += read_size;
		}
	}

	fclose(audio);
	printf("audio successfully Received! \n");
	return 1;
}

int send_audio(long long int socket)
{

	FILE *audio;
	long int size, read_size, stat, packet_index;
	char send_buffer[512], read_buffer[512];
	packet_index = 1;

	audio = fopen("/home/sosdt009/Desktop/ROBO.mp3", "r");

	if (audio == NULL)
	{
		printf("Error Opening audio File");
		exit(-1);
	}

	printf("Getting audio Size\n");

	fseek(audio, 0, SEEK_END);
	size = ftell(audio);
	fseek(audio, 0, SEEK_SET);
	printf("Total audio size: %li \n", size);

	//Send audio Size
	printf("Sending audio Size\n");
	send(socket, (void *)&size, sizeof(size), 0);

	printf("Sending audio as Byte Array\n");

	do
	{
		//Read while we get errors that are due to signals.
		stat = recv(socket, read_buffer, 255, 0);
		printf("Bytes read: %li \n", stat);

	} while (stat < 0);

	printf("Received data in socket\n");
	printf("Socket data: %s\n", read_buffer);

	while (!feof(audio))
	{

		//Read from the file into our send buffer
		read_size = fread(send_buffer, 1, sizeof(send_buffer), audio);

		//Send data through our socket 
		do
		{
			stat = send(socket, send_buffer, read_size, 0);
		} while (stat < 0);

		printf("Packet %li, sent %li bytes.\n", packet_index, read_size);

		packet_index++;
	}

	return 0;
}

//File preamble.h

typedef struct
{
	long long llSize;
	char FileName[500];
	char Reserved[8];
} FILEDATA;

	#ifdef __linux__
	#define _FILE_OFFSET_BITS 64
	#else
	#include <winsock2.h>
	#endif

	#include <stdio.h>
	#include <stdlib.h>
	#include <errno.h>
	#ifdef __linux__
	#include <unistd.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/ioctl.h>
	#include <netinet/in.h>
	#include <arpa/inet.h>
	#define WINBIN
	#else
	#define WINBIN "b"
	#define close closesocket
	#define ftell _ftell64
	#define ioctl ioctlsocket
	typedef int socklen_t;
	#endif
	#include "preamble.h"

char *file[] = { "mp3.mp3"  ,
				 "image.jpg",
				 "film.mkv"
				};
 #ifdef __linux__
 char Path[] = "/media/sf_UnixShares/";
 #else
 char Path[] = "C:\\Users\\UnixShares\\";
 #endif

int SendFile(int socket, char *FileName)
{
	FILEDATA fd;
	FILE *fp;
	long int read_size, stat, packet_index;
	long long int size=0;
	char send_buffer[512];
	char read_buffer[512];
	char LocFname[1024];
	packet_index = 1;

	memset(&fd, 0, sizeof(fd));
	strcpy(LocFname, Path);
	strcat(LocFname, FileName);
	fp = fopen(LocFname, "r" WINBIN);
	
	if (fp == NULL)
	{
		printf("Error Opening File \"%s\"\n", FileName);
		exit(-1);
	}

	printf("Getting file Size\n");

	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	fseek(fp, 0, SEEK_SET);
	fd.llSize = size;
	printf("Total file size: %lli \n", size);

	//Send file preamble
	strcpy(fd.FileName, FileName);
	printf("Sending file preamble\n");
	send(socket, (void *)&fd, sizeof(fd), 0);

	//Wait for client acknowledge
	do
	{
		//Read while we get errors that are due to signals.
		stat = recv(socket, read_buffer, 255, 0);
		printf("Bytes read: %li \n", stat);
	} while (stat < 0);
	printf("Received preamble acknowledge <%5s>\n", read_buffer);
	if (strncmp("OK", read_buffer, 5))
	{
		printf ("Transfer aborted!\n");
		return 0;
	}

	printf("Press Enter to send file: ...");
	getchar();
	printf("\rSending file\n");

	while (!feof(fp))
	{
		//Read from the file into our send buffer
		read_size = fread(send_buffer, 1, sizeof(send_buffer), fp);

		//Send data through our socket 
		do
		{
			stat = send(socket, send_buffer, read_size, 0);
		} while (stat < 0);

		printf("\rPacket %li, sent %li bytes.", packet_index, read_size);

		packet_index++;

		//Zero out our send buffer
		memset(send_buffer, 0, sizeof(send_buffer));
	}
	
	printf("\nFile sent!\n");

	return 1;
}

int main(int argc, char *argv[])
{
	long long int socket_desc, new_socket, c;
	struct sockaddr_in server, client;

 #if defined(__WIN32__) || defined(_WIN32)
    //----------------------
    // Declare and initialize variables.
    int iResult;
    WSADATA wsaData;

    //----------------------
    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != NO_ERROR)
	{
        printf("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }
 #endif

	//Create socket
	socket_desc = socket(AF_INET, SOCK_STREAM, 0);
	if (socket_desc == -1)
	{
		printf("Could not create socket");
	}

	//Prepare the sockaddr_in structure
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
	server.sin_port = htons(6888);

	//Bind

	if (bind(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0)
	{
		puts("bind failed");
		return 1;
	}

	puts("Bind completed");

	//Listen
	listen(socket_desc, 3);

	//Accept and incoming connection
	puts("Waiting for incoming connections...");
	c = sizeof(struct sockaddr_in);

	new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t *) & c);

	fflush(stdout);

	if (new_socket < 0)
	{
		perror("Accept Failed");
		return 1;
	}
	else
		puts("Connection accepted");

	for (int i=0; i<3; i++)
		if (!SendFile(new_socket, file[i]))
		{
			printf ("Client required tx abort!\n");
			break;
		}
		
	//Tell client that transfer is finished sending a file len=0
	FILEDATA fd = {0};
	send(new_socket, (void *)&fd, sizeof(fd), 0);

	close(new_socket);
	close(socket_desc);
	fflush(stdout);
	return 0;
}

	#ifdef __linux__
	#define _FILE_OFFSET_BITS 64
	#else
	#include <winsock2.h>
	#endif

	#include <stdio.h>
	#include <stdlib.h>
	#include <errno.h>
	#ifdef __linux__
	#include <unistd.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/ioctl.h>
	#include <netinet/in.h>
	#include <arpa/inet.h>
	#define WINBIN
	#else
	#define WINBIN "b"
	#define close closesocket
	#define ftell _ftell64
	#define ioctl ioctlsocket
	typedef int socklen_t;
	#endif
	#include "preamble.h"

/*
 * This function is to be used once we have confirmed that an fp
 * is to be sent.
 * It should read and output a file.
 */
int ReceiveFile(int socket)
{

	long int buffersize = 0;
	long int read_size;
	long long int recv_size = 0;

	FILE *fp;
	FILEDATA fd;

	//Find the size of the fp
	recv(socket, (void *)&fd, sizeof(fd), 0);

	//Make sure that the size is bigger than 0
	if (fd.llSize <= 0)
	{
		printf("End of transfer or error (len=0)\n");
		return 0;
	}

	fp = fopen(fd.FileName, "w" WINBIN);

	if (fp == NULL)
	{
		printf("Error! Cannot create file \"%s\".\n", fd.FileName);
		//Send failure to server
		send(socket, "ABORT", 6, 0);
		return 0;
	}

	printf ("Receiving %lld bytes for file \"%s\".\n", fd.llSize, fd.FileName);
	
	//Send our verification signal
	send(socket, "OK", 3, 0);

	//Loop while we have not received the entire file yet

	while (recv_size < fd.llSize)
	{
		ioctl(socket, FIONREAD, (unsigned long int *)&buffersize);

		//We check to see if there is data to be read from the socket 
		if (buffersize <= 0)
			continue;

		//The protocol put all data together :(
		//If more data of required is available
		//just peek what we need.
		if (buffersize > (fd.llSize - recv_size))
			buffersize = fd.llSize - recv_size;

		char *pBuf = malloc(buffersize);
		if (!pBuf)
		{
			fprintf(stderr, "\nMemory Error. Cannot allocate!\n");
			exit(-1);
		}

		read_size = recv(socket, pBuf, buffersize, 0);
		if (read_size  < 0)
		{
			printf("\n%s", strerror(errno));
			return 0;
		}

		//Write the currently read data into our fp file
		fwrite(pBuf, 1, buffersize, fp);

		free(pBuf);

		//Increment the total number of bytes read
		recv_size += read_size;
		
		printf("\rReceived %lli bytes out of %lli.", recv_size, fd.llSize);
	}

	fclose(fp);
	printf("\nFile successfully Received! \n");
	return 1;
}

int main(int argc, char *argv[])
{
	long long int socket_desc;
	struct sockaddr_in server;

	//printmonth(11, 2015, 30);
	//exit(0);

 #if defined(__WIN32__) || defined(_WIN32)
    //----------------------
    // Declare and initialize variables.
    int iResult;
    WSADATA wsaData;

    //----------------------
    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != NO_ERROR)
	{
        printf("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }
 #endif

	//Create socket
	socket_desc = socket(AF_INET, SOCK_STREAM, 0);

	if (socket_desc == -1)
	{
		printf("Could not create socket \n");
	}

	memset(&server, 0, sizeof(server));
	//server.sin_addr.s_addr = inet_addr("10.170.0.40");
	server.sin_addr.s_addr = inet_addr("127.0.0.1");
	server.sin_family = AF_INET;
	server.sin_port = htons(6888);

	//Connect to remote server
	if (connect(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0)
	{
		// printf(strerror(errno));
		close(socket_desc);
		printf("Connect Error \n");
		return -1;
	}

	puts("Connected \n");

	while (ReceiveFile(socket_desc))
		;

	close(socket_desc);

	return 0;
}