Source_Code.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <pthread.h>

#define Threads 4

typedef struct {
    const char *url;
    long start;
    long end;
    int tid;
    const char *fname;
    pthread_mutex_t *file_lock;
} DownloadTask;

size_t write_data(void *ptr, size_t size, size_t nmemb, void *data) {
    DownloadTask *task = (DownloadTask *)data;
    size_t total_size = size * nmemb;

    pthread_mutex_lock(task->file_lock);

    FILE *fp = fopen(task->fname, "rb+");
    if (fp) {
        fseek(fp, task->start, SEEK_SET);
        fwrite(ptr, 1, total_size, fp);
        fclose(fp);
    }

    pthread_mutex_unlock(task->file_lock);
    return total_size;
}

void *download_part(void *arg) {
    DownloadTask *task = (DownloadTask *)arg;
    CURL *curl = curl_easy_init();
    char range[64];

    if (!curl) {
        fprintf(stderr, "Thread %d: Failed to init curl\n", task->tid);
        return NULL;
    }

    snprintf(range, sizeof(range), "%ld-%ld", task->start, task->end);

    curl_easy_setopt(curl, CURLOPT_URL, task->url);
    curl_easy_setopt(curl, CURLOPT_RANGE, range);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, task);

    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);

    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        fprintf(stderr, "Thread %d: Download failed: %s\n", task->tid, curl_easy_strerror(res));
    } else {
        printf("Thread %d: Finished downloading bytes %s\n", task->tid, range);
    }

    curl_easy_cleanup(curl);
    return NULL;
}

void start_download(const char *url, const char *fname, long fsize) {
    pthread_t threads[Threads];
    DownloadTask tasks[Threads];
    pthread_mutex_t file_lock = PTHREAD_MUTEX_INITIALIZER;

    FILE *fp = fopen(fname, "wb");
    if (!fp) {
        perror("File open failed");
        return;
    }
    fseek(fp, fsize - 1, SEEK_SET);
    fputc('\0', fp);
    fclose(fp);

    long part_size = fsize / Threads;

    for (int i = 0; i < Threads; i++) {
        tasks[i].url = url;
        tasks[i].start = i * part_size;
        tasks[i].end = (i == Threads - 1) ? fsize - 1 : (i + 1) * part_size - 1;
        tasks[i].tid = i;
        tasks[i].fname = fname;
        tasks[i].file_lock = &file_lock;

        pthread_create(&threads[i], NULL, download_part, &tasks[i]);
    }

    for (int i = 0; i < Threads; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("? Download complete: %s\n", fname);
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <URL>\n", argv[0]);
        return 1;
    }

    const char *url = argv[1];
    const char *fname = "downloaded_file.bin";
    long fsize = 1024L * 1024 * 1024; 

    printf("Starting download: %s (%ld bytes)\n", url, fsize);
    start_download(url, fname, fsize);

    return 0;
}