ANÁLISIS DE UN INTERFAZ DE RED

PRACTICA Nº 4 OBJETIVOS ANÁLISIS DE UN INTERFAZ DE RED Realizar una aplicación en C que capture tramas de una red Ethernet, y analizar su contenido, mostrándolo por pantalla y calculando al finalizar estadísticas del tráfico interceptado. Para desarrollar esta práctica se utilizará la librería C libpcap, que permite capturar tramas Ethernet de forma independiente al sistema operativo utilizado. Esta práctica se divide en dos partes: 1. Se plantea desarrollar un programa en C que acceda al interfaz de red del equipo y obtenga su dirección de red y su máscara de red. Esta parte está enfocada a servir como introducción al uso de la librería libpcap, que se utilizará para la realización de la segunda parte de la práctica. 2. La segunda parte consiste en la implementación de un analizador de red que active el modo promiscuo en la tarjeta de red de la estación de trabajo, y capture todas las tramas que circulan por la red local y muestre a continuación unas estadísticas de las tramas que ha capturado. DESARROLLO 1. PRIMERA PARTE La aplicación debe ser desarrollada en Lenguaje C, utilizando la librería libpcap para capturar tramas Ethernet. Consiste en el desarrollo de una aplicación que acceda al interfaz de red y muestre por pantalla el nombre del dispositivo de red que se va a analizar, su dirección IP y su máscara. No necesita que se le introduzcan parámetros al fichero ejecutable. 2. SEGUNDA PARTE La aplicación debe ser desarrollada en Lenguaje C, utilizando la librería libpcap para capturar tramas Ethernet. Para cada trama capturada, debe obtenerse la dirección Ethernet origen y destino, así como el tipo de paquete encapsulado. La información encapsulada en esos paquetes también debe ser extraída: paquetes IP, ARP, RARP, etc. En cada uno de ellos deberá extraerse la información oportuna: direcciones IP origen y destino, en el caso de IP, y el contenido de las peticiones / respuestas ARP y RARP. Página 1 de 16

Toda esta información debe ser visualizada por la salida estándar. Por ejemplo: Wed Mar 24 21:49:07 2001 [IEEE 802.3] Dirección origen: 00:00:f1:34:23:12 Dirección destino: ff:ff:ff:ff:ff:ff Longitud: 60 bytes Wed Mar 24 21:49:08 2001 [ETHERNET] Direccion origen: 00:00:f1:34:23:11 Direccion destino: ff:ff:ff:ff:ff:ff Longitud: 60 bytes Tipo: 0x0806 (ARP) [ARP] Tipo direccion hardware: 0x0001 Tipo direccion protocolo: 0x0800 Longitud direccion hardware: 06 bytes Longitud direccion protocolo: 04 bytes Codigo operacion: 01 (Petici_on) Direccion Ethernet emisor: 00:00:f1:34:23:11 Direccion IP emisor: 157.88.128.1 Direccion Ethernet objetivo: 00:00:00:00:00:00 Direccion IP objetivo: 157.88.128.3 Wed Mar 24 21:49:09 2001 [ETHERNET] Direccion origen: 00:00:f1:34:23:11 Direccion destino: ff:ff:ff:ff:ff:ff Longitud: 68 bytes Tipo: 0x0800 (IP) [IP] Direccion origen: 157.88.128.1 Direccion destino: 157.88.128.5 Tipo: 06 (TCP) [TCP] Puerto origen: 2048 Puerto destino: 80 Figura 1: Formato de tramas IEEE 802.3 Página 2 de 16

