¿Cómo evitar que scanf cause un desbordamiento de búfer en C?

Yo uso este código:

while ( scanf("%s", buf) == 1 ){

¿Cuál sería la mejor manera de evitar un posible desbordamiento del búfer para que pueda pasar cadenas de longitudes aleatorias?

Sé que puedo limitar la cadena de entrada llamando, por ejemplo:

while ( scanf("%20s", buf) == 1 ){

Pero preferiría poder procesar cualquier entrada del usuario. ¿O no se puede hacer esto de manera segura usando scanf y debería usar fgets?

En su libro La práctica de la programación (que vale la pena leer), Kernighan y Pike discuten este problema y lo resuelven usando snprintf() para crear la cadena con el tamaño de búfer correcto para pasar a la scanf() familia de funciones. En efecto:

int scanner(const char *data, char *buffer, size_t buflen)
{
    char format[32];
    if (buflen == 0)
        return 0;
    snprintf(format, sizeof(format), "%%%ds", (int)(buflen-1));
    return sscanf(data, format, buffer);
}

Tenga en cuenta que esto todavía limita la entrada al tamaño proporcionado como ‘búfer’. Si necesita más espacio, debe realizar la asignación de memoria o utilizar una función de biblioteca no estándar que realice la asignación de memoria por usted.

Tenga en cuenta que la versión POSIX 2008 (2013) del scanf() familia de funciones admite un modificador de formato m (un carácter de asignación-asignación) para entradas de cadena (%s, %c, %[). Instead of taking a char * argument, it takes a char ** argument, and it allocates the necessary space for the value it reads:

char *buffer = 0;
if (sscanf(data, "%ms", &buffer) == 1)
{
    printf("String is: <<%s>>\n", buffer);
    free(buffer);
}

If the sscanf() function fails to satisfy all the conversion specifications, then all the memory it allocated for %ms-like conversions is freed before the function returns.

If you are using gcc, you can use the GNU-extension a specifier to have scanf() allocate memory for you to hold the input:

int main()
{
  char *str = NULL;

  scanf ("%as", &str);
  if (str) {
      printf("\"%s\"\n", str);
      free(str);
  }
  return 0;
}

Edit: As Jonathan pointed out, you should consult the scanf man pages as the specifier might be different (%m) and you might need to enable certain defines when compiling.

Most of the time a combination of fgets and sscanf does the job. The other thing would be to write your own parser, if the input is well formatted. Also note your second example needs a bit of modification to be used safely:

#define LENGTH          42
#define str(x)          # x
#define xstr(x)         str(x)

/* ... */ 
int nc = scanf("%"xstr(LENGTH)"[^\n]%*[^\n]", matriz); 

Lo anterior descarta el flujo de entrada hasta, pero sin incluir, la nueva línea (\n) personaje. Deberá agregar un getchar() para consumir esto. También verifique si llegó al final de la transmisión:

if (!feof(stdin)) { ...

y eso es todo.

usando directamente scanf(3) y sus variantes plantea una serie de problemas. Por lo general, los usuarios y los casos de uso no interactivos se definen en términos de líneas de entrada. Es raro ver un caso en el que, si no se encuentran suficientes objetos, más líneas resolverán el problema, pero ese es el modo predeterminado para scanf. (Si un usuario no sabía cómo ingresar un número en la primera línea, una segunda y una tercera línea probablemente no ayuden).

al menos si tu fgets(3) sabe cuántas líneas de entrada necesitará su programa, y ​​no tendrá ningún desbordamiento de búfer…

Limitar la longitud de la entrada es definitivamente más fácil. Podría aceptar una entrada arbitrariamente larga usando un bucle, leyendo un bit a la vez, reasignando espacio para la cadena según sea necesario…

Pero eso es mucho trabajo, por lo que la mayoría de los programadores de C simplemente cortan la entrada en una longitud arbitraria. Supongo que ya lo sabe, pero usar fgets() no le permitirá aceptar cantidades arbitrarias de texto; aún necesitará establecer un límite.

No es mucho trabajo hacer una función que asigne la memoria necesaria para su cadena. Esa es una pequeña función c que escribí hace algún tiempo, siempre la uso para leer cadenas.

Devolverá la cadena de lectura o si se produce un error de memoria NULL. Pero tenga en cuenta que debe liberar () su cadena y siempre verificar su valor de retorno.

#define BUFFER 32

char *readString()
{
    char *str = malloc(sizeof(char) * BUFFER), *err;
    int pos;
    for(pos = 0; str != NULL && (str[pos] = getchar()) != '\n'; pos++)
    {
        if(pos % BUFFER == BUFFER - 1)
        {
            if((err = realloc(str, sizeof(char) * (BUFFER + pos + 1))) == NULL)
                free(str);
            str = err;
        }
    }
    if(str != NULL)
        str[pos] = '\0';
    return str;
}