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

Question

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

我正在研究的解决方案是接受 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)

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

Answer 1

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

您将需要创建一个数据结构，其中包含每个文件的文件句柄和偏移量（在虚拟文件中）。然后你可以在这个结构中搜索真正的文件句柄并计算正确的偏移量。

需要注意的问题：

• 如果您通过一次fread()调用读取文件的末尾

其他选项：

• 如果您不需要fseek()，您可以尝试教代码理解-为别名stdin并用于cat连接文件：cat file1 file2 file3 | program - output

• 使用FUSE API编写文件系统。在您的情况下，这并不像听起来那么可怕。这将允许您保持原始代码不变。相反，您将使用 FUSE 使文件看起来像一个巨大的文件。

  • FUSE Python 教程
  • FUSE - 用户空间中的文件系统第 1部分（第 2 部分）（第 3 部分）

Answer 2

听起来您想bash通过“进程替换”来实现 4.x 实现的目标：

the_program <(cat file1 file2 file3) output

也就是说，您已将输入文件作为程序可以打开和读取的cat命名流（它可能是一个名称，例如）发送。/dev/fd/64这避免了对程序的所有修改。

这是否满足您的要求（除了需要C代码来实现效果）？一个可能的问题是程序是否需要可查找的文件；目前尚不清楚您是否能够在打开的文件流上进行搜索。

Answer 3

这是一个实现基础的截断拦截解决方案。有限的测试，有限的错误检查，几乎像羽毛一样健壮。并非所有功能都是完整的，并且很多功能都丢失了（如果您的代码使用 fseeki64，请在此处实现等）。这是我回避的解决方案（将按照建议尝试 fuse），但如果其他人想这样做，这可能是一个起点。

主要的

#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)