Requisitos: Escuela Politécnica Superior de Elche El programa tendrá como parámetro obligatorio de llamada el número máximo de tramas que capturará antes de finalizar. Si este parámetro es 0, el programa se ejecutará indefinidamente hasta que sea interrumpido por el usuario al pulsar ctrl-c. Esta combinación de teclas hace que el sistema operativo envíe la señal de interrupción SIGINT que deberá ser capturada por el programa para que analice la captura y se impriman los datos estadísticos finales (antes de terminar el programa). Para cada trama recibida, debe obtenerse el instante de captura (fecha y hora), la dirección origen y destino, la longitud en bytes (formato numérico decimal) así como el tipo de paquete encapsulado, en formato numérico hexadecimal, para el caso de trama Ethernet (los códigos correspondientes a los tipos de paquetes se encuentran en el Anexo I). Sólo será necesario expresar el tipo de paquete en formato texto (además del numérico hexadecimal) para los tipos más comunes: IP, ARP y RARP. Las direcciones Ethernet deberán presentarse como 6 grupos de 2 dígitos hexadecimales separados por : (ejemplo 00:03:0E:12:EF:EE). En el caso de que el tipo de paquete encapsulado sea ARP, deberán extraerse todos los campos. El formato de los paquetes ARP puede verse en la Figura 2. Las direcciones IP deberán presentarse como 4 grupos de números decimales comprendidos entre 0 y 255 separados por '. (ejemplo 157.88.128.15). En el caso de que el tipo de paquete encapsulado sea IP, deberán extraerse las direcciones IP origen y destino, y el protocolo encapsulado3 (en formato decimal). El formato de los paquetes IP (cabecera) puede verse en la Figura 3. En el caso de que el paquete IP transporte un segmento TCP o UDP, deberán extraerse los números de puerto origen y destino (formato numérico decimal). El formato de los segmentos TCP y UDP puede verse en las Figuras 4 y 5. Figura 2: Formato de paquetes ARP Página 3 de 16

Figura 3: Formato de la cabecera de un paquete IP Figura 4: Formato de la cabecera de un segmento TCP Figura 5: Formato de la cabecera de un segmento UCP Página 4 de 16

La captura de tramas finalizará cuando el usuario presione Ctrl-C o cuando se alcance el número máximo de tramas especificado en la llamada del sistema. El programa capturará la señal de fin de ejecución, y antes de finalizar mostrará en pantalla unas estadísticas que contengan, al menos: Número total de tramas Ethernet capturadas, especificando el número de paquetes IP, paquetes ARP y el de otros tipos y sus porcentajes respecto al total de tramas. Número de paquetes TCP, UDP y otros encapsulados dentro de los paquetes IP y sus porcentajes respecto al número total de paquetes IP. Desglosar la información anterior por cada par de direcciones IP origen y destino. Toda esta información deberá mostrarse por la salida estándar con el formato presentado en el siguiente ejemplo: Número total de tramas recibidas: 10 Número total de tramas descartadas: 0 Número total de paquetes IP: 8 (80%) Número total de paquetes ARP: 2 (20%) Resto de paquetes: 0 (0%) Número total de paquetes TCP: 6 (75%) Número total de paquetes UDP: 2 (25%) Resto de paquetes: 0 (0%) [157.88.128.1] <-> [157.88.128.3] Número de paquetes TCP: 4 (80%) Número de paquetes UDP: 1 (20%) Resto de paquetes: 0 [157.88.128.3] <-> [157.88.128.5] Número de paquetes TCP: 2 (66'66%) Número de paquetes UDP: 1 (33'33%) Resto de paquetes: 0 Tras la impresión de estas estadísticas el programa terminará. 3. COMPILACIÓN DE PROGRAMAS El modo promiscuo es un flag software de la tarjeta de red que, si se activa, provoca que la tarjeta capture de la red todos las tramas, sin preocuparse de quien es el destinatario de la misma. Normalmente este flag está desactivado, y el sistema operativo sólo recibe las tramas cuya dirección Ethernet destino es la suya. En los sistemas Unix, únicamente el usuario root tiene permisos para activar el modo promiscuo. Dado que la aplicación que se va a desarrollar debe obtener permisos especiales para poder acceder a la tarjeta de red será necesario compilarlo de forma especial. Para ello se utilizará el comando mkpcap. La forma de utilización es la siguiente; mkpcap fichero_ejecutable fichero_fuente_1 fichero fuente_2... Aviso importante: el programa mkpcap registra las acciones del usuario. Cualquier intento de violar la seguridad del sistema conllevará el suspenso automático de la asignatura Página 5 de 16

