Hola.. soy nueva aqui.. la otra vez he puesto un nuevo tema y nadie me respondio..
asi que respondo con una pregunta..
tengo un trabajo de la facultad en donde me piden realizar un sniffer con llamadas al sistema, es esto loq me descoloca un poco, y la verdad no tengo mucha practica en el tema..tener modos de captura.. y los usuarios tienen que poder ingresar tipo de socket tcp o udp, y un puerto..
el main de lo que he hecho hasta ahora..
int main()
{ //desde ak
int MYPORT;
struct sockaddr_storage their_addr;
socklen_t addr_size;
struct addrinfo hints, *res;
int new_fd, data_size;
// Primero cargar la estructura de las direcciones con getaddrinfo():
memset(&hints, 0, sizeof hints); //poner en cero la estructura
hints.ai_family = AF_UNSPEC; // usa IPv4 o IPv6
hints.ai_socktype = SOCK_STREAM; //
hints.ai_flags = AI_PASSIVE; // para llenar el ip con localhost
//en null va llenar con localhost en myport uno que el usuario ingrese
getaddrinfo(NULL, MYPORT, &hints, &res);
// hacer el socket, bind y escuchar en el:
//crea un socket que sera el que monitorea los paquetes
//primer parametro indica que el socket es de red
//segundo parametro se puede indicar si es orientado a la conexion o no..
//tercer parametro indica el protocolo que queremos utilizar
sock_raw = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
//si es menor a cero no se puede crear el socket
if(sock_raw < 0)
{
printf("Error al crear el Socket\n");
return 1;
}
int rc = bind(sock_raw, res->ai_addr, res->ai_addrlen);
if(rc < 0)
{
printf("Error al conectar..\n");
return 1;
}
int escucha = listen(sock_raw, limit_time);
//si es menor a cero no se puede escuchar
if(escucha < 0)
{
printf("Error al realizar listen..\n");
return 1;
}
// aceptar conexiones entrantes:
addr_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &addr_size);
//si es menor a cero no se puede aceptar nuevas conexiones
if(new_fd < 0)
{
printf("Error al aceptar la conexion \n");
return 1;
}
//hasta ak
//se define un char buffer con una reserva en memoria de 65536
//el tamanho es debido a la cantidad max de informacion que puede manejar TCP
unsigned char *buffer = (unsigned char *)malloc(65536); //Its Big!
//log.txt nombre del fichero
//"w" : abrir un archivo para escritura, se crea si no existe o se sobreescribe si existe.
logfile=fopen("log.txt","w");
//si logfile devuelve nulo no se puede crear el archivo log
if(logfile==NULL) printf("No se pudo crear el archivo log");
printf("Iniciando...\n");
while(1)
{
/*Esta funcion recibe para el socket "sock_raw" una serie de datos que almacena en el array del parámetro buffer.
*El parámetro long_msj "65536" indica el tamaño del parámetro anterior. Una recepción normal de datos un 0.
*Esta función devuelve el número de bytes recibidos si todo ha ido bien, y SOCKET_ERROR si se ha producido un fallo al enviar.
*/
data_size = recv(int sock_raw, buffer, 65536, 0);
if(data_size <0 )
{
printf("Recv error , Fallo al recibir el paquete...\n");
return 1;
}
//Se procesa el paquete
//Se le envia lo recibido que esta almacenado en buffer y el tamnho de bytes recibidos
ProcessPacket(buffer , data_size);
}
close(sock_raw);
printf("Finalizado");
return 0;
}
si me pueden ayudar porfa, estoy yendo por buen camino...
