当 dest 小于 src 但又足够大以容纳 src 所需的子字符串时,为什么 strncpy() 会产生垃圾?

问题描述 投票:0回答:3

我尝试使用 strncpy() 来限制复制到 dest(此处为 str1)的 n 字节数。 dest 对于 n 个字节来说足够大,但是当 dest 小于源时,输出会产生垃圾(此处为 argv[1])。 当我使 dest 足够大以容纳源时,这看起来有所不同。

这是代码:

#include <stdio.h>                                                              
#include <string.h>                                                             
                                                                                
int main(int argc, char *argv[])                                                
{                                                                               
/* // Works when str1[?] is 20:                                                                    
  char str1[20];                                                                
  char str2[20]; */                                                             
                                                                                
  // produces garbage, str1 is smaller than argv[1] but big enough for the 4 bytes copied                                                            
  char str1[10];                                                                
  char str2[10];                                                                
                                                                                
  printf("argc = %i\n", argc);                                                  
  if (argc <= 1 || argc > 2){                                                   
    printf("Input Example:\n"                                                   
           "  %s SEGMENT:OFFSET\n"                                              
           "  %s 0100:F00A\n", argv[0], argv[0]);                               
    return 0;                                                                   
  }                                                                             
  printf("strlen(argv[1]) = %li, argv[1] = %s\n"                                
          , strlen(argv[1]), argv[1]);                                          
                                                                                
  // str1                                                                       
  strncpy(str1, argv[1], 4); // copying 4 bytes to str1                                                   
  printf("Copy only 4 Bytes -> sizeof(str1) = %li, "                            
         "strlen(str1) = %li, str1 = %s\n", sizeof(str1), strlen(str1), str1);  
                                                                                
  // str2                                                                       
  strncpy(str2, argv[1], 3); // copying 3 bytes to str2                                                   
  printf("Copy only 3 Bytes -> sizeof(str2) = %li, "                            
         "strlen(str2) = %li, str2 = %s\n", sizeof(str2), strlen(str2), str2);  
                                                                                
  return 0;                                                                     
}                      

输入 0100:F00A 产生:

./test.bin 0100:F00A
argc = 2
strlen(argv[1]) = 9, argv[1] = 0100:F00A
Copy only 4 Bytes -> sizeof(str1) = 10, strlen(str1) = 8, str1 = 0100�U
Copy only 3 Bytes -> sizeof(str2) = 10, strlen(str2) = 3, str2 = 010

预期只是str1 = 0100

我也想知道为什么str2是正确的,它的初始数组大小与str1一样小。

当我改变时

char str1[10] 

char str1[20]

这样做使其大于 argv[1] 的输入,则输出是正确的:

./test.bin 0100:F00A
argc = 2
strlen(argv[1]) = 9, argv[1] = 0100:F00A
Copy only 4 Bytes -> sizeof(str1) = 20, strlen(str1) = 4, str1 = 0100
Copy only 3 Bytes -> sizeof(str2) = 20, strlen(str2) = 3, str2 = 010

看起来 strncpy 首先将所有内容复制到 dest,然后删除后面的其余内容。但这就是 strncpy 的工作方式吗? 我假设它只是复制需要的内容,即 4 个字节。

c string strcpy strncpy
3个回答
5
投票

来自手册页 https://linux.die.net/man/3/strncpy

strncpy()函数类似,只不过最多复制src的n个字节。警告:如果 src 的前 n 个字节中没有空字节,则放置在 dest 中的字符串将不会以空终止。

即在您的情况下,dest中没有放置空值


3
投票

来自

strncpy()
的 GLIBC 手册页:

警告:如果

n
的前
src
字节中没有空字节,则放置在
dest
中的字符串将不会以空结尾。

您正在观察效果。


1
投票

无论它的价值如何,我尝试在我的电脑(Windows/GCC 10.3.0)上按原样编译和运行你的程序......并且,表面上,它“看起来不错”。我没有看到你描述的文物。

这个例子说明了正在发生的事情:

#include <stdio.h>                                                              
#include <string.h>                                                             
                                                                                
int main(int argc, char *argv[])                                                
{ 
  char *s;
  char test1[] = "AAAAAAAA";                                                                             
  char test2[] = "AAAAAAAA";                                                                             

  printf("BEFORE: strlen(test1)=%lli, sizeof(test1)=%lli, test1=%s...\n",
    strlen(test1), sizeof(test1), test1);

  strncpy(test1, "BBBB", 4);
  printf("AFTER: strlen(test1)=%lli, sizeof(test1)=%lli, test1=%s...\n",
    strlen(test1), sizeof(test1), test1);

  strncpy(test2, "BBBB", 6);
  printf("AFTER: strlen(test2)=%lli, sizeof(test2)=%lli, test2=%s...\n",
    strlen(test2), sizeof(test2), test2);

  return 0;
}

  - gcc -o x -g -Wall -pedantic x.c
x.c:37:3: warning: 'strncpy' output truncated before terminating nul copying 4 bytes from a string of the same length [-Wstringop-truncation]
   37 |   strncpy(test1, "BBBB", 4);
      |   ^~~~~~~~~~~~~~~~~~~~~~~~~

  - x 0100:F00A
segment=0100, strlen(segment)=4; offset=F00A, strlen(offset)=4
BEFORE: strlen(test1)=8, sizeof(test1)=9, test1=AAAAAAAA...
AFTER: strlen(test1)=8, sizeof(test1)=9, test1=BBBBAAAA...
AFTER: strlen(test2)=4, sizeof(test2)=9, test2=BBBB...

附加说明:

  • 某些系统(BSD、Solaris 等)提供 strlcpy()

    它最多将 size-1 字节复制到目标,始终添加终止空字节,并且不会用(更多)空字节填充目标。

  • 将命令行解析为“段”和偏移量的另一种方法可能是使用 strtok():

    ...
    if (argc != 2) {                                                   
      printf("USAGE: enter SEGMENT:OFFSET, e.g. \"0100:F00A\"\n");                               
      return 1;                                                                   
    } 
    
    if ((strlen(argv[1]) != 9) || (strchr(argv[1], ':') == NULL)) {
      printf ("This doesn't look like a segment::offset!\n");
      return 1;
    }
    
    s = strtok(argv[1], ":");
    if (s == NULL){                                                   
      printf("Illegal entry: unable to parse %s\n", argv[1]);                               
    } 
    else {
      strcpy(segment, s);
      strcpy (offset, strtok(NULL, ":"));
      printf("segment=%s, strlen(segment)=%lli; offset=%s, strlen(offset)=%lli\n",
        segment, strlen(segment), offset, strlen(offset));
    }
    
© www.soinside.com 2019 - 2024. All rights reserved.