4. Libpcap: LIBRERÍA DE CAPTURA DE TRAMAS Libpcap es una librería con primitivas para la captura de tramas Ethernet independiente del sistema operativo. Permite desarrollar aplicaciones de monitorización de red, seguridad, etc fácilmente portables a diferentes sistemas Unix. En el Anexo II de este documento puede encontrarse la página de manual que describe las funciones disponibles en libpcap. Para poder utilizar las funciones debemos incluir el siguiente fichero de cabecera en nuestro código C: #include "pcap.h" /* Fichero de Cabecera de LIBPCAP */ Las funciones más interesantes se describen a continuación (ver Anexo II para una descripción completa del interfaz de llamada): pcap_lookupdev Devuelve un descriptor que apunta al primer dispositivo de red del sistema. Ese descriptor deberá ser utilizado en la llamada a otras funciones de la librería. Ejemplo: char *dispositivo = NULL; char buffer_error[pcap_errbuf_size]; [...] dispositivo = pcap_lookupdev(buffer_error); pcap_open_live Devuelve un descriptor de tipo pcap, necesario para la captura de las tramas. Admite varios parámetros, entre ellos es necesario pasarle el descriptor de dispositivo obtenido de la salida de pcap_lookupdev. Ejemplo: pcap_t *descriptor; int snaplen = DEFAULT_SNAPLEN; [...] descriptor = pcap_open_live (dispositivo, snaplen,0,1000,buffer_error); pcap_open_offline Devuelve un descriptor de tipo pcap, necesario para la captura de las tramas. Permite utilizar como origen de datos un fichero de capturas (por ejemplo, generado con tcpdump). Puede ser útil también para depurar el programa con gdb, al no tener que acceder a un dispositivo de red real. pcap_loop Función principal de libpcap. Toma el control del programa realizando un bucle e invocando a la rutina que indique el programador cada vez que captura una trama. Ejemplo: pcap_loop(descriptor, -1, ether_print,(u_char *)0) Página 6 de 16

5. ANÁLISIS DEL TRÁFICO CAPTURADO Una vez desarrollado y depurado el programa, deberán realizarse una serie de capturas de tramas y analizar el tráfico obtenido. Para realizar cada una de las capturas, se arrancará el programa de captura de tramas redirigiendo la salida hacia un fichero. Por ejemplo captura_tramas > trafico. Puede limitarse el número total de paquetes capturados si se considera necesario. Mientras se realiza la captura, se ejecutarán algunos programas que generen tráfico en la red y se realizarán operaciones con ellos. En concreto, deberán realizarse pruebas con los siguientes (una o varias capturas por cada programa): telnet ftp un programa que transfiera datos entre dos máquinas sin necesidad de establecer una conexión TCP, por ejemplo tftp (consultar la página de manual de este programa para ver las opciones). Intentar recibir un fichero mediante este programa (no importa que se produzcan errores). Repetir las capturas anteriores con distintas máquinas (locales de la universidad y remotas, aunque no respondan a los programas). 6. NORMAS PARA EL DESARROLLO DE LA PRÁCTICA Será necesario entregar una memoria detallada por parejas o de forma individual, explicando su diseño, desarrollo y ejecución. Un ejemplo de la tabla de contenidos del documento puede ser: 1. Introducción. 2. Diseño de la aplicación. 1. Módulo X: xxx.h y xxx.c 2. Módulo Y: yyy.h e yyy.c 3. [...] 3. Utilización de la aplicación (Forma de Ejecución) 4. Ejemplos de capturas y de estadísticas ofrecidas. 5. Explicación de problemas encontrados durante el desarrollo y su solución. 6. Anexo enumerando las mejoras optativas introducidas en la práctica, explicando por qué se ha elegido esas mejoras y no otras, y estimando el esfuerzo de desarrollo de las mismas. 7. Fecha de entrega y revisión La entrega y revisión de la práctica se realizará los días 22 y 23 de Abril. Cada alumno entregará y revisará la práctica de forma individual en el turno de prácticas que le corresponda durante esa semana, los alumnos pertenecientes al turno B se repartirán de la siguiente manera: Los apellidos que empiezan con letra < M Turno del grupo A Los apellidos que empiezan con letra >= M Turno del grupo C Página 7 de 16

