c-将多个流透明地视为一个流(流大小已知)

我试图解决的问题是优化某些第三方代码的输入，该代码具有命令行"program input_file output_file"。第三方代码使用标准fopen、fseek、fread等处理input_file。我希望能够使用多个输入文件，将它们视为一个文件，就像它们按照提供的顺序连接在一起一样。我有第三方代码，但希望尽可能少地修改它。目前我正在连接文件，然后用连接的文件作为输入调用程序，我试图消除连接，因为文件可能很大，而且需要时间。从stdin读取并不能达到我想要的目的，因为程序会将stdin写入一个文件以允许查找。

我正在研究的解决方案是接受input_file命令行参数作为连接(？分隔)的多个文件，并将concat_stream.h添加到程序源的开头(包括stdio之后)。concat_stream.h通过拦截标准调用，实现了将多个流透明地视为一个流，并使用流的一些全局数组和伴随的数据来实现级联流。以下是concat_stream.h的一小部分作为示例：

FILE * fopen_concat_streams (char * filename, char * mode )
{
if( strchr(filename, '?')!=NULL )/*do we want a concat_stream?*/
return concat_streams_init(filename, mode);/*setup concat_stream, return first stream as id*/
else
return fopen(filename, mode);/*standard library implementation*/
}
long int ftell_concat_streams( FILE * stream )
{
unsigned int index=is_stream_concat(stream);/*work out if stream refers to a concat_stream or regular stream*/
if(index!=CONCAT_STREAMS_MAX)/*is stream a concat_stream?*/
{
...
return answer;/*work out and return location in concat_stream*/
}
else
return ftell(stream);/*standard library implementation*/
}
#define fopen(x, y) fopen_concat_streams(x, y)
#define ftell(x) ftell_concat_streams(x)

我的问题是，我是否走上了正确的轨道，有没有更简单的方法？如果有一个图书馆可以帮我解决这个问题，我会用它来代替，这似乎应该是一件受欢迎的事情，但到目前为止我还没有找到任何东西。解决初始问题的完全不同的方法也会被接受，多个流作为一个流只是我对最简单解决方案的最佳猜测。

如果您知道所有文件的路径和大小，那么这可能会起作用。您试图实现的是创建一个由所有单独部分组成的虚拟文件。

您需要创建一个数据结构，其中包含每个文件的文件句柄和偏移量(在虚拟文件中)。然后，您可以在此结构中搜索实际的文件句柄并计算正确的偏移量。

需要注意的问题：

如果使用单个fread()调用读取文件末尾

其他选项：

如果您不需要fseek()，您可以尝试教代码将-理解为stdin的别名，并使用cat连接文件：cat file1 file2 file3 | program - output
使用FUSE API编写一个文件系统。这并不像你的情况听起来那么可怕。这将允许您保持原始代码不变。相反，您可以使用FUSE使文件看起来像一个巨大的文件。
- FUSE Python教程
- FUSE-用户空间中的文件系统第1部分(第2部分)(第3部分)

听起来您想要实现bash4.x通过"过程替代"实现的功能：

the_program <(cat file1 file2 file3) output

也就是说，让cat将输入文件作为一个命名流发送(可能是/dev/fd/64之类的名称)，程序可以打开并从中读取。这样可以避免对程序的所有修改。

这是否满足您的要求(除了需要C代码才能达到效果)？一个可能的问题是，如果程序需要一个可查找的文件；目前还不清楚您是否能够在打开的文件流上进行搜索。

下面是一个实现基本功能的截取解决方案。有限的测试，有限的错误检查，就像羽毛一样坚固。并不是所有的函数都是完整的，很多函数都缺失了(如果您的代码使用fseeki64，请在这里实现它等)。这是一个我回避的解决方案(会按照建议尝试融合)，但如果其他人想这样做，这可能是一个起点。

主

#include <stdio>
#include "concat_streams.h"
int main(int argc, char*argv[])
{
char buf[16];
concat_streams_global_init('?');
FILE* file = fopen( "file1?file2?file3?file4", "rb" );
...
fseek( file, 12, SEEK_SET);
...
fread(buf, 1, 16, file);
...
fclose(file);
}

concat_streams.h

