Los errores principales son dos:

* Utilizas el puntero "saludo" sin inicializar:

char* saludo;
 
/* ... */
 
gets(saludo);

Debes reservar un bloque de memoria, almacenar la dirección de este en esa variable y solo entonces la utilizas (sin validaciones):

char *saludo;
 
/* ... */
 
saludo = malloc(100);
puts("Texto:");
gets(saludo);

* La función strncpy copia como máximo el numero de caracteres indicado pero, si copia el máximo, no agrega el '\0'. Bien verificas el numero de caracteres de antemano (lo cual pone fuera de lugar el uso de esa función) o agregas el '\0' de forma manual. Por lo anterior es mejor utilizar sprintf, de esta forma:

char *copySaludo = malloc(n + 1);
sprintf(copySaludo, "%.*s", n, saludo);
printf("Las %d primeras letras: \"%s\"\n", n, copySaludo);

----

Ademas de eso hay otras cosas que, sin ser errores, deberías cambiar en el programa como eliminar el uso de "sizeof(char)" (este siempre es igual a uno) y cambiar el uso de gets por fgets. Mas información en la pagina |Lo que no hay que hacer en C/C++. Nivel basico|.

Un saludo

Gracias por sus respuestas.

Reconozco mi error grave de declarar un puntero sin inicializar, tenia un concepcion de querer hacerlo dinamico para la lectura de cadenas, veo que eso es altamente complejo.

Por que si declaro

char* saludo = malloc(100);

Es en si esquivalente ah:

char saludo[100]

Aunque desconozco si el declarar char, vayan al heap; caso que sucede con el malloc.

Ahora si quisiera usar fgets, tendria que saber de antemano cuanto caracteres voy a ingresar (lo digo por el segundo argumento "int length"), cosa que no se acomoda a mis intenciones.

Aceptar tambien que usar gets, era de muy pero muy mala practica acabo de observar que en los man-pages de la terminal gnu/linux, lo clasifican de obsoleto en el standard 2011.

Con respecto a esta linea de codigo:

malloc((strlen(saludo) + 1) * sizeof(char))

tengo un habito de calcular los arreglo y de ahi multiplicarlos por su tipo de dato, si este cambia a int, float y lo tengo ya ganado.
Pero estoy para aprender nuevos y buenos habitos, no se si estoy haciendo bien con el anterior malloc.

lo del strncpy, podria agregar una linea:

copysaludo[n] = '\0';

Pero muy elegante lo del sprintf, una linea y cumple el proposito.

Aprendiendo C, a paso de tortuga, jeje..

Saludos!

Claro si defino una constante de un tamaño maximo y no sobrepase ese tamaño funcionara correctamente, de lo contrario esto resultaria en un crash, digamos asi:

char* saludo = malloc(10);
/*...*/
printf("Texto: ");
fgets(saludo, 10, stdin);
/*...*/

Al hacer pruebas obtenemos crash, si hago lo siguiente:
texto: hello, hi!

el texto "hello, hi!", tiene 10 en longitud faltando un '\0' para terminar la cadena, me provoca el crash. Es por eso que citaba "es bastante complejo leer cadenas" si se quiere hacer dinamicamente. y funciona correctamente si leo menores a 10 de longitud.

Saludos!

Exacto, cuando la cadena es: 'hello, hi'

Este tendra 9 en longitud, y fgets se encargara de ponerle el '\0' al final, para cumplir con el maximo tamaño permitido, evitando caer en crash y si no me equivoco esto es lo que llaman buffer overflows.

Decia 'complejo' para poder obtener una cadena al menos de una forma segura, y de forma dinamica. Esto es debido por que estuve revisando una funcion que forma parte de un codigo que oculta todo estos detalles, expongo:

string GetString(void)
{
    // growable buffer for chars
    string buffer = NULL;
 
    // capacity of buffer
    unsigned int capacity = 0;
 
    // number of chars actually in buffer
    unsigned int n = 0;
 
    // character read or EOF
    int c;
 
    // iteratively get chars from standard input
    while ((c = fgetc(stdin)) != '\n' && c != EOF)
    {
        // grow buffer if necessary
        if (n + 1 > capacity)
        {
            // determine new capacity: start at 32 then double
            if (capacity == 0)
            {
                capacity = 32;
            }
            else if (capacity <= (UINT_MAX / 2))
            {
                capacity *= 2;
            }
            else
            {
                free(buffer);
                return NULL;
            }
 
            // extend buffer's capacity
            string temp = realloc(buffer, capacity * sizeof(char));
            if (temp == NULL)
            {
                free(buffer);
                return NULL;
            }
            buffer = temp;
        }
 
        // append current character to buffer
        buffer[n++] = c;
    }
 
    // return NULL if user provided no input
    if (n == 0 && c == EOF)
    {
        return NULL;
    }
 
    // minimize buffer
    string minimal = malloc((n + 1) * sizeof(char));
    strncpy(minimal, buffer, n);
    free(buffer);
 
    // terminate string
    minimal[n] = '\0';
 
    // return string
    return minimal;
}

Anotar que el tipo de dato 'string', esta previamente definido en una libreria aparte como:

typedef char* string;

Aunque en este ultimo codigo no entiendo la linea:

string temp = realloc(buffer, capacity * sizeof(char));

Por que si buffer comenzo con NULL, al llegar a esta linea como que asignara NULL para temp, y esto a mi entender como que terminaria el programa 

Saludos!