Anexo I Tipos correspondientes a los protocolos encapsulados de una trama Ethernet La información de esta sección ha sido extraída del RFC 1370. Los tipos que aparecerán normalmente son el 0x0800 (IP), 0x0806 (ARP) y 0x8035 (RARP) Ethernet Type field Description ---------------------- ----------- decimal Hex 000 0000-05DC IEEE802.3 Length Field 257 0101-01FF Experimental 512 0200 XEROX PUP (see 0A00) 513 0201 PUP Addr Trans (see 0A01) 1536 0600 XEROX NS IDP 2048 0800 DOD IP 2049 0801 X.75 Internet 2050 0802 NBS Internet 2051 0803 ECMA Internet 2052 0804 Chaosnet 2053 0805 X.25 Level 3 2054 0806 ARP 2055 0807 XNS Compatability 2076 081C Symbolics Private 2184 0888-088A Xyplex 2304 0900 Ungermann-Bass net debugr 2560 0A00 Xerox IEEE802.3 PUP 2561 0A01 PUP Addr Trans 2989 0BAD Banyan Systems 4096 1000 Berkeley Trailer nego 4097 1001-100F Berkeley Trailer encap/ip 5632 1600 Valid Systems 16962 4242 PCS Basic Block Protocol 21000 5208 BBN Simnet 24576 6000 DEC Unassigned (Exp.) 24577 6001 DEC MOP Dump/Load 24578 6002 DEC MOP Remote Console 24579 6003 DEC DECNET Phase IV Route 24580 6004 DEC LAT 24581 6005 DEC Diagnostic Protocol 24582 6006 DEC Customer Protocol 24583 6007 DEC LAVC, SCA 24584 6008-6009 DEC Unassigned 24586 6010-6014 3Com Corporation 28672 7000 Ungermann-Bass download 28674 7002 Ungermann-Bass dia/loop 28704 7020-7029 LRT 28720 7030 Proteon 28724 7034 Cabletron 32771 8003 Cronus VLN 32772 8004 Cronus Direct 32773 8005 HP Probe 32774 8006 Nestar Página 8 de 16

32776 8008 AT&T 32784 8010 Excelan 32787 8013 SGI diagnostics 32788 8014 SGI network games 32789 8015 SGI reserved 32790 8016 SGI bounce server 32793 8019 Apollo Computers 32815 802E Tymshare 32816 802F Tigan, Inc. 32821 8035 Reverse ARP 32822 8036 Aeonic Systems 32824 8038 DEC LANBridge 32825 8039-803C DEC Unassigned 32829 803D DEC Ethernet Encryption 32830 803E DEC Unassigned 32831 803F DEC LAN Traffic Monitor 32832 8040-8042 DEC Unassigned 32836 8044 Planning Research Corp. 32838 8046 AT&T 32839 8047 AT&T 32841 8049 ExperData 32859 805B Stanford V Kernel exp. 32860 805C Stanford V Kernel prod. 32861 805D Evans & Sutherland 32864 8060 Little Machines 32866 8062 Counterpoint Computers 32869 8065-8066 Univ. of Mass. @ Amherst 32871 8067 Veeco Integrated Auto. 32872 8068 General Dynamics 32873 8069 AT&T 32874 806A Autophon 32876 806C ComDesign 32877 806D Computgraphic Corp. 32878 806E-8077 Landmark Graphics Corp. 32890 807A Matra 32891 807B Dansk Data Elektronik 32892 807C Merit Internodal 32893 807D-807F Vitalink Communications 32896 8080 Vitalink TransLAN III 32897 8081-8083 Counterpoint Computers 32923 809B Appletalk 32924 809C-809E Datability 32927 809F Spider Systems Ltd. 32931 80A3 Nixdorf Computers 32932 80A4-80B3 Siemens Gammasonics Inc. 32960 80C0-80C3 DCA Data Exchange Cluster 32966 80C6 Pacer Software 32967 80C7 Applitek Corporation 32968 80C8-80CC Intergraph Corporation 32973 80CD-80CE Harris Corporation 32974 80CF-80D2 Taylor Instrument 32979 80D3-80D4 Rosemount Corporation 32981 80D5 IBM SNA Service on Ether 32989 80DD Varian Associates Página 9 de 16

