在C语言中将文件拆分为固定大小的块

我被要求将文件分割成固定大小的块来进行文件加密。更具体地说，我有很多文件，可以是二进制文件或文本文件

我被要求编写一个用户程序，将这些文件作为输入，将每个文件拆分为许多32位块，然后发送32位块

这种情况下，用户在远程服务器中备份其文件，方法是将其文件拆分为块，对块进行加密（使用RSA），然后将密文发送到服务器

考虑两个文件，一个是33位文本文件a，另一个是34位二进制文件B。
A可以分为两个32位块A1和A2（A2的最后31位都是0）。
B可以分为两个32位块B1和B2（B2的最后30位都是0）。 如果我得到A1（或者A2，B1，B2），那么我认为A1是一个32位整数，可以进行RSA加密

我能够为RSA加密编写代码，但不幸的是，我不知道如何编写用于获取A1、A2、B1、B2的C代码

---

有人能帮我写一个示例代码或给我一些参考吗？

下面是一个高级算法，您可以轻松地将其转换为C代码：

char* get_Next_Block_From_File(FILE *fp, int seek_offset, int blockSize)
{
    // Open file
    // lseek to seek_offset

    len = blockSize / 8;
    bit_pos = blockSize % 8;

    for (i=0; i<len; i++) {
        copy_from_file_to_local_buffer_byte_by_byte();
    }

    if (bit_pos) {
        byte[i] <<= (8 - bit_pos);
        append_byte_to_local_buffer();
    }

    return local_buffer;
}

