main.cpp

#include <iostream>
#include <stdio.h>
#include <sys/stat.h>
#include "socketreceiver.h"

using namespace std;

int file_exists(string filename) {
    struct stat buffer;
    return (stat (filename.c_str(), &buffer) == 0);
}

bool written = false;

int main(int argc, char *argv[]) {
    try {
        socketreceiver r;

        ssize_t n = 0;
        char recvBuff[1024];

        if (argc != 2)
            throw "No hostname provided in argument";

        string hostname = string(argv[1]);
        r.connect_server(hostname);

        cout << r.recv_message() << endl;

        string filename;
        cout << "Enter File Name to retrieve : " << endl;
        cin >> filename;

        cout << "Trying to receive " << filename << endl;
        r.send_message(filename);

        if(file_exists(filename.c_str()))
            remove(filename.c_str());

        FILE *fp = fopen(filename.c_str(), "ab");

        while ((n = r.fill_buffer(recvBuff, sizeof(recvBuff))) > 0) {
            fwrite(recvBuff, 1, (size_t) n, fp);
            written = true;
        }

        if(!written) {
            cout << "File transfer failed" << endl;
            remove(filename.c_str());
        } else {
            printf("File Transfer Complete");
        }

        fclose(fp);
    } catch (const char* error) {
        cout << error << endl;
    }

    return 0;
}

socketreceiver.cpp

#include "socketreceiver.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

void socketreceiver::send_message(std::string message) {
    send(connection_desc , message.c_str(), message.length() , 0);
}

std::string socketreceiver::recv_message() {
    char buffer[1024];
    ssize_t n = read(connection_desc, buffer, sizeof(buffer));

    buffer[n] = '\0';

    return std::string(buffer);
}

ssize_t socketreceiver::fill_buffer(char *buffer, size_t size) {
    bzero(buffer, size);
    ssize_t n = recv(connection_desc, buffer, size, 0);
    buffer[n] = '\0';

    return n;
}

void socketreceiver::connect_server(std::string hostname) {
    connection_desc = socket(AF_INET, SOCK_STREAM, 0);

    if(connection_desc < 0)
        throw "Socket creation failed";

    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(4040);

    if(inet_pton(AF_INET, hostname.c_str(), &serv_addr.sin_addr) <= 0)
        throw "Invalid hostname";

    int connect_result = connect(connection_desc, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if(connect_result < 0)
        throw "Socket connection failed";
}

socketreceiver::~socketreceiver() {
    close(connection_desc);
}

socketreceiver.h

#ifndef FILERECEIVER_SOCKETRECEIVER_H
#define FILERECEIVER_SOCKETRECEIVER_H

#include <string>
#include <stdio.h>

class socketreceiver {
private:
    int connection_desc;
public:
    void connect_server(std::string hostname);

    void send_message(std::string message);
    std::string recv_message();

    ssize_t fill_buffer(char* buffer, size_t size);

    ~socketreceiver();
};


#endif //FILERECEIVER_SOCKETRECEIVER_H