32990 80DE-80DF Integrated Solutions TRFS 32992 80E0-80E3 Allen-Bradley 32996 80E4-80F0 Datability 33010 80F2 Retix 33011 80F3 AppleTalk AARP (Kinetics) 33012 80F4-80F5 Kinetics 33015 80F7 Apollo Computer 33023 80FF-8103 Wellfleet Communications 33031 8107-8109 Symbolics Private 33072 8130 Waterloo Microsystems 33073 8131 VG Laboratory Systems 33079 8137-8138 Novell, Inc. 33081 8139-813D KTI 33100 814C SNMP 36864 9000 Loopback 36865 9001 3Com(Bridge) XNS Sys Mgmt 36866 9002 3Com(Bridge) TCP-IP Sys 36867 9003 3Com(Bridge) loop detect 65280 FF00 BBN VITAL-LanBridge cache Anexo II Página de manual de Libpcap PCAP(3) PCAP(3) NAME pcap - Packet Capture library SYNOPSIS #include <pcap.h> pcap_t *pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf) pcap_t *pcap_open_offline(char *fname, char *ebuf) pcap_dumper_t *pcap_dump_open(pcap_t *p, char *fname) char errbuf[pcap_errbuf_size]; char *pcap_lookupdev(char *errbuf) int pcap_lookupnet(char *device, bpf_u_int32 *netp, bpf_u_int32 *maskp, char *errbuf) int pcap_dispatch(pcap_t *p, int cnt, pcap_handler callback, u_char *user) int pcap_loop(pcap_t *p, int cnt, pcap_handler callback, u_char *user) void pcap_dump(u_char *user, struct pcap_pkthdr *h, u_char *sp) int pcap_compile(pcap_t *p, struct bpf_program *fp, char *str, int optimize, bpf_u_int32 netmask) int pcap_setfilter(pcap_t *p, struct bpf_program *fp) Página 10 de 16

u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h) int pcap_datalink(pcap_t *p) int pcap_snapshot(pcap_t *p) int pcap_is_swapped(pcap_t *p) int pcap_major_version(pcap_t *p) int pcap_minor_version(pcap_t *p) int pcap_stats(pcap_t *p, struct pcap_stat *ps) FILE *pcap_file(pcap_t *p) int pcap_fileno(pcap_t *p) void pcap_perror(pcap_t *p, char *prefix) char *pcap_geterr(pcap_t *p) char *pcap_strerror(int error) void pcap_close(pcap_t *p) void pcap_dump_close(pcap_dumper_t *p) DESCRIPTION The Packet Capture library provides a high level interface to packet capture systems. All packets on the network, even those destined for other hosts, are accessible through this mechanism. ROUTINES pcap_open_live() is used to obtain a packet capture descriptor to look at packets on the network. device is a 18 October 1997 1 PCAP(3) PCAP(3) string that specifies the network device to open. snaplen specifies the maximum number of bytes to capture. promisc specifies if the interface is to be put into promiscuous mode. (Note that even if this parameter is false, the interface could well be in promiscuous mode for some other reason.) to_ms specifies the read timeout in millisec onds. ebuf is used to return error text and is only set when pcap_open_live() fails and returns NULL. pcap_open_offline() is called to open a ``savefile'' for reading. fname specifies the name of the file to open. The file has the same format as those used by tcpdump(1) and tcpslice(1). The name "-" in a synonym for stdin. ebuf is used to return error text and is only set when pcap_open_offline() fails and returns NULL. Página 11 de 16

