c - 在 freebsd 7 上快速修复 32 位(2GB 限制)fseek/ftell

Question

我在 FreeBSD 上有一个旧的 32 位 C/C++ 程序，它被数百个用户远程使用，而它的作者不会修复它。它以不安全的方式编写，所有文件偏移量都在内部存储为无符号的 32 位偏移量，并且使用了 ftell/fseek 函数。在 FreeBSD 7(软件主机平台)中，它 means that ftell and fseek uses 32-bit signed long :

 int fseek(FILE *stream, long offset, int whence);

 long ftell(FILE *stream);

我需要快速修复程序，因为一些内部数据文件在收集数据 13 年后突然达到 2^31 文件大小(2 147 483 7yy 字节)，并且内部 fseek/ftell 断言现在对任何请求都失败.

在 FreeBSD7 世界中，fseeko/ftello hack 用于 2GB+ 文件。

 int
 fseeko(FILE *stream, off_t offset, int whence);

 off_t
 ftello(FILE *stream);

这里的off_t 类型没有明确定义；我现在所知道的是，它有 8 字节大小，看起来像 long long 或 unsigned long long(我不知道是哪个)。

是否足够(最多处理 4 GB 文件)并且安全地搜索和替换所有 ftell 到 ftello，以及所有 fseek 到 fseeko(sed -i 's/ftell/ftello'，与 seek 相同)，如果可能的话，它们的用法是:

 unsigned long offset1,offset2; //32bit
 offset1 = (compute + it) * in + some - arithmetic;
 fseek(file, 0, SEEK_END);
 fseek(file, 4, SEEK_END); // or other small int constant

 offset2 = ftell(file);
 fseek(file, offset1, SEEK_SET);  // No usage of SEEK_CUR

以及此类调用的组合。

off_t 的符号是什么？将 64 位 off_t 分配给无符号的 32 位偏移量是否安全？它适用于 2 GB 到 4 GB 范围内的字节吗？

除了 ftell/fseek 之外，还有哪些函数可以用来处理偏移量？

Answer 1

FreeBSD fseeko() and ftello() 被记录为 POSIX.1-2001 兼容，这意味着 off_t is a signed integer type .

在 FreeBSD 7 上，您可以安全地执行以下操作:

off_t          actual_offset;
unsigned long  stored_offset;

if (actual_offset >= (off_t)0 && actual_offset < (off_t)4294967296.0)
    stored_offset = (unsigned long)actual_offset;
else
    some_fatal_error("Unsupportable file offset!");

(在 LP64 架构上，上面的代码会很愚蠢，因为 off_t 和 long 都是 64 位有符号整数。即使那样也是安全的；只是很愚蠢，因为可以支持所有可能的文件偏移量。 )

人们经常被这个问题困扰的是，偏移量计算必须使用 off_t 来完成。 .也就是说，将 result 转换为 off_t 是不够的, 你必须投 values用于算术 off_t . (从技术上讲，您只需要确保每个算术运算都以 off_t 的精度完成，但我发现如果我只是将所有操作数都用 punt 和 cast 来记住规则会更容易。)例如:

off_t          offset;
unsigned long  some, values, used;

offset = (off_t)some * (off_t)value + (off_t)used;
fseeko(file, offset, SEEK_SET);

通常偏移计算用于查找特定记录中的字段；算术往往保持不变。如果可能的话，我真的建议您将查找操作移至辅助函数:

int fseek_to(FILE *const file,
             const unsigned long some,
             const unsigned long values,
             const unsigned long used)
{
    const off_t  offset = (off_t)some * (off_t)value + (off_t)used;
    if (offset < (off_t)0 || offset >= (off_t)4294967296.0)
        fatal_error("Offset exceeds 4GB; I must abort!");
    return fseeko(file, offset, SEEK_SET);
}

现在，如果你碰巧处于一个幸运的位置，你知道所有的偏移量都是对齐的(到某个整数，比如 4)，你可以给自己几年更多的时间来重写应用程序，方法是使用上面的扩展:

#define BIG_N 4

