c - 尝试替换文件中的文本会引发错误

Question

该脚本的要点是采用三个参数。查找、替换、前缀。 Find 是要替换的文本，replace 是替换文本的内容，而 prefix 是一种特殊情况。如果文本中存在前缀，则使用前缀+替换来替换前缀(某些文本)。我想知道为什么下面的代码在说打开的文件后立即抛出错误。如果被替换的文本重复，如“aaa”、“bbb”，其中“a”是被替换的文本，它似乎只会抛出错误。

 Opened file.txt
 *** Error in `./a.out': malloc(): memory corruption: 0x00005652fbc55980 ***

打印“尝试替换文件...”后偶尔也会出现段错误。我对系统上的 C 和 GDB 不太熟悉，导致只是缺少库错误，这与此无关。这是代码:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>

char concat(const char *s1, const char *s2)
{
    char *result = calloc(strlen(s1)+strlen(s2)+1, 1);
    strcpy(result, s1);
    strcat(result, s2);
    printf("Prefix will be replaced with %s.\n", result);
    return result;
}

static int replaceString(char *buf, const char *find, const char *replace, const char *prefix)
{

    int olen, rlen;
    char *s, *d;
    char *tmpbuf;

    if (!buf || !*buf || !find || !*find || !replace)
        return 0;

    tmpbuf = calloc(strlen(buf) + 1, 1);

    if (tmpbuf == NULL)
        return 0;

    olen = strlen(find);
    rlen = strlen(replace);

    s = buf;
    d = tmpbuf;

    while (*s) {
        if (strncmp(s, find, olen) == 0) {
            strcpy(d, replace);
            s += olen;
            d += rlen;
        }
        else
        {
            *d++ = *s++;
        }
    }

    *d = '\0';

   if(strcmp(buf, tmpbuf) == 0)
   {
          free(tmpbuf);
          return 0;
   }
   else
   {
         strcpy(buf, tmpbuf);
         free(tmpbuf);
         printf("%s", buf);
         printf("Replaced!\n");
         return 1;
   }

}

void getAndReplace(char* filename, char* find, char* replace, char* prefix)
{

   long length;
   FILE* f = fopen (filename, "r");
   char* buffer = 0;

   if (f)
   {
      fseek (f, 0, SEEK_END);
      length = ftell (f);
      fseek (f, 0, SEEK_SET);
      buffer = calloc(length+1, 1); //If i use malloc here, any file other than the first has garbage added to it. Why?
      if (buffer)
      {
        fread(buffer, 1, length, f);
      }
      fclose(f);
   }

   if(buffer)// && strlen(buffer) > 1)
   {
      int result = replaceString(buffer, find, replace, prefix);

      if(result == 0)
      {
         printf("Trying to replace prefix.\n");
         replace = concat(prefix, replace);
         result = replaceString(buffer, prefix, replace, "");
      }
      else
      {
         printf("Successfully replaced %s with %s\n", find, replace);
      }

      if(result == 1)
      {
         FILE* fp = fopen(filename, "w+");
         if(fp)
         {
             printf("Opened %s\n", filename);
             fprintf(fp, buffer);
             fclose(fp);
             printf("File %s overwritten with changes.\n", filename);
         }
      }
      else
      {
          printf("Nothing to replace for %s\n", filename);
      }
   }
   else
   {
     printf("Empty file.");
   }
   if(buffer)
   {
      free(buffer);
   }
}

int main(int argc, char **argv)
{

    if(argc < 4)
    {
      printf("Not enough arguments given: ./hw3 <find> <replace> <prefix>\n");
      return 1;
    }

    struct dirent *de;

    DIR *dr = opendir(".");

    if (dr == NULL)
    {
        printf("Could not open current directory\n");
        return 0;
    }

    while ((de = readdir(dr)) != NULL)
    {
       if(strlen(de->d_name) > 4 && !strcmp(de->d_name + strlen(de->d_name) - 4, ".txt"))
       {
            printf("Trying to replace for file %s\n", de->d_name);
            getAndReplace(de->d_name, argv[1], argv[2], argv[3]);
       }
    }

    closedir(dr);
    return 0;
}

Answer 1

我希望你concat函数

char concat(const char *s1, const char *s2);

这只是一个错字，你的意思是

char *concat(const char *s1, const char *s2);

否则该函数将返回一个指针，就好像它是一个char。

使用 valgrind 可以提供更多详细信息，明确您正在读/写的内容，以及您不允许的内容你在哪里泄漏内存。没有它就很难确定准确的地方。我注意到的一件事是，根据 find 和 replace 的长度，您可能没有足够的内存用于 tmpbuf 这会导致缓冲区溢出。

我认为编写 replaceString 的最佳方法是制作它分配它本身需要的内存，而不是为其提供一个要写入的缓冲区。因为您从用户处获得了 find 和 replace，所以您不知道生成的缓冲区需要有多大。你可以计算一下事先，但你不这样做。如果您想将预先分配的缓冲区传递给replaceString，我将它作为双指针传递，以便 replaceString 可以做到需要时对其进行realloc。或者在函数中分配内存并返回指向已分配内存的指针。

这将是我的版本:

char *replaceString(const char *haystack, const char *needle, const char *replace)
{
    if(haystack == NULL || needle == NULL || replace == NULL)
        return NULL;

    char *dest = NULL, *tmp;

    size_t needle_len = strlen(needle);
    size_t replace_len = strlen(replace);
    size_t curr_len = 0;

    while(*haystack)
    {
        char *found = strstr(haystack, needle);

        size_t copy_len1 = 0;
        size_t new_size = 0;
        size_t pre_found_len = 0;

        if(found == NULL)
        {
            copy_len1 = strlen(haystack) + 1;
            new_size = curr_len + copy_len1;
        } else {
            pre_found_len = found - haystack;
            copy_len1 = pre_found_len;
            new_size = curr_len + pre_found_len + replace_len + 1;
        }


        tmp = realloc(dest, new_size);
        if(tmp == NULL)
        {
            free(dest);
            return NULL;
        }

        dest = tmp;

        strncpy(dest + curr_len, haystack, copy_len1);

        if(found == NULL)
            return dest; // last replacement, copied to the end

        strncpy(dest + curr_len + pre_found_len, replace, replace_len + 1);
        curr_len += pre_found_len + replace_len;

        haystack += pre_found_len + needle_len;
    }

    return dest;
}

这个版本的想法与你的类似，但是我的将内存重新分配为一切顺利。我将参数的名称更改为与strstr 函数基于我的文档:

man strstr

char *strstr(const char *haystack, const char *needle);

因为我要更新 haystack 以指向复制的字符，所以我使用这个循环:

while(*haystack)
{
    ...
}

这意味着当到达'\0'终止字节时它将停止。

第一件事是使用strstr来定位与needle匹配的子字符串。根据是否找到子字符串，我计算需要多少字节复制直到子字符串和缓冲区的新大小。之后我为缓冲区重新分配内存并复制所有内容，直到子字符串，然后追加替换，更新 curr_len 变量并更新haystack 指向子字符串后面的指针。

如果未找到子字符串，则无需进行更多替换。所以我们必须复制 haystack 指向的字符串并返回构造的字符串。这目标的新大小为 curr_len + strlen(haystack) + 1(+1因为我希望 strncpy 函数也复制 '\0' 终止字节)。它必须复制 strlen(haystack) + 1 字节。在第一个 strncpy 之后，函数返回dest。

如果找到了子字符串，那么我们必须复制所有内容，直到找到子字符串，追加替换并更新当前长度和 haystack 指针。首先我计算字符串直到找到子字符串并将其保存在pre_found_len。目的地的新大小将为curr_len + pre_found_len + Replace_len + 1(当前长度+长度字符串直到子字符串+替换的长度+1'\0'-终止字节)。现在第一个 strncpy 仅复制 pre_found_len字节。然后它复制替换。

现在你可以这样调用它:

int main(void)
{
    const char *orig = "Is this the real life? Is this just fantasy?";
    char *text = replaceString(orig, "a", "_A_");
    if(text)
    {
        puts(orig);
        puts(text);
    }

    free(text);
}

将输出:

Is this the real life? Is this just fantasy?
Is this the re_A_l life? Is this just f_A_nt_A_sy?

现在您可以在getAndReplace中使用此函数来替换前缀:

char *getAndReplace(char* filename, char* find, char* replace, char* prefix)
{
    ...

    char *rep1 = replaceString(buffer, find, replace);

    if(rep1 == NULL)
    {
        // error
        free(buffer);
        return NULL;
    }

    char *prefix_rep = malloc(strlen(replace) + strlen(prefix) + 1);
    if(prefix_rep == NULL)
    {
        // error
        free(buffer);
        free(rep1);
        return NULL;
    }

    sprintf(prefix_rep, "%s%s", replace, prefix);

    char *rep2 = replaceString(rep1, prefix, prefix_rep);

    if(rep2 == NULL)
    {
        // error
        free(buffer);
        free(rep1);
        free(prefix_rep);
        return NULL;
    }

    // rep2 has all the replacements
    ...


    // before leaving
    free(buffer);
    free(rep1);
    free(prefix_rep);

    // returning all replacements
    return rep2;
}

当使用malloc & co时，不要忘记检查它们是否返回NULL并且不返回不需要时忘记释放内存。