pcap_dump_open() is called to open a ``savefile'' for pcap_dump_open() is called to open a ``savefile'' for writing. The name "-" in a synonym for stdout. NULL is returned on failure. p is a pcap struct as returned by pcap_open_offline() or pcap_open_live(). fname specifies the name of the file to open. If NULL is returned, pcap_geterr() can be used to get the error text. pcap_lookupdev() returns a pointer to a network device suitable for use with pcap_open_live() and pcap_lookup net(). If there is an error, NULL is returned and errbuf is filled in with with an appropriate error message. pcap_lookupnet() is used to determine the network number and mask associated with the network device device. Both netp and maskp are bpf_u_int32 pointers. A return of -1 indicates an error in which case errbuf is filled in with with an appropriate error message. pcap_dispatch() is used to collect and process packets. cnt specifies the maximum number of packets to process before returning. A cnt of -1 processes all the packets received in one buffer. A cnt of 0 processes all packets until an error occurs, EOF is reached, or the read times until an error occurs, EOF is reached, or the read times out (when doing live reads and a non-zero read timeout is specified). callback specifies a routine to be called with three arguments: a u_char pointer which is passed in from pcap_dispatch(), a pointer to the pcap_pkthdr struct (which precede the actual network headers and data), and a u_char pointer to the packet data. The number of packets read is returned. Zero is returned when EOF is reached in a ``savefile.'' A return of -1 indicates an error in which case pcap_perror() or pcap_geterr() may be used to display the error text. pcap_dump() outputs a packet to the ``savefile'' opened with pcap_dump_open(). Note that its calling arguments are suitable for use with pcap_dispatch(). 18 October 1997 2 PCAP(3) PCAP(3) pcap_compile() is used to compile the string str into a filter program. program is a pointer to a bpf_program struct and is filled in by pcap_compile(). optimize con trols whether optimization on the resulting code is per Página 12 de 16

formed. netmask specifies the netmask of the local net. pcap_setfilter() is used to specify a filter program. fp is a pointer to an array of bpf_program struct, usually the result of a call to pcap_compile(). -1 is returned on failure; 0 is returned on success. pcap_loop() is similar to pcap_dispatch() except it keeps reading packets until cnt packets are processed or an error occurs. It does not return when live read timeouts occur. Rather, specifying a non-zero read timeout to pcap_open_live() and then calling pcap_dispatch() allows the reception and processing of any packets that arrive the reception and processing of any packets that arrive when the timeout occurs. A negative cnt causes pcap_loop() to loop forever (or at least until an error occurs). pcap_next() returns a u_char pointer to the next packet. pcap_datalink() returns the link layer type, e.g. DLT_EN10MB. pcap_snapshot() returns the snapshot length specified when pcap_open_live was called. pcap_is_swapped() returns true if the current ``savefile'' uses a different byte order than the current system. pcap_major_version() returns the major number of the ver sion of the pcap used to write the savefile. pcap_minor_version() returns the major number of the ver sion of the pcap used to write the savefile. pcap_file() returns the name of the ``savefile.'' int pcap_stats() returns 0 and fills in a pcap_stat struct. The values represent packet statistics from the start of the run to the time of the call. If there is an error or the under lying packet capture doesn't support packet statistics, -1 is returned and the error text can be obtained with pcap_perror() or pcap_geterr(). pcap_fileno() returns the file descriptor number of the ``savefile.'' pcap_perror() prints the text of the last pcap library error on stderr, prefixed by prefix. pcap_geterr() returns the error text pertaining to the Página 13 de 16

