File part 2

    #include <stdio.h>
    #include <conio.h>
    #include <memory.h>
    #include <malloc.h>
    #include <string.h>

    #define MAX_CHAR        260
    #define MAX_BUFFER        8192

    void get_file_name(const char* src_file, char* file_name)
    {
        int i;
        char* p;
        i = strlen(src_file);
        while(i && src_file[--i] != '\\')
        strcpy(file_name, src_file + i);
    }


    void get_ext_name(const char* src_file, char* ext)
    {
        int i;

        i = strlen(src_file);
        while(i && src_file[--i] != '.');
        strcpy(ext, src_file + i + 1);
    }

    void remove_ext(char* src_name)
    {
        int i;
        if(!src_name)
            return;
        i = strlen(src_name);
        while(i && src_name[--i] != '.')
            src_name[i] = '\0';
        src_name[i] = '\0';
    }
    int split(const char* src_name, int part_size, const char* dest_path, int src_remove) // part_size có đơn vị là byte. src_remove chọn xóa hoặc không xóa file nguồn.
    {
        FILE* src_file;
        unsigned char buffer[MAX_BUFFER];
        int   buff_size;
        int   file_size;
//        int   part_size;
        int      remain;
        int   current;
        int count = 0;

        if(part_size > 0 )
        {
            src_file = fopen(src_name, "rb");
            if(!src_file) // Không mở được file trả về 0
                return 0;
            fseek(src_file, SEEK_SET, SEEK_END); //dời con trỏ về cuối file để
            file_size = ftell(src_file); // lấy kích thước file
            fseek(src_file, SEEK_SET, SEEK_SET); // dời con trỏ về đầu file để xử lý file
            count = file_size / part_size ; // chia file thành từng phần
            remain = file_size % part_size; // phần còn dư

            current = 0; // biến đếm số file đc chia ra
            while(current <= count)
            {
                int block;
                int remain_part;
                char file_part_name[MAX_CHAR];
                FILE* part;
                int     read;
                char full_path[MAX_CHAR];

                get_file_name(src_name, file_part_name); // lấy tên file vd: c:\\file.exe -> file.exe
                sprintf(full_path, "%s%s.part%3d", dest_path, file_part_name, current + 1); // full_path có dạng C:\\file.part1, C:\\file.part2, ...
                part = fopen(full_path, "wb"); // Mo file co dang .part1, .part2, ... để ghi.
                //Tối ưu hóa việc ghi file vào bộ đệm
                block = part_size / MAX_BUFFER;
                remain_part = part_size % MAX_BUFFER;
               //==> 1
                // Ghi phần file dư còn lại
                if(current == count)
                {

                    if(remain)
                    {
                        unsigned char* buff;
                        buff = (unsigned char *)malloc(remain);
                        fread(buff, 1, remain, src_file);
                        fwrite(buff, 1, remain, part);
                        free(buff);
                    }
                }
                // ==> Kết thúc việc ghi
                else
                {
                    // 1 ==> 2
                    while(block)
                    {
                        fread(buffer, 1, sizeof(buffer), src_file);
                        fwrite(buffer, 1, sizeof(buffer), part);
                        --block;
                    }
                    if(remain_part)
                    {
                        fread(buffer, 1, remain_part, src_file);
                        fwrite(buffer, 1, remain_part, part);
                    }
                    // ==> End
                }
                fclose(part);
                ++current;
            }
            fclose(src_file);
            if(src_remove) // Xóa file nếu có
                remove(src_name);
            return 1;
        }
        return 0;
    }
    int join(const char* src_001, const char* dest_path)
    {
        char ext[10];
        FILE* file;
        int i = 0;
        char src_file[MAX_CHAR];
        char dest_file[MAX_CHAR];

        strcpy(src_file, src_001);
        file = fopen(src_001, "rb");
        if(!file)
            return 0;
        fclose(file);


        get_ext_name(src_001, ext);
        if(strcmp(ext, "001"))
            return 0;
        ///
        get_file_name(src_001, src_file);
        remove_ext(src_file);
        sprintf(dest_file, "%s%s", dest_path, src_file);

        file = fopen(dest_file, "wb");
        if(!file)
            return 0;

        while(1)
        {
            FILE* part;
            int   part_size;
            int   block;
            int      remain;
            unsigned char buffer[MAX_BUFFER];
            char  part_name[MAX_CHAR];

            sprintf(part_name, "%s%s.%0.3d", dest_path, src_file, ++i);// giống cái trên
            part = fopen(part_name, "rb");
            if(!part)
                break;
            fseek(part, SEEK_SET, SEEK_END);
            part_size = ftell(part);
            fseek(part, SEEK_SET, SEEK_SET);
            block = part_size / sizeof(buffer);
            remain = part_size % sizeof(buffer);
            while(block)
            {
                fread(buffer, 1, sizeof(buffer), part);
                fwrite(buffer, 1, sizeof(buffer), file);
                --block;
            }
            if(remain)
            {
                fread(buffer, 1, remain, part);
                fwrite(buffer, 1, remain, file);
            }
            fclose(part);
        }
        fclose(file);
        return 1;
    }
    int main(int argc, char* argv[])
    {
        if(split("123.mp4", 400*1024, "C:\\1\\", 0)) // file mẫu "x_man Random tran 1.rar" chia làm 4 phần
            printf("split file: done!\n");
       // if(join("C:\\1\\123.mp4.001", "C:\\"))
         //   printf("Join files: done!\n");

        return 0;
    }