#define CONCAT_STREAMS_MAX 10 /*max number of concat streams*/
FILE*** concat_streams=NULL;
size_t** concat_streams_boundaries=NULL;
size_t* concat_streams_count=NULL;
size_t* concat_streams_selector=NULL;
size_t* concat_streams_tot_size=NULL;
char concat_streams_delim='?';
/*return index of stream if it is concat, CONCAT_STREAMS_MAX otherwise*/
int is_stream_concat(FILE* stream)
{
unsigned int index=0;
while(index<CONCAT_STREAMS_MAX)
{
if(concat_streams[index]!=NULL)
{
if(concat_streams[index][0]==stream)
break;
}
++index;
}
return index;
}
/*Initialise concat_stream store*/
void concat_streams_global_init(char delim_use)
{
concat_streams_delim=delim_use;
concat_streams=(FILE***) malloc(sizeof(FILE**)*CONCAT_STREAMS_MAX);
concat_streams_boundaries=(size_t**) malloc(sizeof(size_t*)*CONCAT_STREAMS_MAX);
concat_streams_count=(size_t*) malloc(sizeof(size_t)*CONCAT_STREAMS_MAX);
concat_streams_selector=(size_t*) malloc(sizeof(size_t)*CONCAT_STREAMS_MAX);
concat_streams_tot_size=(size_t*) malloc(sizeof(size_t)*CONCAT_STREAMS_MAX);
memset(concat_streams, 0, sizeof(FILE**)*CONCAT_STREAMS_MAX );
memset(concat_streams_boundaries, 0, sizeof(size_t*)*CONCAT_STREAMS_MAX);
memset(concat_streams_count, 0, sizeof(size_t)*CONCAT_STREAMS_MAX );
memset(concat_streams_selector, 0, sizeof(size_t)*CONCAT_STREAMS_MAX );
memset(concat_streams_tot_size, 0, sizeof(size_t)*CONCAT_STREAMS_MAX );
}
/*The meat of fopen*/
FILE* concat_streams_init(char* files_question_delim, char * mode)
{
unsigned int concat_streams_next_set=0;
while(concat_streams_next_set<CONCAT_STREAMS_MAX)
{
if(concat_streams[concat_streams_next_set]==NULL)
break;
++concat_streams_next_set;
}
if(concat_streams_next_set==CONCAT_STREAMS_MAX)
return NULL;
char*files_question_delim_cpy=NULL;
unsigned int i=0;
while(files_question_delim[i]!=0)
{
if(files_question_delim[i]=='?')
++concat_streams_count[concat_streams_next_set];
++i;
}
++concat_streams_count[concat_streams_next_set];
files_question_delim_cpy=(char*)malloc(i);
memcpy(files_question_delim_cpy, files_question_delim, i);
concat_streams[concat_streams_next_set]=(FILE**)malloc(sizeof(FILE*)*concat_streams_count[concat_streams_next_set]);
concat_streams_boundaries[concat_streams_next_set]=(size_t*)malloc(sizeof(size_t)*(concat_streams_count[concat_streams_next_set]+1));
concat_streams_boundaries[concat_streams_next_set][0]=0;

char* next_file;
next_file=strtok(files_question_delim_cpy, "?");
while(next_file!=NULL)
{
concat_streams[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]]=fopen(next_file, "rb");
if(concat_streams[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]]==NULL)
{
fclose_concat_streams(concat_streams[concat_streams_next_set][0]);
return NULL;/*fopen failed*/
}
fseek(concat_streams[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]], 0, SEEK_END);
concat_streams_boundaries[concat_streams_next_set][1+concat_streams_selector[concat_streams_next_set]] = concat_streams_boundaries[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]] + ftell(concat_streams[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]]);
concat_streams_tot_size[concat_streams_next_set]+=ftell(concat_streams[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]]);
rewind(concat_streams[concat_streams_next_set][concat_streams_selector[concat_streams_next_set]]);
++concat_streams_selector[concat_streams_next_set];
next_file=strtok(NULL, "?");
}
concat_streams_selector[concat_streams_next_set]=0;
free(files_question_delim_cpy);
return concat_streams[concat_streams_next_set][0];
}
FILE * fopen_concat_streams (char * filename, char * mode )
{
if( strchr(filename, '?')!=NULL )
return concat_streams_init(filename, mode);
else
return fopen(filename, mode);
}
/*only implemented origin==SEEK_SET*/
int fseek_concat_streams( FILE * stream, long int offset, int origin )
{
unsigned int i=0;
unsigned int index=is_stream_concat(stream);
if(index!=CONCAT_STREAMS_MAX)
{
switch(origin)
{
case SEEK_SET:
while(i<concat_streams_count[index])
{
if(offset>=concat_streams_boundaries[index][i] && offset<concat_streams_boundaries[index][i+1])
break;
++i;
}
if(i==concat_streams_count[index])
return 1;/*out of range*/
concat_streams_selector[index]=i;
return fseek(concat_streams[index][concat_streams_selector[index]], offset-concat_streams_boundaries[index][concat_streams_selector[index]], SEEK_SET);
default:
puts("error, Only SEEK_SET supported when using cat streams");
return 1;/*not implemented*/
}
}
else
return fseek(stream, offset, origin);/*just a normal file*/
}
long int ftell_concat_streams( FILE * stream )
{
unsigned int index=is_stream_concat(stream);
if(index!=CONCAT_STREAMS_MAX)
{
/*Found*/
return concat_streams_boundaries[index][concat_streams_selector[index]] + ftell(concat_streams[index][concat_streams_selector[index]]);
}
else
return ftell(stream);
}
int feof_concat_streams( FILE * stream )
{
unsigned int index=is_stream_concat(stream);
if(index!=CONCAT_STREAMS_MAX)
{
if(concat_streams_selector[index]==concat_streams_count[index])
return 1;/*EOF*/
else
return 0;
}
else
return feof(stream);
}
size_t fread_concat_streams (void * ptr, size_t size, size_t count, FILE * stream )
{
size_t mult=size*count;
size_t num_to_go=mult;
char* buffer=NULL;
unsigned int index=is_stream_concat(stream);
unsigned int num_read;
char* out_ptr=(char*)ptr;
if(index!=CONCAT_STREAMS_MAX)
{
if(concat_streams_selector[index]==concat_streams_count[index])
return 0;/*at eof*/
buffer=(char*)malloc(2048*4096);
while(num_to_go!=0)
{
num_read=fread(buffer, 1, num_to_go>=2048*4096?2048*4096:num_to_go, concat_streams[index][concat_streams_selector[index]]);
if( num_read != (num_to_go>=2048*4096?2048*4096:num_to_go) )
{
if( feof(concat_streams[index][concat_streams_selector[index]])==0 )
{
puts("EOF not set, read error");
memcpy(out_ptr, buffer, num_read);
out_ptr+=num_read;
num_to_go-=num_read;
free(buffer);
return mult-num_to_go;
}
else
{
rewind(concat_streams[index][concat_streams_selector[index]]);
++concat_streams_selector[index];
if(concat_streams_selector[index]==concat_streams_count[index])
{
memcpy(out_ptr, buffer, num_read);
out_ptr+=num_read;
num_to_go-=num_read;
free(buffer);
return mult-num_to_go;
}
else
rewind(concat_streams[index][concat_streams_selector[index]]);
}
}
memcpy(out_ptr, buffer, num_read);
out_ptr+=num_read;
num_to_go-=num_read;
}
free(buffer);  
return mult;
}
else
return fread(ptr, size, count, stream);
}
size_t fwrite_concat_streams ( const void * ptr, size_t size, size_t count, FILE * stream )
{
unsigned int index=is_stream_concat(stream);
if(index!=CONCAT_STREAMS_MAX)
{
puts("error, writing to cat_streams not supported");
return 0;
}
else
return fwrite(ptr, size, count, stream);
}
int fclose_concat_streams ( FILE * stream )
{
unsigned int i=0;
unsigned int index=is_stream_concat(stream);
if(index!=CONCAT_STREAMS_MAX)
{
while(i<concat_streams_count[index])
{
fclose(concat_streams[index][i]);
++i;
}
free(concat_streams[index]);
concat_streams[index]=NULL;
free(concat_streams_boundaries[index]);
concat_streams_boundaries[index]=NULL;
concat_streams_count[index]=0;
concat_streams_selector[index]=0;
concat_streams_tot_size[index]=0;
}
else
return fclose(stream);
}
#define fseek(x, y, z) fseek_concat_streams(x, y, z)
#define fread(w, x, y, z) fread_concat_streams(w, x, y, z)
#define fwrite(w, x, y, z) fwrite_concat_streams(w, x, y, z)
#define fopen(x, y) fopen_concat_streams(x, y)
#define ftell(x) ftell_concat_streams(x)
#define feof(x) feof_concat_streams(x)
#define fclose(x) fclose_concat_streams(x)

相关内容

最新更新

热门标签：