18 October 1997 3 PCAP(3) PCAP(3) last pcap library error. pcap_strerror() is provided in case strerror(1) isn't available. pcap_close() closes the files associated with p and deal locates resources. pcap_dump_close() closes the ``savefile.'' SEE ALSO tcpdump(1), tcpslice(1) AUTHORS Van Jacobson, Craig Leres and Steven McCanne, all of the Lawrence Berkeley National Laboratory, University of Cali fornia, Berkeley, CA. The current version is available via anonymous ftp: ftp://ftp.ee.lbl.gov/libpcap.tar.z BUGS Please send bug reports to libpcap@ee.lbl.gov. Anexo III Tipos de datos usados por Libpcap typedef struct pcap pcap_t; /* Each packet in the dump file is prepended with this generic header. * This gets around the problem of different headers for different * packet interfaces. */ struct pcap_pkthdr { struct timeval ts; /* time stamp */ bpf_u_int32 caplen; /* length of portion present */ bpf_u_int32 len; /* length this packet (off wire) */ }; /* As returned by the pcap_stats() */ struct pcap_stat { u_int ps_recv; /* number of packets received */ u_int ps_drop; /* number of packets dropped */ u_int ps_ifdrop; /* drops by interface XXX not yet supported */ Página 14 de 16

AYUDAS Función pcap_loop (para obtener el instante de tiempo): Para obtener el instante de tiempo en la rutina (callback) que se llama a partir de PCAP_LOOP, debéis buscarlo en el segundo parámetro (pkthdr) de la siguiente forma (mediante la función ctime): pcap_loop(descr,numpackets,callback,args); callback(u_char *args, const struct pcap_pkthdr* pkthdr, const u_char* packet) { printf("\n%s",ctime(&((*pkthdr).ts.tv_sec))); } Más información en: http://publib16.boulder.ibm.com/pseries/en_us/libs/basetrf1/pcap_loop.htm #a05520ksq Función signal: Para recoger el CTRL+C durante la ejecución de la parte b de la práctica 4, es necesario utilizar la librería <signal.h>, de forma que antes de abrir el interfaz de red, preparéis el programa para recibir un CRTL+C, por ejemplo con: signal(sigint, escape) Y definiendo la función escape como; void escape (int sig) /*aquí se llega después del control-c*/ { /*Lógicamente no devuelve nada.*/ printf("\nhe recibido Ctrl-C\n"); pcap_close(descr); fprintf(stdout,"\nfinalizado\n"); exit(1); } Listas enlazadas: http://www.elrincondelc.com/cursoc/cursoc22.html http://www.infor.uva.es/~benja/practica2.html http://www.hci.uniovi.es/martindocencia/dstool/listpage.htm Página 15 de 16

Función inet_ntoa: Para la primera parte de esta práctica, os puede ser de utilidad la función inet_ntoa, la cual convierte un valor decimal de 32 bits en el formato decimal punto (como cadena de caracteres) en el que normalmente se expresan las direcciones IP. La definición de la función y los tipos de datos que utiliza es la siguiente: #include <netinet/in.h> #include <arpa/inet.h> char *inet_ntoa(inaddr) struct in_addr inaddr; struct in_addr { u_long s_addr; }; Un ejemplo de su utilización: #include <sys/socket.h> #include <netinet/in.h> int main() { bpf_u_int32 dir_ip, mascara; /* dirección ip y su mascara*/ struct in_addr direccion; /* obtenemos la dirección de red con las funciones pcap_lookupdev y pcap_lookupnet */ pcap_lookupdev ( ) ret = pcap_lookupnet(,&dir_ip,&mascara, ); /* ahora en las variables dir_ip y mascara tenemos un decimal que expresa la dirección de red y su correspondiente máscara, si imprimimos estas variables con prinf y formato %d, visualizaremos este número, pero como queremos que aparezca con formato decimal punto, usamos la función inet_ntoa: */ direccion.s_addr = dir_ip; red = inet_ntoa(direccion); /* Por tanto en la variable red ahora tendremos una cadena de caracteres que representa la dirección ip de red. En el caso de la máscara, los pasos a seguir son los mismos */ } [ ] Esto lo utilizaremos muy a menudo en la parte de sockets (últimas prácticas de la asignatura). Otra posibilidad es que creéis una función que pase un entero decimal a binario y separe los cuatro grupos de 8 bits de una dirección IP. Página 16 de 16