char*get\u Next\u Block\u From\u File（File*fp，int seek\u offset，int blockSize）
{
//打开文件
//lseek寻找_偏移
len=块大小/8；
比特位置=块大小%8；
对于（i=0；i
C）程序，用于将给定文件拆分为固定大小的块
//split.cpp：主项目文件。
#包括“stdafx.h”
使用名称空间系统；
#包括
#包括
#包括
#定义段600//小文件的近似目标大小
长文件大小（char*name）；//下面的函数定义
int splitFile（字符*fp1，大小\u t最大大小）；
长文件大小（字符*名称）
{
文件*fp=fopen（名称，“rb”）；//必须是二进制读取才能获取字节
长尺寸=-1；
if（fp）
{
fseek（fp，0，SEEK_END）；
尺寸=ftell（fp）+1；
fclose（fp）；
}
返回大小；
}
/*
**分割文件
**将现有输入文件拆分为多个具有指定格式的输出文件
**最大文件大小。
**
**返回值：
**创建的结果文件数，如果输入数据不正确或为负数，则为0
**值，以防在文件拆分期间出错。
*/
int splitFile（）
{
int结果=0；
字符缓冲区[1024]；//更改请参见//2098*16
大小；
尺寸不可读取；
书写的大小；
int段=0，i，len，acum；
//文件*fp1，*fp2；
字符文件名[260]={“}；
//char filename[260]={“D:\\smallFileName\uz}；//小文件的基本名称。
char largeFileName[]={“D:\\Payload\u data\\Datafile\u to\u split.txt”}；//更改路径
long sizeFile=文件大小（largeFileName）；
char smallFileName[260]；
字符行[1024]；
长maxSize=sizeFile/段+1；
int filecounter=1；
文件*fIn；
文件*fOut；
fIn=fopen（大文件名，“rb”）；
如果（（fIn！=NULL）&&（maxSize>0））
{
//fIn=fopen（fIn，“rb”）；
如果（fIn！=NULL）
{
fOut=NULL；
结果=1；/*我们至少有一个零件*/
//将数据从pchar拆分为多个文件
对于（i=1；i最大尺寸）
{
读取=最大大小-大小；
}
/*从输入文件读取数据*/
read=fread（缓冲区，1，read，fIn）；
如果（读==0）
{
结果*=-1；
打破
}
/*将数据写入输出文件*/
write=fwrite（缓冲区，1，读取，fOut）；
如果（已写！=已读）
{
结果*=-1；
打破
}
/*更新当前输出文件的大小计数器*/
大小+=已写入；
如果（大小>=maxSize）/*下一次拆分*/
{
fclose（fOut）；
fOut=NULL；
结果++；
}
}
/*清理*/
如果（fOut！=NULL）
{
fclose（fOut）；
}
财务总监（财务）；
}
} 
}
返回（结果）；
}
内部主（空）
{
//segments=sizeFile/SEGMENT+1；//确保文件结束
//fp1=fopen（大文件名，“r”）；
////如果（fp1）
////{
//对于（i=0；我总是觉得这些教程很有用：我不知道有哪种计算机系统可以提供“33位文本文件”文件包含整字节，而不是位。你想用C或C++来做吗？我以前读过，但是还不知道怎么做。例如，网页上说我们需要不同的代码用于文本和二进制文件。所以，标准程序是先知道所考虑的文件是二进制还是文本，然后使用不同的代码来处理。当进行加密时，将文本文件视为二进制文件是安全的。但我想知道应该调用哪个函数
C Program for splitting the given file into fixed size blocks

// split.cpp : main project file.

#include "stdafx.h"

using namespace System;

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

#define SEGMENT 600 //approximate target size of small file

long file_size(char *name);//function definition below
int splitFile(char *fp1, size_t maxSize);


long file_size(char *name)
{
    FILE *fp = fopen(name, "rb"); //must be binary read to get bytes

    long size=-1;
    if(fp)
    {
        fseek (fp, 0, SEEK_END);
        size = ftell(fp)+1;
        fclose(fp);
    }
    return size;
}

/*
**  splitFile
**  Splits an existing input file into multiple output files with a specified
**  maximum file size.
**
**  Return Value:
**  Number of created result files, or 0 in case of bad input data or a negative
**  value in case of an error during file splitting.
*/
int splitFile()
{
    int result = 0;

    char buffer[1024];//change see //2098 * 16
    size_t size;
    size_t read;
    size_t written;

    int segments=0, i, len, accum;

    //FILE *fp1, *fp2;

    char filename[260]={""};
    //char filename[260]={"D:\\smallFileName_"};//base name for small files.
    char largeFileName[]={"D:\\Payload_data\\Datafile_to_split.txt"};//change to your path
    long sizeFile = file_size(largeFileName);
    char smallFileName[260];
    char line[1024];
    long maxSize= sizeFile/SEGMENT + 1;
    int filecounter=1;

    FILE *fIn;
    FILE *fOut;
    fIn = fopen(largeFileName, "rb");

    if ((fIn != NULL) && (maxSize > 0))
    {
       // fIn = fopen(fIn, "rb");
        if (fIn != NULL)
        {
            fOut = NULL;
            result = 1;   /* we have at least one part */

            // Splitting Data from pchar into multiple files
                for(i=1; i<25 ;i++)
                    {               
                        sprintf(smallFileName, "%s%d.txt", filename, i);                      
                         printf("\n File number %d",i);
                         while (!feof(fIn))
                         {
                         /* initialize (next) output file if no output file opened */
                              if (fOut == NULL)
                              {  
                                 filecounter++;

                                sprintf(buffer, "smallFileName_%d", filecounter);
                                fOut = fopen(buffer, "wb");
                             if (fOut == NULL)
                             { 
                                 result *= -1;   
                                 break; 
                             }

                                size = 0;
                             }

                /* calculate size of data to be read from input file in order to not exceed maxSize */
                read = sizeof(buffer);
                if ((size + read) > maxSize)
                {
                    read = maxSize - size;
                }

                /* read data from input file */
                read = fread(buffer, 1, read, fIn);
                if (read == 0)
                {
                    result *= -1;
                    break;
                }

                /* write data to output file */
                written = fwrite(buffer, 1, read, fOut);

                if (written != read)
                {
                    result *= -1;
                    break;
                }

                /* update size counter of current output file */
                size += written;
                if (size >= maxSize)   /* next split? */
                {
                    fclose(fOut);
                    fOut = NULL;
                    result++;
                }
            }

            /* clean up */
            if (fOut != NULL)
            {
                fclose(fOut);
            }
            fclose(fIn);
        }
    } 
}
    return (result);
}


int main(void)
{


    //segments = sizeFile/SEGMENT + 1;//ensure end of file


    //fp1 = fopen(largeFileName, "r");

    ////if(fp1)
    ////{
    //    for(i=0;i<segments;i++)
    //    {
    //        accum = 0;
    //        sprintf(smallFileName, "%s%d.txt", filename, i);
    //        fp2 = fopen(smallFileName, "w");
    //        if(fp2)
    //        {
    //            while(fgets(line, 1080, fp1) && accum <= SEGMENT)
    //            {
    //                accum += strlen(line);//track size of growing file
    //                fputs(line, fp2);
    //            }
    //            fclose(fp2);
    //        }
    //    }
    //    fclose(fp1);
    //}


    //maxSize =sizeFile/SEGMENT + 1;
    //ensure end of file
    splitFile();

    getch();
    printf("\n File splitted Successfully");
    return 0;
}