La cosa es que planteas el problema, muestras lo que tienes realizado hasta el momento y especificas dónde te has quedado trabado.
La gente te va a resolver dudas puntuales, no a hacer la tarea. 

Muy buenas.

Para resolver tu problema lo que podrías hacer es leer el archivo línea a línea con fgets y, sobre la cadena adquirida, usar la función strtok con el separador + para recoger cada subcadena.

Muy buenas.

Pues bien, hay varias cosas que te fallan en el código, a saber:

1. Llamas a la función con los argumentos a, b, c y d; pero dentro de ella les das unos valores nuevos que, por otra parte, son locales de la función, no podrás saber que has guardado fuera de ella. Por tanto:
1.1. Llama a la función sin argumentos y declaras dentro de ella las cuatro variables. O
1.2. Haz que los argumentos sean punteros o referencias, entonces los valores que les des dentro de la función serán los que verás en esas mismas variables cuándo ésta regrese.

2. Dentro de la función la lógica está mal planteada: después de pedir las variables hay una cadena que pide al usuario que vuelva a introducir los datos, estén estos bien o no. Eso debería formar parte de la parte del tratamiento de error. Puedes:
2.1. Usar un if para saber si los datos introducidos son correctos, lo que tienes dentro de while. Si falla pon n2 e informa al usuario de que ha habido un fallo. Dentro del while mira si n2==0 para repetir el bucle en caso afirmativo.

3. Regresas un dato con n2 al término de la función pero, contrariamente a tu planteamiento, a juzgar por el código de main, n2 no regresa los cuatro números sino que siempre te retornará 0. Por otra parte una vez que has hecho que una función devuelva el control con return todo código que haya escrito después de esta instrucción es código que no se va a ejecutar. Puedes:
3.1. Hacer que la instrucción no devuelva nada y, junto a lo dicho en el punto 1.2. la función main recibirá los resultados en la variables usadas como argumentos de llamada. O
3.2. Hacer que la función devuelva un puntero a entero y llamarla sin argumentos. Mediante la memoria dinámica creas un array que llenarás con los cuatro números y eso será lo que devolverá la función. En main recogerás ese puntero a una variable puntero local.

No es mucha cosa, solo un divertimento; pero sirve para ver en qué parte de la memoria pone el S.O. las funciones, las variables locales, las globales y las dinámicas.
Así se puede ver como el sistema separa la memoria de código, la memoria de pila (stack) y la memoria del montón (heap).

#include <stdio.h>
#include <stdlib.h>
 
char gc;
int gi;
 
int main(int argc, char *argv[])
{
	char c;
	int i;
	int *p = malloc(sizeof(int));	
	printf("printf\t= %p\n", &printf);
	printf("malloc\t= %p\n", &malloc);
	printf("main\t= %p\n", &main);
	printf("\n");
	printf("gi\t= %p\n", &gi);
	printf("gc\t= %p\n", &gc);
	printf("\n");
	printf("argv\t= %p\n", &argv);
	printf("argc\t= %p\n", &argc);
	printf("\n");
	printf("c\t= %p\n", &c);
	printf("i\t= %p\n", &i);
	printf("p\t= %p\n", &p);
	printf("\n");
	for(i = 0; i < argc; ++i)
		printf("argv[%i]\t= %p -- %s$\n", i, argv[i], argv[i]);
	printf("\n");
	printf("p (->)\t= %p\n", p);
	free(p);
	return 0;
}

P. ej.:

$ ./c 1 12 123 1234 12345
printf   = 0x4004f0
malloc   = 0x400520
main   = 0x40061d

gi   = 0x60105c
gc   = 0x601060

argv   = 0x7ffd71212400
argc   = 0x7ffd7121240c

c   = 0x7ffd71212413
i   = 0x7ffd71212414
p   = 0x7ffd71212418

argv[0]   = 0x7ffd71214551 -- ./c$
argv[1]   = 0x7ffd71214555 -- 1$
argv[2]   = 0x7ffd71214557 -- 12$
argv[3]   = 0x7ffd7121455a -- 123$
argv[4]   = 0x7ffd7121455e -- 1234$
argv[5]   = 0x7ffd71214563 -- 12345$

p (->)   = 0x1e36010

En la libreria ctype hay una macro que te viene muy bien:

int isdigit(int c)

devuelve un valor distinto de 0 si c es un número decimal.

Con ella repasas los caracteres de la cadena y si hay alguno que no sea un número lanzas un mensaje de error.

Cuándo se usa la función malloc, por ejemplo, y una llamada básica podría ser algo así:

int *p = malloc(sizeof(int) * 5);

Y ahora viene la parte curiosa y mi planteamiento:

int arr[5] es un array de enteros.
int (*p)[5] es un puntero a un array de 5 enteros.
Lo único que tienen en común los dos son el tipo de dato, int, y el tamaño del array, 5. El nombre que le demos no tiene imporancia. Si se obvia dicho nombre nos debería dar un tamaño pero sin declarar nada.

Por tanto el código antes escrito podría codificarse de una forma un poco más intuitiva:

int *p = malloc( sizeof(int[5]) );

Y funciona, al menos con GCC.

>>> Editado porqué estas líneas no tienen un sentido práctico <<<

También funciona:

int *p = malloc( sizeof(int[5][5]) );

y

int **p = malloc( sizeof(int[5][5]) );

>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<

¿Qué os parece?

Tal vez te falta dereferenciar el puntero:
int a = *(int*)numero;

Sí. Si quieres comparar el valor introducido con todos los anteriores deberás rellenar un array con cada iteración.

Utiliza otra variable que a final del bucle adquiera el valor que has entrado. Así en la nueva iteración podrás comparar el valor anterior con el actual.

Prueba con esto:

#include <stdio.h>
#include <string.h>
 
int main() {
   char nombre[20];
   char apellidos[40];
   int edad;
 
   printf("Nombre: ");
   fgets(nombre, 19, stdin);
   *strchr(nombre, '\n') = '\0';
   printf("Apellidos: ");
   fgets(apellidos, 39, stdin);
   *strchr(apellidos, '\n') = '\0'; 
   printf("Edad: ");
   scanf("%i", &edad);
 
   if (edad >= 18 && edad <= 22) {
      printf("Hola %s %s", nombre, apellidos);
   }
   else {
      printf("No cumples los requisitos");
   }
 
   return 0;
}
 

Con fgets lees toda la cadena de entrada hasta pulsar ENTER y recoge hasta un máximo de caracteres que le has informado como último parámetro de la función.
Cómo también lee el carácter de nueva línea debes convertirlo en carácter nulo, y eso es lo que hace la línea donde se encuentra la función strchr.