int fseek_to(FILE *const file,
             const unsigned long some,
             const unsigned long values,
             const unsigned long used)
{
    const off_t  offset = (off_t)some * (off_t)value + (off_t)used;
    if (offset < (off_t)0)
        fatal_error("Offset is negative; I must abort!");
    if (offset >= (off_t)(BIG_N * 2147483648.0))
        fatal_error("Offset is too large; I must abort!");
    if ((offset % BIG_N) && (offset >= (off_t)2147483648.0))
        fatal_error("Offset is not a multiple of BIG_N; I must abort!");
    return fseeko(file, offset, SEEK_SET);
}

int fseek_big(FILE *const file, const unsigned long position)
{
    off_t  offset;
    if (position >= 2147483648UL)
        offset = (off_t)2147483648UL
               + (off_t)BIG_N * (off_t)(position - 2147483648UL);
    else
        offset = (off_t)position;
    return fseeko(file, offset, SEEK_SET);
}

unsigned long ftell_big(FILE *const file)
{
    off_t  offset;
    offset = ftello(file);
    if (offset < (off_t)0)
        fatal_error("Offset is negative; I must abort!");
    if (offset < (off_t)2147483648UL)
        return (unsigned long)offset;
    if (offset % BIG_N)
        fatal_error("Offset is not a multiple of BIG_N; I must abort!");
    if (offset >= (off_t)(BIG_N * 2147483648.0))
        fatal_error("Offset is too large; I must abort!");
    return (unsigned long)2147483648UL
         + (unsigned long)((offset - (off_t)2147483648UL) / (off_t)BIG_N);
}

逻辑很简单:如果 offset 小于 2³¹，则按原样使用。否则，它由值 2³¹ + BIG_N × (offset - 2^{31 )。唯一的要求是偏移量 231 及以上始终是 BIG_N 的倍数。}

显然，您必须仅使用上述三个函数——加上您需要的任何 fseek_to() 变体，只要它们进行相同的检查，只需使用不同的参数和公式进行偏移量计算 --，您可以支持最大 2147483648 + BIG_N × 2147483647 的文件大小。对于 BIG_N==4，即 10 GiB (少了 4 个字节；准确地说是 10,737,418,236 个字节)。

有问题吗？

---

编辑澄清:

从更换您的 fseek(file, position, SEEK_SET) 开始调用电话 fseek_pos(file, position) ,

static inline void fseek_pos(FILE *const file, const unsigned long position)
{
    if (fseeko(file, (off_t)position, SEEK_SET))
        fatal_error("Cannot set file position!");
}

和fseek(file, position, SEEK_END)调用电话 fseek_end(file, position) (为了对称——我假设这个位置通常是一个字面整数常量)，

static inline void fseek_end(FILE *const file, const off_t relative)
{
    if (fseeko(file, relative, SEEK_END))
        fatal_error("Cannot set file position!");
}

最后，ftell(file)调用电话 ftell_pos(file) :

static inline unsigned long ftell_pos(FILE *const file)
{
    off_t position;
    position = ftello(file);
    if (position == (off_t)-1)
        fatal_error("Lost file position!");
    if (position < (off_t)0 || position >= (off_t)4294967296.0)
        fatal_error("File position outside the 4GB range!");
    return (unsigned long)position;
}

因为在你的架构和操作系统上 unsigned long是 32 位无符号整数类型，off_t是 64 位有符号整数类型，这为您提供了完整的 4GB 范围。

对于偏移计算，定义一个或多个类似于

的函数

static inline void fseek_to(FILE *const file, const off_t term1,
                                              const off_t term2,
                                              const off_t term3)
{
    const off_t position = term1 * term2 + term3;

    if (position < (off_t)0 || position >= (off_t)4294967296.0)
        fatal_error("File position outside the 4GB range!");
    if (fseeko(file, position, SEEK_SET))
        fatal_error("Cannot set file position!");
}

对于每个偏移量计算算法，定义一个fseek_to变种。命名参数，使算术有意义。制作参数const off_t ，如上所述，因此您不需要在算术中进行额外的转换。只有参数和 const off_t position =定义计算算法的行因变体函数而异。

有问题吗？