¿Qué diferencia hay entre *s++ y s++? Creo que en la primera incrementas la posición de la memoria en la que se encuentra *s, pero en la segunda no sé que haces.

¿Que os parece así?

int strssr(const char *arg /*Argumento que contiene los numeros*/,
             char *s /*Puntero a since */,
              char *t /*Puntero a to */,
               char lim /*Limite de separacion */)
{
   if(arg == NULL||s == NULL||t==NULL)
     return 1;
   char *str = (char *)arg;
   while(*str && (*s++ = *str) && !(*++str eq lim));
   while(*str && (*t++ = *++str));
}

Más resumido todo.

El compilador no me permite incrementar el puntero con str++. No sé si lo que me dices será en C++.
Y no sé, yo considero que así va bien. Lo pruebo con todas las posibilidades haciendo NULL todo y no devuelve violacion de segmento, para mí esto ya esta xd
El codigo ha quedado así:

int strssr(const char *arg /*Argumento que contiene los numeros*/,
             char *s /*Puntero a since */,
              char *t /*Puntero a to */,
               char lim /*Limite de separacion */)
{
   if(arg == NULL || s == NULL || t == NULL)
     return 1;
   char *str = (char *)arg;
   while(*str)
   {
     *s = *str++;
     if(*str == lim)
       break;
     *s++;
   }
   *str++;
   while(*str)
   {
     *t = *str++;
     *t++;
   }
return 0;
}

¿Alguna recomendación o mejora?

Gracias

Si no incremento *str++ la segunda cadena es :8080 en vez de 8080 y si llega a carácter nulo no entrará en el segundo while, es decir, que se queda con la primera cadena.

int strssr(const char *arg /*Argumento que contiene los numeros*/,
             char *s /*Puntero a since */,
              char *t /*Puntero a to */,
               char lim /*Limite de separacion */)
{
   if(s == NULL||t == NULL)
     return 1;
   char *str = (char *)arg;
   while(*str)
   {
     *s = *str++;
     if(*str == lim)
       break;
     *s++;
   }
   *str++;
   while(*str)
   {
     *t = *str++;
     *t++;
   }
return 0;
}

¿Así? Compruebo los argumentos, a excepción de lim, que es cosa del usuario, digo yo.

Si, ya he visto la función strtok, pero me parece más complicada de usar.

El while(*str) comprueba que str no sea '\0'.
Lo de uint8_t supongo que tienes razón, usaré un char.

Hola.

Resulta que he hecho una función que considero bastante útil para el uso popular:

void strssr(const char *arg /*Argumento que contiene los numeros*/,
             char *s /*Puntero a since */,
              char *t /*Puntero a to */,
               uint8_t lim /*Limite de separacion */)
{
   char *str = (char *)arg;
   while(*str)
   {
     *s = *str++;
     if(*str == lim)
       break;
     *s++;
   }
   *str++;
   while(*str)
   {
     *t = *str++;
     *t++;
   }
}

Consiste en separar un argumento en dos a partir de una señal definida en el cuatro argumento, por ejemplo:

int main()
{
   char *ip = (char *)calloc(16,sizeof(char));
   char *puerto = (char *)calloc(5,sizeof(char));
   strssr("192.168.1.1:8080", ip, puerto, ':');
   printf("%s\t%s\n", ip, puerto);
 return 0;
}

Me gustaría saber si hay alguien que regule todo esto de las bibliotecas en C. ¿Tal vez el opengroup.org?
Es por el bien de la comunidad jeje.

Gracias por las respuestas.

Una de todas esas formas de saberlo que te comentan es con cualquier programa, ya sea una backdoor o no, que te envíe la dirección privada de red.

Puedes usar crunch para generarte tus propios diccionarios.

Yo utilizo Kali Linux, principalmente porque contiene muchísimas herramientas preparadas para el hacking.
Tengo en una partición Debian, dedicado al uso personal, y Kali en otra para hacer el idiota un rato. Pero, personalmente, considero que no es necesaria una distribución como Kali. Con tener los programas necesarios y saber programar no necesitas ninguna distribución externa que esté guiada a la (in)seguridad informática.

Al menos en C, para hacer esto:

char *cadena = "Hola"; 

Antes debes reservar memoria con alguna función como malloc o calloc:

char *cadena = (char *)calloc(5,sizeof(char)); 
strcpy(cadena,"Hola"); 

Y por último con strcpy asignar a cadena una frase.

Para poder escanear a la víctima siendo ésta ajena a tu red debe de estar en el DMZ de su red. El DMZ es la Zona Desmilitarizada, lo que quiere decir que el router no deniega ningún acceso al ordenador seleccionado, es decir, está totalmente expuesto a internet. Debe estar en el DMZ o tener el NAT activado hacia algún puerto.
Si está usando Windows XP y tú metasploit, supongo que querrás usar el puerto 445. En ese caso la víctima debería tener el puerto 445 del NAT apuntando hacia su IP interna.

Debemos partir de la idea de que los routers deniegan todo acceso ilegítimo a la red, es decir, no autorizado por ningún ordenador. Así que respecto a tu pregunta, solo hay dos posibilidades de darle respuesta:
1- Que el ordenador esté en el DMZ o tenga el NAT activado.
2- Que tú estés en la misma red.

Para más cuestiones, estaremos encantados de resolver tus dudas. Si tienes más preguntas podemos hablar.