DISEÑO E IMPLEMENTACION DE UN ALGORITMO PARA LA CONFIGURACIÓN DE DOS

TECNOLOGÍAS DE ROUTERS, UTILIZANDO EL SOFTWARE DE ENRUTAMIENTO QUAGGA

JHON ALBERTO AGUIRRE ARDILA

GUSTAVO ADOLFO MARTÍN GONZÁLEZ

UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS

FACULTAD TECNOLÓGICA
INGENIERÍA EN TELECOMUNICACIONES
BOGOTÁ D.C.
2017

1
 DISEÑO E IMPLEMENTACION DE UN ALGORITMO PARA LA CONFIGURACIÓN DE DOS
TECNOLOGÍAS DE ROUTERS, UTILIZANDO EL SOFTWARE DE ENRUTAMIENTO QUAGGA

JHON ALBERTO AGUIRRE ARDILA

GUSTAVO ADOLFO MARTÍN GONZÁLEZ

DIRECTOR DE PROYECTO
ING. GUSTAVO ADOLFO HIGUERA CASTRO

Trabajo de grado para optar al título de profesional en Ingeniería en Telecomunicaciones

UNIVERSIDAD DISTRITAL FRANCISCO JOSÉ DE CALDAS

FACULTAD TECNOLÓGICA
INGENIERÍA EN TELECOMUNICACIONES
BOGOTÁ D.C.
2017

2
Agradecimientos

Durante el camino que emprendimos en nuestra alma mater, no solo adquirimos conocimiento,
sino que también nos formamos como personas integrales y agradecidas de hacer parte de
nuestra querida Universidad Francisco José de Caldas la cual nos acogió en su seno y que hoy nos
entrega a la sociedad como personas profesionales, capaces de integrarse al desarrollo del país
de una manera productiva.

Agradecemos a Dios, a nuestras familias, a los docentes, compañeros y amigos que de una u otra
manera aportaron a nuestra formación académica y crecimiento personal. Aunque se presentaron
dificultades, tuvimos la sabiduría para poderlas superar y lograr culminar el ciclo profesional.

Por último, agradecemos a nuestro director de tesis, el ingeniero Gustavo A. Higuera Castro, por
su apoyo y acompañamiento en el desarrollo de la presente monografía.

Jhon A. Aguirre Ardila

Gustavo A. Martín González

3
 HOJA DE ACEPTACIÓN

DISEÑO E IMPLEMENTACION DE UN ALGORITMO PARA LA CONFIGURACIÓN DE DOS

TECNOLOGÍAS DE ROUTERS, UTILIZANDO EL SOTWARE DE ENRUTAMIENTO QUAGGA.

Observaciones.

_________________________________________________________

_________________________________________________________

_________________________________________________________

_________________________________________________________

_________________________________________________________

_________________________________________________________

_______________________________
Ing. Gustavo Adolfo Higuera M. Sc.
Director del Proyecto

Fecha de presentación: 9 de agosto de 2017

4
 Tabla de contenido

HOJA DE ACEPTACIÓN ............................................................................................................ 4

1. ÍNDICE DE ILUSTRACIONES ........................................................................................... 9

2. ÍNDICE DE TABLAS .......................................................................................................... 11

3. RESUMEN ............................................................................................................................ 12

4. ABSTRACT .......................................................................................................................... 13

5. INTRODUCCIÓN ................................................................................................................ 14

6. OBJETIVOS ......................................................................................................................... 15

6.1. General ........................................................................................................................... 15

6.2. Específicos ...................................................................................................................... 15

7. ANTECEDENTES ............................................................................................................... 16

8. JUSTIFICACIÓN ................................................................................................................ 18

9. PROBLEMA O PREGUNTA DE INVESTIGACIÓN ..................................................... 18

10. MARCO TEÓRICO ......................................................................................................... 20

10.1. DEFINICIÓN DE RED DE DATOS ........................................................................ 20

10.2. PROTOCOLOS DE CONECTIVIDAD EN REDES ............................................. 20

10.3. PROTOCOLOS DE ENRUTAMIENTO ................................................................ 20

10.3.1. Protocolos Vector Distancia ............................................................................... 21

10.3.2. Protocolos estado de enlace ................................................................................ 22

5
 10.3.3. Enrutamiento estático ........................................................................................ 22

10.3.4. Enrutamiento dinámico ..................................................................................... 22

10.4. MODELO OSI ........................................................................................................... 23

10.5. ROUTER .................................................................................................................... 24

10.5.1. Router por software............................................................................................ 25

10.6. TABLA DE ENRUTAMIENTO............................................................................... 26

10.7. LINUX ......................................................................................................................... 27

10.8. UBUNTU ..................................................................................................................... 27

10.9. ZEBRA – QUAGGA ........................................................................................................ 28

10.9.1. Arquitectura del sistema .................................................................................... 28

10.10. GTK+ .......................................................................................................................... 29

10.11. GLADE ....................................................................................................................... 30

10.12. LENGUAGES DE PROGRAMACIÓN .................................................................. 31

10.12.1. Introducción ........................................................................................................ 31

10.12.2. Definición............................................................................................................. 31

10.13. CONCEPTO DE ALGORITMO.............................................................................. 31

10.13.1. Características de los algoritmos....................................................................... 32

10.14. PROGRAMACIÓN ESTRUCTURADA ................................................................. 32

10.14.1. Modelado del mundo real .................................................................................. 33

6
 10.15. PYTHON .................................................................................................................... 34

8.15.1. IDLE Y CONSOLA INTERACTIVA .................................................................... 35

8.15.2. PyGTK....................................................................................................................... 36

8.15.3. Módulo Pexpect ........................................................................................................ 37

10.16. INTERFAZ GRÁFICA DE USUARIO ................................................................... 37

10.16.1. Principios para el diseño de interfaces gráficas ............................................... 37

10.17. EL PROTOCOLO SSH ............................................................................................. 38

10.17.1. Características del protocolo SSH..................................................................... 38

10.18. LISTAS DE CONTROL DE ACCESO (ACL) ....................................................... 39

10.18.1. Propósito de las ACL .......................................................................................... 39

10.18.2. Tipos de ACL ...................................................................................................... 41

10.18.3. Máscara Wildcard .............................................................................................. 41

10.19. DHCP .......................................................................................................................... 43

10.20. TRADUCCIÓN DE DIRECCIONES DE RED PARA IPV4 NAT ....................... 43

10.20.1. Tipos de NAT ...................................................................................................... 44

11. METODOLOGÍA ............................................................................................................. 45

12. DESARROLLO DE LA PROPUESTA........................................................................... 46

12.1. HARDWARE UTILIZADO ..................................................................................... 46

12.2. SISTEMA OPERATIVO .......................................................................................... 47

7
 12.3. PAQUETES DE SOFTWARE.................................................................................. 48

12.3.1. Configuración de Quagga .................................................................................. 49

12.3.2. Interfaz quagga ................................................................................................... 50

12.4. IP FORWARDING .................................................................................................... 51

12.5. CONFIGURACIÓN INTERFAZ PC ENRUTADOR ............................................ 51

12.6. INSTALACIÓN DE GLADE Y GTK+.................................................................... 52

12.7. CONFIGURACIÓN SSH EN ROUTER CISCO.................................................... 52

12.8. TOPOLOGÍA DE PRUEBA ..................................................................................... 53

12.9. DISEÑO INTERFAZ................................................................................................. 54

13. ADMINISTRACION DE LA RED………………………………………………………67

14. ADMINISTRACION DE LA RED………………………………………………………73

15. USO DE LA PLATAFORMA .......................................................................................... 72

13.1. DESCRIPCIÓN.......................................................................................................... 72

13.2. FLUJO PRINCIPAL ................................................................................................. 72

13.2.1. Ejecución Interfaz ................................................................................................. 72

13.2.2. Ingreso de credenciales ........................................................................................ 72

13.2.3. Ingreso a usuario EXEC. ...................................................................................... 72

13.2.4. Revisar parámetros configurados ........................................................................ 72

13.2.5. Configuración de parámetros ............................................................................... 73

8
 13.2.6. Verificación pruebas............................................................................................. 73

13.3. FLUJOS ALTERNATIVOS ..................................................................................... 73

13.3.1. Usuario y contraseña errónea .............................................................................. 73

13.3.2. Configurar parámetros incompletos .................................................................... 73

13.4. USO DE LA PLATAFORMA.................................. ¡Error! Marcador no definido.

14. DIAGRAMA DE FLUJO ................................................................................................. 75

15. CONCLUSIONES ............................................................................................................. 77

16. BIBLIOGRAFÍA ............................................................................................................... 78

17.1. CÓDIGO DE LA APLICACIÓN ............................................................................. 81

1. ÍNDICE DE ILUSTRACIONES

Ilustración 1. Clasificación de los protocolos de enrutamiento ..................................................... 23

Ilustración 2. Capas del modelo OSI .............................................................................................. 24

Ilustración 3. Router Cisco y sus componentes principales ........................................................... 24

Ilustración 4. Componentes internos de una computadora ............................................................ 26

Ilustración 5. Ejemplo de interfaz Gráfica de Usuario diseñada con el software glade ................. 30

Ilustración 6. Resolución de un problema ...................................................................................... 32

Ilustración 7. Un programa procedimental ..................................................................................... 33

Ilustración 8. Entorno de Desarrollo Integrado de Python ............................................................. 35

9
Ilustración 9. Consola interactiva python ....................................................................................... 36

Ilustración 10. Ejemplo de filtrado de paquetes ............................................................................. 40

Ilustración 11. Numeración y denominación de las ACLs............................................................. 41

Ilustración 12. Máscara wildcard ................................................................................................... 42

Ilustración 13. Diagrama de flujo. Etapas de realización del proyecto .......................................... 45

Ilustración 14. Especificaciones placa base PC enrutador ............................................................. 46

Ilustración 15. Tarjeta de red adicional para el PC enrutador ........................................................ 46

Ilustración 16. Router cisco elegido para interactuar con el PC enrutador .................................... 47

Ilustración 17. Acceso a quagga y comandos principales .............................................................. 50

Ilustración 18. Modificación del archivo “sysctl.conf” para que el PC actúe como enrutador ..... 51

Ilustración 19. Topología en software de simulación Packet Tracer ............................................. 53

Ilustración 20. Ventana de acceso a la interfaz .............................................................................. 54

Ilustración 21. Ventana de acceso router Quagga .......................................................................... 54

Ilustración 22. Ventana de acceso incorrecto ................................................................................. 55

Ilustración 23. Pestaña Inicio. Configuración router quagga ......................................................... 55

Ilustración 24. Pestaña Configuración router quagga .................................................................... 56

Ilustración 25. Configuración protocolo RIP. Router Quagga ....................................................... 57

Ilustración 26. Configuración protocolo OSPF. Router Quagga ................................................... 57

Ilustración 27. Configuración enrutamiento estático. Router Quagga ........................................... 58

Ilustración 28. Configuración ACL estándar. Router Quagga ....................................................... 58

Ilustración 29. Configuración ACL extendida. Router Quagga ..................................................... 59

Ilustración 30. Pestaña conectividad. Router Quagga .................................................................... 59

Ilustración 31. Parámetros DHCP .................................................................................................. 60

10
Ilustración 32. Credenciales acceso cisco ...................................................................................... 60

Ilustración 33. Parámetros ACL’s Estándar. Router Cisco ............................................................ 61

Ilustración 34. Parámetros configuración ACL Extendida ............................................................ 61

Ilustración 35. Parámetros de configuración NAT......................................................................... 62

Ilustración 36. Topología Inmplementada ..................................................................................... 65

Ilustración 37. Equipo cilente. Prorama iperf (red quagga – cisco) ............................................... 66

Ilustración 38. Equipo cilente. Prorama iperf (red wifi Pc a PC)................................................... 67

Ilustración 39. Equipo cliente transmitiendo a máxima capacidad ................................................ 68

Ilustración 40. Estadisticas protocolo Netflow .............................................................................. 69

Ilustración 41. Acceso al servidor FTP .......................................................................................... 70

Ilustración 42. Lista de archivos PC servidor ................................................................................ 71

Ilustración 43. Archivo descargado por medio del servidor FTP .................................................. 71

Ilustración 44. Diagrama de casos de uso ...................................................................................... 74

Ilustración 45. Diagrama de flujo ................................................................................................... 76

2. ÍNDICE DE TABLAS

Tabla 1. Distancias administrativas usadas por los routers Cisco .................................................. 21

Tabla 2. Ejemplo de una máscara wildcard .................................................................................... 42

Tabla 3. Últimas versiones de ubuntu ............................................................................................ 47

Tabla 4. Requerimientos mínimos de las versiones LTS 14.04 y 16.04 de Ubuntu ...................... 48

11
 3. RESUMEN

El presente trabajo de grado consiste en la elaboración de una aplicación para escritorio,

implementada en el sistema operativo Ubuntu, por medio del lenguaje de programación Python
y el diseñador de interfaces Glade. El aplicativo opera como interfaz gráfica para que el usuario
pueda interactuar de una manera sencilla e intuitiva con los comandos de networking de Cisco
IOS y el software de enrutamiento quagga.

Inicialmente se estudiaron los comandos disponibles en ambas plataformas, se investigó como

utilizar un computador de escritorio como enrutador, se puso en marcha la topología de la red y
posteriormente se realizaron pruebas de conectividad para comprobar la comunicación entre
terminales. Seguidamente se diseñó el aspecto que tendría la interfaz y se generó el algoritmo
para poder realizar la programación de los parámetros de red de las dos plataformas de
enrutamiento desde el mismo aplicativo. La programación de los parámetros de enrutamiento se
realizó de manera centralizada, se tiene el aplicativo corriendo en el pc enrutador y desde allí se
realiza la conexión al router cisco por medio del protocolo ssh para garantizar la integridad del
tráfico de datos.

Lo que se busca con el uso de la aplicación es facilitar el aprendizaje y la asimilación de conceptos

de routing de manera gráfica, reducir el tiempo de programación ejecutando varios comandos
simultáneamente, no como la consola de comandos en la que hay que entrar y salir de la
configuración en repetidas ocasiones y por último guardar los cambios, proceso que se realiza
desde la interfaz desarrollada desde una sola ventana y que se puede verificar rápidamente.
También se quiere incentivar el uso de software libre y la interoperabilidad en redes, la
herramienta desarrollada está hecha de manera escalable por si se quieren agregar más
funcionalidades y mejoras.

12
 4. ABSTRACT

The present grade work consists in the elaboration of a application for desktop, implemented in
the operating system ubuntu, through the programming language Python and the interface
designer Glade. The application operates as a graphical interface so that the user can interact in
a simple and intuitive way with Cisco IOS networking commands and quagga routing software.

Initially we studied the commands available on both platforms, investigated how to use a desktop
computer as a router, started the network topology and subsequently performed connectivity
tests to verify communication between terminals. Next, the interface aspect was designed and
the algorithm was generated to be able to program the network parameters of the two routing
platforms from the same application. The programming of the routing parameters was done
centrally, you have the application running on the pc router and from there the connection to the
cisco router is made through the ssh protocol to ensure the integrity of data traffic.

What is sought with the use of the application is to facilitate learning and assimilation of routing
concepts graphically, reduce scheduling time by running multiple commands simultaneously, not
as the command console in which to enter and exit the configuration repeatedly and finally save
the changes, process that is done from the interface developed from a single window and can be
verified quickly. We also want to encourage the use of free software and interoperability in
networks, the tool developed is scalable in case you want to add more functionality and
improvements.

13
 5. INTRODUCCIÓN

Cuando se está aprendiendo a cerca de redes, una vez asimilados los conceptos hay que buscar
herramientas de software para darse una idea de cómo trabajan los dispositivos de networking
de manera conjunta, es allí donde aparecen los simuladores de redes como el “Cisco Packet
Tracer”, la cual es una buena alternativa, ya que permite al estudiante diseñar la topología de la
red y hacer la programación de los dispositivos de networking por medio del CLI (Cisco Command
Line) y/o por medio de una interfaz gráfica integrada en el software. Lo ideal sería que después
de esto se pudieran practicar los conceptos con enrutadores reales, lo que en algunos casos no
es posible, debido a la falta de laboratorios de routing, el alto costo de los equipos y el tiempo
que llevan estas prácticas entre otros motivos.

Esta situación es problemática, debido a que, al no interactuar con enrutadores reales, el

estudiante puede obviar aspectos básicos, como, por ejemplo: saber cuándo usar cables de red
directos o cruzados, verificar velocidad de los enlaces con los indicadores propios de los equipos,
detectar fallos físicos (puertos o cables defectuosos) entre otros. La presente propuesta tiene
como objetivo ayudar a reducir este problema desde varios focos:

 Mostrar como un computador de escritorio puede ser acoplado fácilmente para operar
como un enrutador (tanto a nivel de software como hardware).
 Demostrar como el uso de software libre es útil para aprender redes y como operar de
manera conjunta con enrutadores cisco.
 Entregar una aplicación que permita realizar programación de routers en modo gráfico
pero que al mismo tiempo muestre al usuario cómo se programan las órdenes como si
estuviera en la propia consola de comandos.
 Ofrecer una alternativa económica y versátil para facilitar el aprendizaje de redes

Una vez realizada la programación de los enrutadores, los usuarios pueden realizar las pruebas
que consideren pertinentes: por ejemplo, implementando un servidor FTP, utilizando
herramientas de análisis de tráfico, configurando los diferentes protocolos de enrutamiento para
así poder compararlos y obtener sus propias conclusiones.

14
 6. OBJETIVOS

6.1. General

Desarrollar un algoritmo para la configuración de dos tecnologías de routers, haciendo uso de

software de enrutamiento y creando una interfaz dinámica para minimizar redundancia de
código.

6.2. Específicos

 Conocer, interactuar y aplicar el software de enrutamiento propio de los dispositivos de

networking.

 Desarrollar la interfaz para simplificar la administración de la red, garantizando la

seguridad de los datos por medio del protocolo ssh.

 Evidenciar el funcionamiento y el transporte de paquetes a través de la red realizando

pruebas de comunicación entre terminales.

15
 7. ANTECEDENTES

Implementación de un router bajo Linux

Realizado por: José Vázquez Jerónimo
Universidad Veracruzana
Facultad de Ingeniería en Electrónica y Comunicaciones
País: México
Año: 2009
Este trabajo se basa en la implementación de un router básico, instalado y configurado en el
sistema operativo Linux (Distribución Ubuntu 9.04) así como el programa Quagga versión 0.99.11,
el cual es un software libre que funciona como enrutador en los sistemas operativos UNIX. En
esta implementación se realizan únicamente las configuraciones para el enrutamiento estático y
el protocolo de enrutamiento RIP (Protocolo de enrutamiento interior) así como las
configuraciones para casos prácticos donde se requiera un enrutador con estas características.

Diseño, implementación, administración y enrutamiento avanzado bajo el núcleo IOS CLI

Realizado por: Jesús Alberto Tejedor Doria
Universidad Politécnica de Valencia
Facultad de informática
País: España
Año: 2013
Este proyecto abarca el diseño, implementación y administración de una red de área local con
conexiones externas a nivel de campus, el cual se centra en los en el diseño de la red, recursos
que se necesitan para implementarla y su administración. Lo relevante de este proyecto llevado
al propuesto son las diferentes tecnologías de routers especificadas para el enrutamiento de la
red, las que dan directrices para los parámetros requeridos de programación y protocolos
soportados por los equipos registrados.

Desarrollo de una herramienta software de programación del router cisco 2600

Realizado por: Juan Asensio Sánchez
Universidad Politécnica de Cartagena
Departamento de Tecnologías de la Información y las Comunicaciones
País: Colombia
Año: 2004

16
El objetivo del proyecto es, previo estudio de las posibilidades de configuración de los routers
Cisco de la serie 2600, el desarrollo de un programa que permita realizar todas las tareas
relacionadas con la configuración de Servicios Diferenciados, además de opciones de
configuración básicas, en dicho equipo. Las herramientas de servicios diferenciados incluirán la
generación de listas de control de acceso, la creación de mapas de clases, adición y modificación
de mapas de políticas y, por último, la asociación de las anteriores políticas a las interfaces.

Implementación de protocolos de enrutamiento mediante un enrutador basado en software de

código abierto bajo Linux
Realizado por: Julio Alexander Ulloa Márquez
Escuela Politécnica Nacional
Facultad de ingeniería eléctrica y electrónica
País: Perú
Año: 2007
Este trabajo muestra la implementación de varios protocolos de enrutamiento (RIP, OSPF, BGP,
IGRP, EIGRP), utilizando herramientas de código abierto bajo el sistema operativo Linux. Se realiza
un análisis teórico del enrutamiento, de los sistemas operativos, herramientas de enrutamiento
y las herramientas de virtualización y simulación, para luego presentar una parte práctica donde
se puede observar la implementación y configuración del enrutador y su funcionamiento frente
a algunos escenarios.

implementación y configuración de un enrutador para la interconexión de la red de tecnología

avanzada rita-ud con la red metropolitana rumbo mediante software libre y el modelo tmn de
la uit-t
Realizado por: Carlos Andrés Martínez, Fabio Antonio González Mendieta, Dora Andrea
Antolínez Ladino
Universidad Distrital Francisco José De Caldas
País: Colombia
Año: 2011
Este trabajo plantea la implementación de un enrutador para la interconexión de una red LAN
académica con el nodo de RUMBO, sobre una máquina de mediano rendimiento, usando
software libre y empleando una adaptación del modelo TMN de la UIT-T para la gestión de este
elemento de red. Para el desarrollo de este proyecto se utiliza el software de enrutamiento Vyatta
en un equipo con arquitectura x.86

17
 8. JUSTIFICACIÓN

En un entorno cada vez más cambiante, tecnológicamente hablando; la tendencia a las redes
convergentes que se viene dando a nivel mundial es solo una premisa para darse una idea de la
gran cantidad de distribuidores de dispositivos de networking que existen y de su expansión de
productos por el mundo. No obstante, debe tenerse en cuenta que son proveedores
especializados como Cisco Systems o Juniper Networks, lo que conlleva a que sus productos no
sean compatibles entre sí, no fomentan el principio de interoperabilidad.

El objetivo del proyecto es entregar una herramienta ofimática que permita una interacción más
didáctica y menos específica para configurar dos tecnologías de routers, dar una alternativa
práctica para hacer uso de un pc como router y fomentar la interoperabilidad entre dispositivos
de networking.

Con la puesta en marcha del proyecto se espera que las personas que se adentran en el campo
de la administración de redes, cuenten con una herramienta que les ayude a comprender
parámetros de enrutamiento, coexistencia de tecnologías y que además les permita administrar
la red de una manera más sencilla al permitir enviar parámetros de configuración a través de la
misma.

9. PROBLEMA O PREGUNTA DE INVESTIGACIÓN

En un mundo cada vez más digital, la masificación de las tecnologías de la información y las
comunicaciones (TIC) es evidente y de vital importancia para mejorar el rendimiento de las
empresas, la comunicación tanto interna como externa en una entidad debe ser rápida, eficiente
y adaptable al cambio. En este sentido los dispositivos de networking juegan un papel importante;
la interacción con los mismos debe ser fluida por parte del administrador de la red, debe estar en
capacidad de realizar modificaciones en la infraestructura sin afectar la calidad de servicio de la
misma. En algunos casos esto conlleva limitaciones y/o dificultades en cuanto a disponibilidad de
equipos de red e integración con otras redes o equipos de diferentes fabricantes, debido a su
incompatibilidad.

18
La asimilación de los diferentes entornos de desarrollo por parte del administrador de red podría
no ser viable para las empresas en términos de tiempo y recursos, no se encuentran alternativas
fácilmente disponibles para suplir cambios o eventualidades en la red sin necesidad de adquirir
equipos nuevos, tampoco implementación de interfaces de programación que no incluyan
redundancia de código.

Problemas identificados a este tema son:

 En ocasiones los routers comerciales son robustos y podrían estar sobre dimensionados
para realizar procedimientos sencillos como un cambio de topología en una red.
 Los equipos de networking de los diferentes fabricantes no interactúan entre sí, se deben
buscar alternativas tecnológicas que permitan reducir esta brecha, para así fomentar la
interoperabilidad en redes.
 Algunos simuladores de redes como Cisco Packet Tracer permiten la programación de los
dispositivos por medio de interfaz gráfica e interfaz de comandos, esto facilita la
comprensión de la red, deben integrarse herramientas que sigan este principio para
facilitar la administración de la red.
 Configurar un router en topología centralizada puede ser una tarea ardua al utilizar
diferentes tecnologías de routers.
 En el ambiente empresarial no es común encontrar interacción entre equipos de cómputo
con diferentes sistemas operativos dentro de la misma red, lo que impide aprovechar las
ventajas y/o facilidades de cada uno de ellos.
 La variedad de sistemas operativos e interfaces de comandos de los routers pueden ser
difíciles de asimilar en corto tiempo, llevando a una labor menos eficiente al administrador
de la red.

19
 10. MARCO TEÓRICO

10.1. DEFINICIÓN DE RED DE DATOS

Una red puede definirse como una estructura en la que hay un orden establecido. De acuerdo
con (Pérez, 2014) puede hacer referencia a la interconexión de computadoras y otros dispositivos
que comparten recursos. Un dato podría definirse como conceptos, cifras e instrucciones que se
tienen aisladas entre sí, sin seguir un patrón u orden específico.

Se conoce como red de datos a la infraestructura cuyo diseño posibilita la transmisión de

información a través del intercambio de datos. Cada una de estas redes ha sido diseñada
específicamente para satisfacer sus objetivos, con una arquitectura determinada para
facilitar el intercambio de los contenidos. (Pérez, 2014)

10.2. PROTOCOLOS DE CONECTIVIDAD EN REDES

Un protocolo de red se puede definir como una serie de pasos determinados que se deben seguir
para establecer la comunicación entre los diferentes componentes de una red y finalmente llevar
a cabo la transmisión de los datos. Ejemplos de protocolos son expuestos por (Hallberg, 2007,
pág. 92), el protocolo de control de transmisión/ Protocolo Internet (TCP/IP) define un conjunto
de reglas que se utilizan en el envío de datos de un nodo a otro en la red, el Protocolo Simple de
Transferencia de Correo (SMTP) es un conjunto de reglas y estándares que se utilizan para la
transferencia de correo electrónico y archivos adjuntos de un nodo a otro.

10.3. PROTOCOLOS DE ENRUTAMIENTO

Los protocolos de enrutamiento son el conjunto de reglas utilizadas por un router cuando se
comunica con otros routers, con el fin de compartir información de enrutamiento. Dicha
información se usa para construir y mantener las tablas de enrutamiento.

Estos protocolos facilitan el proceso de enrutamiento, el cual consiste en que los routers se
envíen entre sí periódicamente información de las rutas, creando en cada uno de ellos unas
tablas de enrutamiento, para que en el momento que reciban un paquete de protocolo
enrutado contarán con la ruta dónde deben enviarlo. (Mier & Mier, 2008, pág. 21)
20
 10.3.1. Protocolos Vector Distancia

Los protocolos de routing de vector distancia envían datos actualizados de rutas periódicas a los
vecinos directamente conectados. Cada vez que se realiza un envío en temporizador se reinicia.
La métrica utilizada por estos protocolos es el “conteo de saltos” o routers encontrados en el
camino.

10.3.1.1. Distancia administrativa

La distancia administrativa es el conjunto de valores arbitrarios elegidos para las diferentes

fuentes de información. Es posible cambiar estos valores, pero con cuidado. (Collado, 2009,
pág. 72)

Tabla 1. Distancias administrativas usadas por los routers Cisco

10.3.1.2. Convergencia

La convergencia ocurre cuando todos los routers del dominio están de acuerdo a las rutas
que se encuentran disponibles.
El tiempo de convergencia es el tiempo que necesita cada router para sincronizar su tabla
de routing después de que se haya producido un cambio en la topología de la red. (Collado,
2009, pág. 85)

21
 10.3.2. Protocolos estado de enlace

Este tipo de protocolos generalmente se usan para mantener las tablas de routing con una alta
precisión y libres de bucles. Envían sus actualizaciones de forma incremental y mediante
multicast.

10.3.3. Enrutamiento estático

Cuando se tienen tablas de enrutamiento estáticas, hay que introducir la información de dichas
tablas de forma manual, ya que el router no puede adaptarse de manera automática a los cambios
que se puedan presentar en la topología de la red, Sin embargo, este método de enrutamiento
resulta ventajoso en las siguientes situaciones. (González, s.f, pág. 1)

 Existe una sola conexión con un solo ISP. En lugar de conocer todas las rutas globales, se
utiliza una única ruta estática.
 Un cliente no desea intercambiar información de enrutamiento dinámico.

10.3.4. Enrutamiento dinámico

Este tipo de protocolo va cambiando su tabla de enrutamiento acorde a los mensajes de

actualización del enrutamiento, que contienen información acerca de los cambios sufridos en la
red, y que indican al software del router que actualice la tabla de enrutamiento en consecuencia.
Intentar utilizar enrutamiento dinámico sobre situaciones que no lo requieren es una pérdida de
ancho de banda, esfuerzo y en consecuencia de dinero. (González, s.f, pág. 1)

22
 Ilustración 1. Clasificación de los protocolos de enrutamiento

10.4. MODELO OSI

El modelo de interconexión para sistemas abiertos (OSI) define todos los métodos y
protocolos necesarios para conectar una computadora a cualquier otra para formar una
red. El modelo OSI es un modelo conceptual que se utiliza con mucha frecuencia para diseñar
redes y elaborar la ingeniería de las soluciones de red. En general, el modelo OSI conforma
las redes en el mundo real, aunque existen diferencias entre la teoría que los sustenta y la
práctica real en la mayoría de las redes. Aun así, este modelo proporciona una forma
excelente para comprender y visualizar cómo se comunican las computadoras entre sí, y es
un conocimiento indispensable para cualquier persona que trabaje en el campo de la
conectividad de redes. (Hallberg, 2007, págs. 28 - 29)

El modelo OSI está conformado por 7 capas que definen las funciones de los protocolos de
comunicaciones.

23
 Ilustración 2. Capas del modelo OSI

10.5. ROUTER

Ilustración 3. Router Cisco y sus componentes principales

Los enrutadores son dispositivos de interconexión de redes o segmentos de redes que pueden
estar desarrollados tanto en software o en hardware, y cuyo objetivo es definir y establecer el
camino para que los datos lleguen desde su origen a su destino. Los enrutadores funcionan como
puntos intermedios en la red de datos, en donde se toman decisiones respecto a los caminos que
deben seguir los paquetes de información para llegar a su destino.
24
El router tiene varios componentes los cuales son:

 CPU: Ejecuta las instrucciones del sistema operativo, como el inicio del sistema, y las
funciones de enrutamiento y conmutación.
 RAM: Es la memoria de acceso aleatorio y se usa para guardar las tablas de enrutamiento,
se guarda la caché ARP y de conmutación rápida.
 Memoria Flash: Es un tipo de ROM programable. Se usa para almacenar una imagen del
sistema operativo.
 NVRAM: La memoria de acceso aleatorio no volátil se usa por lo general para guardar la
configuración de inicio.
 Buses: Los buses se usan en la comunicación entre la CPU y las interfaces y ranuras de
expansión.
 ROM: Memoria de solo lectura se usa para almacenar de forma permanente el código de
diagnóstico de inicio.
 Fuente de alimentación: Brinda alimentación de energía a los componentes internos.
 Interfaces: Son conexiones de los routers hacia el exterior y pueden ser de tres tipos LAN,
WAN y de Consola AUX.

10.5.1. Router por software

Es posible usar un PC común como enrutador, el rendimiento de la red puede estar sujeto al
hardware propio del computador, pero es una opción más que suficiente para redes locales o
redes con un tráfico limitado. Para utilizar un PC como enrutador se debe disponer de dos tarjetas
de red y activar el soporte de enrutamiento del kernel. Para ampliar las capacidades del enrutador
y que soporte diferentes protocolos de red, se pueden usar programas como (Quagga, Vyatta,
XORP, Zebra, etc). Con estos paquetes de software se pueden implementar routers y firewalls
(propios de capa 3) con una buena eficiencia, incluyendo la posibilidad de configurarlos vía web.
(Vázquez, 2009, pág. 46)

La computadora personal se basa típicamente en la Arquitectura Von Newman que

establece una CPU que es interconectada con una memoria única para programas y datos
a través de un bus. El esquema completo de la computadora junto con el software que
permite funciones de ruteo se muestra a continuación: (Vázquez, 2009, pág. 46)

25
 Ilustración 4. Componentes internos de una computadora

Como se puede observar en la Ilustración 4, los componentes internos de una computadora son
básicamente parecidos a los de un router, solo que este dispositivo realiza la función principal de
interconectar redes

10.6. TABLA DE ENRUTAMIENTO

La tabla de enrutamiento es un archivo que almacena direcciones de red y las interfaces que
alcanzan a dicha red. Indica si está conectada directamente conectada o que no está
directamente conectada.

El router tiene la capacidad de determinar la mejor ruta para un paquete, pero esto va a depender
del ancho de banda, de la saturación de la red, así como de la métrica.

Métrica: Permite conocer cuál es la mejor ruta para el destino.

Número de saltos: Es la cantidad de routers que se deben contar para llegar al destino.
Ancho de banda: Es la velocidad de transmisión de datos de una red.
Conmutación: Es pasar un paquete de una interfaz de red a otra para que llegue a su destino
(Ares, 1999, pág. 50)

26
 10.7. LINUX

Linux es un sistema operativo de distribución libre desarrollado inicialmente por Linus Torvalds
en 1991 en la universidad de Helsinki (Finlandia). Una comunidad de programadores expertos en
UNIX, han ayudado en el desarrollo, distribución y depuración de este sistema operativo. El
núcleo (Kernel) de Linux no contiene código desarrollado por AT&T ni por ninguna otra fuente
propietaria. La mayoría de software disponible en Linux ha sido desarrollado por el proyecto GNU
de la Free Software Fundation (FSF) de Cambridge (Massachusetts). Sin embargo, es toda una
comunidad de programadores la que ha contribuido al desarrollo de aplicaciones para este
sistema operativo. (Cuenca, 2012)

La combinación (o suma) del software GNU y kernel Linux, es lo que ha traído los actuales
sistemas GNU/Linux. Actualmente los movimientos Open Source, desde diferentes
organizaciones (como FSF) y empresas como las que generan diferentes distribuciones Linux
(Red Hat, Mandrake, SuSe…), pasando por grandes empresas como HP, IBM o Sun que
proporcionan apoyo, han dado un empujón muy grande a los sistemas GNU/Linux hasta
situarlos a nivel de poder competir, y superar, muchas de las soluciones propietarias
existentes. (Jorba & Suppi, 2004, pág. 13)

10.8. UBUNTU

Ubuntu es una distribución GNU/Linux basada en Debían GNU/Linux que proporciona un sistema
operativo actualizado y estable para el usuario medio, con un fuerte enfoque en la facilidad de
uso e instalación del sistema. Su eslogan es Linux for Human Beings (Linux para seres humanos) y
su nombre proviene de la ideología sudafricana Ubuntu («humanidad hacia otros»)

El 8 de julio de 2004, Mark Shuttleworth y la empresa Canonical Ltd. anunciaron la creación

de la distribución Ubuntu. Ésta tuvo una financiación inicial de 10 millones de dólares (US$).
El proyecto nació por iniciativa de algunos programadores de los proyectos Debían, Gnome
porque se encontraban decepcionados con la manera de operar del proyecto Debían,
la distribución Linux sin ánimo de lucro más popular del mundo. (Ubuntu ORG, 2011)

Cada seis meses se publica una nueva versión de Ubuntu la cual recibe soporte por parte de
Canonical, durante dieciocho meses, por medio de actualizaciones de seguridad, parches para
bugs críticos y actualizaciones menores de programas. Las versiones LTS (Long TermSupport),
que se liberan cada dos años, reciben soporte durante tres años en los sistemas de escritorio
y cinco para la edición orientada a servidores. (Guias_Ubuntu, 2011)
27
 10.9. ZEBRA – QUAGGA

El software de enrutamiento quagga es un proyecto Open Source que permite convertir un

servidor Linux en un Router. Este software es bastante antiguo, anteriormente se
llamaba Zebra, pero años más tarde el proyecto fracasó por falta de soporte. Luego, un equipo
de desarrolladores decidió seguir manteniendo el software y lo bautizaron como Quagga.

Utilizando Linux y Quagga combinación, el Linux Kernel realiza la función de IP Forwarding

mientras que Quagga realiza la función IP Dynamic Routing. Quagga permite implementar
y configurar los siguientes protocolos de enrutamiento:

RIPv1, RIPv2, OSPFv2, OSPFv3, IS-IS, OLSR, MPLS

Quagga permite la configuración de los protocolos de enrutamiento vía una

interface Command Line Interface (CLI) muy parecida al Cisco IOS. En la práctica podemos
configurar un servidor Linux como Router para luego intercambiar tablas de enrutamiento
con Cisco Router o cualquier otra marca de router. (Capacity, s.f.)

Quagga utiliza una arquitectura de software avanzada para proporcionar una gran calidad, con
un motor multi servidor de encaminamiento. Un sistema con quagga instalado actúa como un
router dedicado. Con Quagga una máquina intercambia información de routing de forma que
la información correcta esté en el lugar correcto. Quagga permite la configuración dinámica y
es posible ver la información de la tabla de routing desde la interfaz de terminal de quagga.
(Ishiguro, 2017)

10.9.1. Arquitectura del sistema

El software de enrutamiento tradicional se hace como un programa de un proceso que

proporciona todas las funcionalidades del protocolo de enrutamiento. Quagga adopta un
enfoque diferente. Está hecho de una colección de varios daemons que trabajan juntos para
construir la tabla de enrutamiento. Puede haber varios demonios de enrutamiento específicos
del protocolo y zebra el gestor de enrutamiento del kernel.

El demonio ‘ripd’ maneja el protocolo RIP, el demonio ‘ospfd’ soporta OSPF versión 2. El
demonio ‘bgpd’ soporta el protocolo BGP-4. Para cambiar la tabla de enrutamiento del
núcleo y para la redistribución de rutas entre diferentes protocolos de enrutamiento, hay
28
 un demonio ‘zebra’ del gestor de tablas de enrutamiento del kernel. Es fácil agregar un
nuevo demonio de protocolo de enrutamiento a todo el sistema de enrutamiento sin afectar
a ningún otro software. Sólo tiene que ejecutar el demonio de protocolo asociado con los
protocolos de enrutamiento en uso. Así, el usuario puede ejecutar un demonio específico y
enviar informes de enrutamiento a una consola de enrutamiento central. (Jakma, 2004)

10.10. GTK+

La biblioteca GTK+ se encarga de crear interfaces gráficas de usuario. Funciona en muchas

plataformas UNIX, Windows y OS X. GTK+ es liberado bajo la Licencia Pública General de GNU
(GNU LGPL), que permite la licencia flexible de aplicaciones de cliente. GTK + tiene una
arquitectura orientada a objetos basado en C que permite la máxima flexibilidad. Enlaces para
muchos otros idiomas se han escrito, incluyendo C ++, Objective-C, Guile / Scheme, Perl, Python,
TOM, Ada95, Free Pascal, y Eiffel. (GNOME_Developer, Part I GTK+ Overview, 2005 - 2014)

GTK + depende de las siguientes bibliotecas:

Glib: Una biblioteca de utilidad de uso general, no específica a las interfaces gráficas de
usuario. Glib proporciona muchos tipos útiles de datos, macros, conversiones de tipos,
utilidades de cadena, utilidades de archivo, una abstracción de bucle principal, y así
sucesivamente.
Gobject: Una biblioteca que proporciona un sistema de tipo, una colección de tipos
fundamentales incluyendo un tipo de objeto, un sistema de señal.
GIO: Un moderno y fácil de usar API VFS (Application Programming Interface – Virtual File
Service), incluidas las extracciones de archivos, drivers, volúmenes, stream IO, así como la
programación de la red y la comunicación Dbus.
Cairo: Cairo es una biblioteca de gráficos 2D con soporte para múltiples dispositivos de
salida.
Pango: Pango es una biblioteca para la manipulación de texto internacionalizado. Se centra
alrededor del objeto PangoLayout, lo que representa un párrafo de texto. Pango
proporciona el motor de GtkTextView, GtkLabel, GtkEntry, y otros widgets que muestran
texto.
ATK: ATK es un toolkit de accesibilidad. Proporciona un conjunto de interfaces genéricas
permitiendo tecnologías de accesibilidad para interactuar con una interfaz gráfica de
usuario.
GdkPixbuf: Se trata de una pequeña biblioteca que le permite crear GdkPixbuf (“buffer de
píxeles”) los objetos de datos de imágenes o archivos de imagen. Use un GdkPixbuf en
combinación con GtkImage para mostrar imágenes.
29
GDK: GDK es la capa de abstracción que permite GTK + para soportar múltiples sistemas de
ventanas. GDK proporciona instalaciones del sistema de ventanas en X11, Windows y OS X.
GTK +: La biblioteca GTK + sí mismo contiene los widgets, es decir, componentes de la GUI
tales como GtkButton o GtkTextView.
(GNOME_Developer, Part I GTK+ Overview, 2005 - 2014)

10.11. GLADE

El diseñador de interfaces Glade permite crear y editar diseños de interfaces gráficas de

usuario (IGU) para aplicaciones GTK+. Las bibliotecas GTK+ proporcionan una extensa
colección de bloques de construcción de Interfaz de usuario tales como cajas, etiquetas de
código, entradas numéricas, casillas de selección, y menús. Estos bloques de construcción se
llaman widgets. Se puede usar Glade para emplazar widgets en una IGU. Glade permite
modificar el esquema y propiedades de esos widgets. También se puede usar Glade para
añadir conexiones entre widgets y el código fuente de una aplicación.
(GNOME_Developer, Manual del diseñador de interfaces de ususario Glade, 2005 - 2014)

Ilustración 5. Ejemplo de interfaz Gráfica de Usuario diseñada con el software glade

30
 10.12. LENGUAGES DE PROGRAMACIÓN

10.12.1. Introducción

A comienzos de 1950 se desarrollaron los primeros lenguajes simbólicos nacidos de la

necesidad de recordar secuencias de programación para las acciones usuales. A estas
acciones se les denominó con nombres fáciles de memorizar y asociar: ADD (sumar), SUB
(restar), MUL (multiplicar), CALL (ejecutar subrutina), etc. A este conjunto de instrucciones
se le llamó “lenguaje ensamblador”.

A finales de los años cincuenta y comienzos de los sesenta se desarrollaron los primeros
lenguajes de alto nivel con su propio vocabulario más o menos limitado, su gramática más
o menos estricta y su semántica, que se asimilan relativamente al lenguaje humano. Estos
lenguajes se denominan de “alto nivel” porque para poder ser utilizados deben pasarse por
un traductor que los convierta a un lenguaje de nivel inferior (código máquina o
ensamblador). A este proceso se le llama “compilación” o “interpretación” y lo realiza,
curiosamente, otro programa. El código escrito por el programador es lo que se conoce
como “código fuente” y el código traducido es lo que se conoce como “código binario”.
(Guimi, 2008)

10.12.2. Definición

Se le llama lenguaje de programación a un conjunto de símbolos y reglas sintácticas y

semánticas que definen su estructura y el significado de sus elementos y expresiones, y es
utilizado para controlar el comportamiento físico y lógico de una máquina. (Guimi, 2008)

10.13. CONCEPTO DE ALGORITMO

Un algoritmo es un conjunto de líneas con una sintaxis específica que actúan de manera conjunta
para dar solución a un problema. Para desarrollar algoritmos eficientes se debe llevar procesos
de forma sistemática y rigurosa.

Un algoritmo es un método para resolver un problema. Aunque la popularización del

término ha llegado con el advenimiento de la era informática, algoritmo proviene de
Mohammed al-Khowârizmi, matemático persa que vivió durante el siglo IX y alcanzó gran

31
 reputación por el enunciado de las reglas paso a paso para sumar, restar, multiplicar y dividir
números decimales; la traducción al latín del apellido en la palabra algorismus derivó
posteriormente en algoritmo. (Joyanes & Zahonero, 1999)

Ilustración 6. Resolución de un problema

Los pasos para la resolución de un problema son:

1. Elaboración del algoritmo, que describe la secuencia ordenada de pasos que conducen a la
solución de un problema dado. (Análisis del problema y desarrollo del algoritmo.)
2. Expresar el algoritmo como un programa en un lenguaje de programación adecuado. (Fase de
codificación.)
3. Ejecución y validación del programa por la computadora.

10.13.1. Características de los algoritmos

Las características fundamentales que debe cumplir todo algoritmo son:

 Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.
 Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el
mismo resultado cada vez.
 Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en algún
momento; o sea, debe tener un número finito de pasos.

10.14. PROGRAMACIÓN ESTRUCTURADA

A medida que se fueron encontrando limitaciones y vacíos en los diferentes enfoques de

programación se desarrolló un esquema conocido como programación orientada a objetos. Es
decir, cada sentencia o instrucción señala al compilador para que realice alguna tarea: obtener
una entrada, producir una salida, sumar tres números, dividir por cinco, etc. En resumen, un
programa en un lenguaje procedimental es un conjunto de instrucciones o sentencias. En el caso
de pequeños programas, estos principios de organización (denominados paradigma) se

32
demuestran eficientes. El programador sólo tiene que crear esta lista de instrucciones en un
lenguaje de programación, compilar en la computadora y ésta, a su vez, ejecuta estas
instrucciones. (Joyanes & Zahonero, 1999)

Ilustración 7. Un programa procedimental

10.14.1. Modelado del mundo real

Otro inconveniente relacionado con la programación estructurada reside en el hecho de que la

disposición separada de datos y funciones no se corresponde con los modelos de las cosas del
mundo real. En el mundo físico se trata con objetos físicos tales como personas autos o aviones.
Estos objetos no son como los datos ni como las funciones. Los objetos complejos o no del mundo
real tienen atributos y comportamiento.

Los atributos o características de los objetos son, por ejemplo: en las personas, su edad, su
profesión, su domicilio, etc.; en un auto, la potencia, el número de matrícula, el precio, número
de puertas, etc; en una casa, la superficie, el precio, el año de construcción, la dirección, etc. En
realidad, los atributos del mundo real tienen su equivalente en los datos de un programa; tienen
un valor específico, tal como 200 metros cuadrados, 20.000 dólares, cinco puertas, etc.

El comportamiento es una acción que ejecutan los objetos del mundo real como respuesta a un
determinado estímulo. Si usted pisa los frenos en un auto, el coche (carro) se detiene; si acelera,
el auto aumenta su velocidad, etc. El comportamiento, en esencia, es como una función: se llama
a una función para hacer algo (visualizar la nómina de los empleados de una empresa).
Por estas razones, ni los datos ni las funciones, por sí mismas, modelan los objetos del mundo real
de un modo eficiente.

33
La programación estructurada mejora la claridad, fiabilidad y facilidad de mantenimiento de los
programas; sin embargo, para programas grandes o a gran escala, presentan retos de difícil
solución. (Joyanes & Zahonero, 1999)

10.15. PYTHON

Python fue creado a principios de los 90 por Guido van Rossum en el Stichting Mathematisch
Centrum en los Países Bajos como sucesor de un lenguaje llamado ABC y la necesidad del
autor por un analizador de sintaxis sencillo y fácil de aprender. Guido sigue siendo el
principal autor de Python, aunque incluye multitud de contribuciones de otros.
Después de crear el intérprete se comenzaron a agregar partes de código similares a las de
un compilador o máquina virtual lo que permitió en un momento crear un intérprete y lograr
programas en ejecución bajo Python.
Python, a pesar de iniciar como el proyecto de una sola persona, ha llevado un diseño y
lineamientos que lo han llevado a lo que hoy es. Entre los planes originales de diseño se
encontraban:
 Similitud con la Shell de UNIX, lo que permite un ambiente amigable, muy similar a la
terminal de UNIX, pero no un remplazo de la misma.
 Arquitectura Extensible. Es decir, una arquitectura en la que se puedan agregar cosas
nuevas, no todo es perfecto en un principio y Python debería ser capaz de cambiar de
acuerdo a las necesidades de los usuarios. Guido van Rossum describe como doloroso su
trabajo con otros lenguajes como ABC al tratar de implementar nuevos tipos de datos.
 Una herramienta en lugar de muchas. Python debería encajar bien en cualquier ambiente,
ser de uso múltiple, y por lo tanto ser un buen remplazo para muchas herramientas (y otros
lenguajes de programación). El alcanzar este objetivo requiere que Python sea altamente
portable.
 Se debe poder agregar funcionalidad de manera separada. Es decir, permitir a otros la
inclusión de características adicionales a Python sin la necesidad de compilar el intérprete
de nuevo.
 Factible, como para ser el proyecto de una sola persona. Al ser extensible permitió a Guido
concentrarse en las tareas más apremiantes mientras delegaba labores menos importantes
a otros.
 Principalmente, servir, para poder hacer el trabajo de cada día. (Islas, 2006, pág. 8)

34
Dentro de los lenguajes informáticos, Python pertenece al grupo de los lenguajes de
programación y puede ser clasificado como un lenguaje interpretado, de alto nivel,
multiplataforma, de tipado dinámico y multiparadigma. A diferencia de la mayoría de los
lenguajes de programación, Python provee reglas de estilos, a fin de poder escribir código fuente
más legible y de manera estandarizada. Estas reglas de estilo, son definidas a través de la Python
Enhacement Proposal N° 8 (PEP8). (Islas, 2006)

8.15.1. IDLE Y CONSOLA INTERACTIVA

La instalación de Python incluye un IDLE (Integrated DeveLopment Environment), un pequeño

entorno de desarrollo escrito en el mismo lenguaje utilizando Tkinter que resulta muy práctico
para realizar los primeros scripts en el proceso de aprendizaje. Incluye resaltado de sintaxis y las
operaciones comunes de un IDE.

Ilustración 8. Entorno de Desarrollo Integrado de Python

35
La consola interactiva de Python permite ejecutar código sobre la marcha. Es decir, se escribe una
determinada operación y al presionar Enter se ejecuta y se muestra el resultado. Además de ser
perfecta para utilizarse como una calculadora, también resulta así para comprobar la eficacia de
pequeños códigos, la correcta instalación de un módulo, entre otras. Se accede a ella
escribiendo python en la terminal o línea de comandos. En Windows, también es posible
ejecutarla desde el acceso directo creado durante la instalación, generalmente llamado “Python
(command line)” (Recursos_Python, 2014)

Ilustración 9. Consola interactiva python

8.15.2. PyGTK

PyGTK permite crear fácilmente programas con una interfaz gráfica de usuario utilizando el
lenguaje de programación Python. La biblioteca subyacente de GTK + proporciona todo tipo de
elementos visuales y utilidades para él y, si es necesario, puede desarrollar aplicaciones
completas para el escritorio de GNOME.

Las aplicaciones PyGTK son verdaderamente multiplataforma y pueden funcionar sin

modificaciones en Linux, Windows, MacOS X y otras plataformas.

Otras características distintivas de PyGTK son, además de su facilidad de uso y creación de

prototipos rápidos, su soporte de accesibilidad de primera clase o la capacidad de manejar textos
complejos multilingües o bidireccionales para aplicaciones totalmente localizadas.
36
PyGTK es un software libre, por lo que puede ser usado, modificado, distribuido y estudiado con
muy pocas restricciones (licencia LGPL). (Finlay, Villar, & Gil, s.f.)

8.15.3. Módulo Pexpect

Pexpect hace de python una mejor herramienta para controlar otras aplicaciones. Permite que el
script genere una aplicación secundaria y la controle como si un humano estuviera escribiendo
comandos.

Pexpect se puede utilizar para automatizar aplicaciones interactivas como ssh, ftp, passwd, telnet,
etc. Se puede usar para automatizar scripts de instalación para duplicar instalaciones de paquetes
de software en diferentes servidores. Puede usarse para pruebas de software automatizadas.
Funciona en cualquier plataforma que soporte el módulo pty de Python estándar. La interfaz de
Pexpect fue diseñada para ser fácil de usar. (Spurrier, 2013)

10.16. INTERFAZ GRÁFICA DE USUARIO

Interfaz gráfica de usuario (En inglés Graphic User Interface, también conocido con su
acrónimo GUI) es un método para facilitar la interacción del usuario con el ordenador o la
computadora a través de la utilización de un conjunto de imágenes y objetos pictóricos
(iconos, ventanas…) además de texto. Surge como evolución de la línea de comandos de los
primeros sistemas operativos y es pieza fundamental en un entorno gráfico. (González Sojo,
s.f.)

10.16.1. Principios para el diseño de interfaces gráficas

Al desarrollar interfaces gráficas se deben tener en cuenta algunos aspectos para facilitar su
entendimiento y usabilidad

Autonomía: El desarrollo gráfico debe ser lo suficientemente claro para que el usuario ubique e
ingrese los datos de una manera intuitiva.

37
Legibilidad: La GUI debe tener elementos guía para que el usuario sepa cómo debe ingresar los
datos, en la medida de posible algún sistema que le permita comprobar los parámetros que está
ingresando.

10.17. EL PROTOCOLO SSH

El protocolo SSH define un protocolo propio para la transmisión segura de los datos, el protocolo
SSH. Este protocolo se sitúa directamente por debajo de la capa de transporte, (concretamente
del transporte TCP). Aparte de establecer conexiones seguras, el protocolo SSH también ofrece
otras funcionalidades como, por ejemplo, la redirección de puertos TCP o la comunicación entre
clientes y servidores de ventanas X, a través de una conexión SSH.

10.17.1. Características del protocolo SSH

Confidencialidad: SSH sirve para comunicar datos, que habitualmente son la entrada de una
aplicación remota y la salida que genera, o bien la información que se transmite por un
puerto redirigido, y la confidencialidad de estos datos se garantiza mediante el cifrado. Un
servicio adicional que proporciona SSH es la confidencialidad de la identidad del usuario. En
SSH la autenticación del usuario se realiza cuando los paquetes ya se mandan cifrados. Por
otro lado, SSH2 también permite ocultar ciertas características del tráfico como, por
ejemplo, la longitud real de los paquetes.

Autenticación de entidad: El protocolo SSH proporciona mecanismos para autenticar tanto

el ordenador servidor como el usuario que se quiere conectar. La autenticación del servidor
suele realizarse conjuntamente con el intercambio de claves. En SSH2 el método de
intercambio de claves se negocia entre el cliente y el servidor, aunque actualmente sólo hay
uno definido, basado en el algoritmo de Diffie-Hellman.
Para autenticar al usuario existen distintos métodos; dependiendo de cuál se utilice, puede
ser necesaria también la autenticación del ordenador cliente, mientras que otros métodos
permiten que el usuario debidamente autenticado acceda al servidor desde cualquier
ordenador cliente.

Autenticación de mensaje: Igual que en SSL/TLS, en SSH2 la autenticidad de los datos se

garantiza añadiendo a cada paquete un código MAC calculado con una clave secreta.

38
 También existe la posibilidad de utilizar algoritmos MAC distintos en cada sentido de la
comunicación.

Eficiencia: SSH contempla la compresión de los datos intercambiados para reducir la

longitud de los paquetes. SSH2 permite negociar el algoritmo que se utilizará en cada
sentido de la comunicación, aunque solamente existe uno definido en la especificación del
protocolo. A diferencia de SSL/TLS, en SSH no está prevista la reutilización de claves de
sesiones anteriores: en cada nueva conexión se vuelven a calcular las claves. Esto es así
porque SSH está pensado para conexiones que tienen una duración más o menos larga,
como suelen ser las sesiones de trabajo interactivas con un ordenador remoto, y no para las
conexiones cortas pero consecutivas, que son más típicas del protocolo de aplicación HTTP
(que es el que inicialmente se quería proteger con SSL). De todas formas, SSH2 define
mecanismos para intentar acortar el proceso de negociación.

Extensibilidad: En SSH2 también se negocian los algoritmos de cifrado, de autenticación de

usuario, de MAC, de compresión y de intercambio de claves. Cada algoritmo se identifica
con una cadena de caracteres que representa su nombre. Los nombres pueden corresponder
a algoritmos oficialmente registrados, o bien a algoritmos propuestos experimentalmente o
definidos localmente. (Herrera, García, & Parramón, 2014)

10.18. LISTAS DE CONTROL DE ACCESO (ACL)

Una ACL es una lista que contiene permisos y denegaciones que pueden aplicarse a una red para
determinar si un paquete puede acceder o no a ella.

10.18.1. Propósito de las ACL

Una ACL es una serie de comandos del IOS que controlan si un router reenvía o descarta paquetes
según la información que se encuentra en el encabezado del paquete. Las ACL son una de las
características del software IOS de Cisco más utilizadas. (Cisco, Principios de Routing Switching
(CCNA 2), 2014)

Cuando se las configura, las ACL realizan las siguientes tareas:

 Limitan el tráfico de la red para aumentar su rendimiento. Por ejemplo, si la política

corporativa no permite el tráfico de video en la red, se pueden configurar y aplicar ACL que

39
 bloqueen el tráfico de video. Esto reduciría considerablemente la carga de la red y
aumentaría su rendimiento.
 Proporcionan control del flujo de tráfico. Las ACL pueden restringir la entrega de
actualizaciones de routing. Si no se requieren actualizaciones debido a las condiciones de la
red, se preserva ancho de banda.
 Proporcionan un nivel básico de seguridad para el acceso a la red. Las ACL pueden permitir
que un host acceda a una parte de la red y evitar que otro host acceda a la misma área. Por
ejemplo, se puede restringir el acceso a la red de Recursos Humanos a los usuarios
autorizados.
 Filtran el tráfico según el tipo de tráfico. Por ejemplo, una ACL puede permitir el tráfico de
correo electrónico, pero bloquear todo el tráfico de Telnet.
 Filtran a los hosts para permitirles o denegarles el acceso a los servicios de red. Las ACL
pueden permitirles o denegarles a los usuarios el acceso a determinados tipos de archivos,
como FTP o HTTP. (Cisco, Principios de Routing Switching (CCNA 2), 2014)

Ilustración 10. Ejemplo de filtrado de paquetes

40
 10.18.2. Tipos de ACL

ACL Estándar: Estos tipos de ACL permiten o deniegan el acceso de acuerdo con la totalidad del
protocolo, como IP. De esta forma, cuando un dispositivo host es denegado por una ACL estándar,
se deniegan todos los servicios provenientes de ese host. Este tipo de ACL sirve para permitir el
acceso de todos los servicios de un usuario específico, o LAN, a través de un router y, a la vez,
denegar el acceso de otras direcciones IP. (Cisco, www.cisco.com, s.f.)

ACL Extendida: Las ACL extendidas filtran no sólo según la dirección IP de origen, sino también
según la dirección IP de destino, el protocolo y los números de puertos. Las ACL extendidas se
utilizan más que las ACL estándar porque son más específicas y ofrecen un mayor control. El rango
de números de las ACL extendidas va de 100 a 199 y de 2000 a 2699. (Cisco, www.cisco.com, s.f.)

Ilustración 11. Numeración y denominación de las ACLs

10.18.3. Máscara Wildcard

Este tipo de máscara es un registro de 32 dígitos binarios que, aplicado a una dirección IPv4,
permite establecer la cantidad de bits son requeridos para ejecutar una determinada acción y
cuáles no deben ser considerados. Las máscaras wildcard utilizan las siguientes reglas para
establecer la coincidencia entre los unos y ceros binarios:

 Bit 0 de máscara wildcard: se establecer la coincidencia con el valor del bit

correspondiente en la dirección.

41
Bit 1 de máscara wildcard: se omite el valor del bit correspondiente en la dirección

A las máscaras wildcard a menudo se las denomina “máscaras inversas”. La razón es que, a
diferencia de una máscara de subred en la que el 1 binario equivale a una coincidencia y el
0 binario no es una coincidencia, en las máscaras wildcard es al revés. Uso de una máscara
wildcard En la tabla 2, se muestran los resultados de la aplicación de una máscara wildcard
0.0.255.255 a una dirección IPv4 de 32 bits. Recuerde que un 0 binario indica un valor con
coincidencia. (Cisco, Principios de Routing Switching (CCNA 2), 2014)

Ilustración 12. Máscara wildcard

Tabla 2. Ejemplo de una máscara wildcard

42
 10.19. DHCP

Cuando un dispositivo se conecta a una red, necesita una IP única. Los administradores de red
asignan direcciones IP estáticas a los routers, a los servidores, a las impresoras y a otros
dispositivos de red cuyas ubicaciones (físicas y lógicas) probablemente no cambien. Por lo tanto,
las direcciones que se les asignan se deben mantener constantes. Además, las direcciones
estáticas habilitan a los administradores para que administren estos dispositivos en forma
remota. (Cisco, Principios de Routing Switching (CCNA 2), 2014)

DHCP (procolo de configuración dinámica de equipos: «Dynamic Host Configuration

Protocol») es un protocolo mediante el cual una máquina puede obtener su configuración
de red automáticamente al iniciar. Esto permite centralizar la administración de las
configuraciones de red y asegurar que todos los equipos de escritorio obtengan
configuraciones similares.
Un servidor DHCP provee muchos parámetros relacionados con la red. Los más comunes son
una dirección IP y la red a la que pertenece el equipo, pero también puede proveer otra
información como servidores DNS, servidores WINS, servidores NTP y más. (Hertzog & Mas,
2012 - 2015, pág. 258)

10.20. TRADUCCIÓN DE DIRECCIONES DE RED PARA IPV4 NAT

Las direcciones IPV4 que se usan en Internet deben registrarse en un registro regional de Internet
(RIR). Las organizaciones pueden arrendar direcciones públicas de un SP (service Provider), pero
solo el titular registrado de una dirección pública de Internet puede asignar esa dirección a un
dispositivo de red.

La organización que administra el espacio de direcciones públicas (direcciones IP enrutables)

es la Agencia de Asignación de Números de Internet (IANA, Internet Assigned Number
Authority). RFC 1918 define un espacio de dirección privada que permite que cualquier
organización asigne direcciones IP a equipos en su red interna sin correr el riesgo de entrar
en conflicto con una dirección IP pública asignada por la IANA. (Francois, 2008)

43
 10.20.1. Tipos de NAT

Existen tres tipos de traducción NAT:

 Traducción estática de direcciones (NAT estática): asignación de direcciones uno a uno

entre una dirección local y una global.
 Traducción dinámica de direcciones (NAT dinámica): asignación de varias direcciones a
varias direcciones entre direcciones locales y globales.
 Traducción de la dirección del puerto (PAT): asignación de varias direcciones a una
dirección entre direcciones ocales y globales. Este método también se conoce como
“sobrecarga” (NAT con sobrecarga). (Cisco, Principios de Routing Switching (CCNA 2),
2014)

44
 11. METODOLOGÍA

Se realizó la recolección de información proporcionada por el fabricante de los equipos

enrutadores obteniendo datos técnicos y tecnologías soportadas, así como conexiones que
generen un funcionamiento efectivo del equipo, se diseñara el algoritmo a partir de la
información recolectada, generando la interfaz, que será la encargada de facilitar la experiencia
de programación para el usuario final, se enviaran comandos a través del protocolo de seguridad
ssh, luego de instalar y trabajar el software de enrutamiento quagga, se establecerán los
parámetros de conexión entre el pc y los enrutadores generando conexión y el flujo de tráfico
necesario para la administración de la comunicación hasta los equipos terminales.

Ilustración 13. Diagrama de flujo. Etapas de realización del proyecto

45
 12. DESARROLLO DE LA PROPUESTA

12.1. HARDWARE UTILIZADO

ASRock 775i65G
 Procesador Intel Pentium ® 4
 Intel ® 865G Chipset
 CPU 3.20 Ghz
 Dual Channel DDR400 (DDR x 2 DIMMs)
 Gráficos Intel ® 865G x86/MMX/SSE2
 Intel ® Extreme Graphics 2 y DirectX8.0
 2 Ports SATA 1-5 Gb/s, 2 ATA 100 IDE Port
 5.1 Channel Audio, Ethernet 10/100 LAN
 ASRock I/O plus: 6 puertos I/O Plus: 6 Puertos
USB 2.0.
 1 GB de memoria RAM DDR2
Ilustración 14. Especificaciones placa base PC
enrutador

ENL832-TX+

 Soporta bus maestro PCI de 32 bit para alto

rendimiento y baja utilización del procesador.
 Cumple con las especificaciones PCI 2.1 y PCI
2.2.
 Cumple con el estándar IEEE 802.3 CSMA/CD,
10/100 Base-Tx.
 Diseño full dúplex para duplicar el rendimiento
a 20Mbps/200Mbps.
 Conector STP para velocidad de red de 100
Mbps o 10 Mbps
 Soporta función de auto negociación.

Ilustración 15. Tarjeta de red adicional para el PC

enrutador

46
CISCO 1941 Series

 2 Puertos Gigabit 10/100/1000 WAN

 Memoria Interna 512 MB
 Memoria Flash 256 MB
 Puerto de consola USB (hasta 115,2 kbps)
 Puerto de consola serial (hasta 115,2 kbps)
 Procesador Incorporado.
 Estándares de red (IEEE 802.1Q, IEEE 802.3, IEEE
802.3af, IEEE 802.3ah, IEEE 802.3u)
 Protocolos de enrutamiento BGP, EIGRP, IGRP, IS-
IS, OSPF
Ilustración 16. Router cisco elegido para interactuar
con el PC enrutador

12.2. SISTEMA OPERATIVO

Para el desarrollo del algoritmo se eligió el sistema operativo Ubuntu basado en GNU/Linux,
versión 14.04 LTS (Soporte Técnico extendido)

Tabla 3. Últimas versiones de ubuntu

47
Las versiones de Ubuntu que son LTS son soportadas oficialmente por la empresa Canonical
durante los próximos cinco años desde su lanzamiento, las que no son LTS tienen soporte oficial
de nueve meses. No se eligió la versión LTS más actual (16.04) por varias razones: Requiere de
más memoria RAM, mayor velocidad de procesamiento y tiene algunas limitaciones con tarjetas
gráficas AMD.

UBUNTU 14.04 LTS UBUNTU 16.04 LTS

Procesador x86 a 700 Mhz Procesador Dual Core
Disco Duro de 5 GB Disco Duro de 16 GB
Memoria RAM 512 MB Memoria RAM 2 GB
Tarjeta Gráfica con resolución 1024x768 Tarjeta Gráfica con resolución de 1366x768

|Tabla 4. Requerimientos mínimos de las versiones LTS 14.04 y 16.04 de Ubuntu

12.3. PAQUETES DE SOFTWARE

Una vez se tiene el ordenador con el sistema operativo instalado se debe actualizar para obtener
los drivers y controladores más recientes, actualizar repositorios y evitar conflictos con la
instalación de paquetes posteriores. Para la instalación de paquetes desde la terminal se debe
acceder en modo root. Se realiza con los siguientes comandos:

apt-get update
apt-get upgrade

También es necesario instalar el editor de texto vim, ya que con él se van a realizar scripts para
interactuar con los paquetes de software

apt-get install vim

48
 12.3.1. Configuración de Quagga

Software de encaminamiento empleado para la programación del PC enrutador. Se realiza la

instalación de este paquete en su versión más reciente (0.99.22.4) con el siguiente comando:

apt-get install quagga

En Linux, cuando se instala un paquete se agrupa en carpetas con fines similares (no queda
instalado todo el programa en una sola carpeta, como pasa en 49imple49), por tal motivo para
configurar quagga se tienen que copiar los archivos de configuración a la carpeta “etc” que es el
directorio correcto para guardar los archivos de configuración de los programas instalados, se
hace con los siguientes comandos:

cd /usr/share/doc/quagga/examples/
cp * /etc/quagga/

Se deben renombrar los ejemplos de configuración (babeld.conf.sample, bgpd.conf.sample,

isisd.conf.sample, ospf.conf.sample, ospf6d.conf.sample, ripd.conf.sample, ripngd.conf.sample,
vtysh.conf.sample y zebra.conf.sample), para usarlos y activar quagga con la configuración por
defecto. Entonces se ejecutan las siguientes líneas en la terminal:

cd /etc/quagga/
cp zebra.conf.sample zebra.conf
cp ripd.conf.sample ripd.conf

Se configuran los demonios (archivos pertenecientes a los protocolos de enrutamiento), para que
se active zebra (demonio de administrador de protocolos) y el protocolo de routing que se vaya
a usar, en este caso rip.

En la ruta anterior se abre el archivo llamado “daemons” con el editor de texto “vim”

vim daemons

Y se editan las siguientes líneas del archivo (pasan de “no” a “yes”)

zebra=yes
ripd=yes
49
Con esto se le indica a quagga que arranque los demonios zebra y ripd. Para que se cargue esta
configuración se reinicia quagga con el siguiente comando:

/etc/init.d/quagga restart

12.3.2. Interfaz quagga

Para acceder a quagga se teclea el comando: “telnet localhost 2601”

Ilustración 17. Acceso a quagga y comandos principales

50
 12.4. IP FORWARDING

El mecanismo de “IP forwarding” se encarga de la retransmisión de los paquetes que se reciben

por una interfaz física y de retransmitirlos por otra interfaz hacia otro nodo. Para que el PC pueda
actuar como enrutador se debe activar, se realiza de la siguiente manera:

Desde la terminal y en modo root se dirige a la siguiente ruta y se abre el archivo “sysctl.conf”
con un editor de texto, en este caso “vim”.

Vim /etc/sysctl.conf
Una vez abierto el archivo Se le quita el # a la línea

#net.ipv4.ip_forward=1

Se guarda y se cierra el archivo, queda como en la Ilustración 18

Ilustración 18. Modificación del archivo “sysctl.conf” para que el PC actúe como enrutador

12.5. CONFIGURACIÓN INTERFAZ PC ENRUTADOR

Recuérdese que el PC tiene dos tarjetas de red instaladas, Ubuntu asigna como nombres para las
tarjetas de red (ETH0, ETH1, etc). En este caso la tarjeta auxiliar es la ETH0 y la que está integrada
a la placa base ETH1. La que se va usar de interfaz al router Cisco 1941 es la ETH0, por tal motivo
debe configurarse (asignarle IP, máscara y Gateway), esto se realiza por medio de los siguientes
comandos:
Ifconfig eth0 192.168.1.3 netmask 255.255.255.0
route add default gw 192.168.1.1 eth0

51
 12.6. INSTALACIÓN DE GLADE Y GTK+

El diseñador de interfaces Glade y las librerías GTK+ actúan en conjunto, se debe asegurar que
queden instaladas y configuradas correctamente para poder diseñar la interfaz.

Se ejecutó el comando para instalar glade

apt-get install glade

Se instaló la versión 3.0 que es la última de las librerías GTK+

apt-get install gtk+-3.0

También es necesaria la librería libglade2-dev, que no viene incluida en el kit de instalación.

apt-get install libglade2-dev

12.7. CONFIGURACIÓN SSH EN ROUTER CISCO

Secure Shell (SSH) es un protocolo que proporciona una conexión de acceso remoto segura para
dispositivos de red. La comunicación entre el cliente y el servidor está cifrada.
Para que la interfaz pueda acceder al router cisco, este debe tener configurada una sesión ssh, se
realiza de la siguiente manera:

router(config)#hostname cisco1941
(Es necesario configurar el nombre del Router sino no dejar configurar SSH)

cisco1941(config)#ip domain-name cisco.com

(Cisco se basa en estas 2 variables para generar las claves RSA. El nombre y el Dominio para
generarlas)

cisco1941(config)#crypto key generate rsa 1024

(Genera las claves RSA con un tamaño de 1024 bits)

cisco1941(config)#ip ssh time-out 30

(Configura el Tiempo de Espera esto es en Segundos)

cisco1941(config)#ip ssh authentication-retries 3

(Configura un máximo de logins fallidos)
52
cisco1941(config)#ip ssh version 2
(Habilitar de SSH version 2)

cisco1941(config)#username sistemas privilege 15 password s1stem4s

(Configura los usuarios que tendrán acceso vía SSH y los privilegios)

cisco1941(config)#line vty 0 4
(Línea donde se aplicara el SSH)
cisco1941(config-line)#transport input ssh
(Activa el SSH en la Line VTY)

cisco1941(config-line)#login local
(Para que se haga uso del usuario)

12.8. TOPOLOGÍA DE PRUEBA

Ilustración 19. Topología en software de simulación Packet Tracer

En la Ilustración 19 se muestra la topología sugerida para la realización de pruebas, el router

quagga (ordenador de escritorio) cuenta con dos tarjetas de red (ETH0 y ETH1), el router cisco
lleva integrado el switch, aunque es la topología física sugerida la red es completamente
escalable, el direccionamiento físico y lógico se realiza teniendo en cuenta la cantidad de equipos
y la disponibilidad de direcciones que se pretende asignar así como los mecanismos de
distribución de estas como VLSM, CIDR o si se tendrán en cuenta las direcciones con clase.

53
 12.9. DISEÑO INTERFAZ

La ventana de inicio de la interfaz (Ilustración 29), se diseñó de forma intuitiva y explicativa para
usuarios finales con un conocimiento muy básico acerca de la configuración de equipos
intermedios de red. Al ejecutar el programa inicialmente nos pide que elijamos el router a
configurar, si elegimos el router “QUAGGA” se solicita el usuario “admin” y la contraseña inicial
(Ilustración 30) configurada en el router embebido quagga, predeterminada “zebra”, de esta
manera se accede a la configuración principal.

Ilustración 20. Ventana de acceso a la interfaz

Ilustración 21. Ventana de acceso router Quagga

54
Si no se colocan los datos de acceso correctos la interfaz no nos deja continuar a la siguiente
ventana, mostrando el siguiente mensaje (Ilustración 22):

Ilustración 22. Ventana de acceso incorrecto

Una vez ingresadas las credenciales correctas, entramos a la configuración principal (Ilustración
32), en la pestaña inicio si presionamos el botón “Consultar” en la zona (1) se muestran los
parámetros que se encuentran programados en el router, cada vez que se guarde una
configuración se puede verificar en esta sección para comprobar que quedó guardada
correctamente.

Ilustración 23. Pestaña Inicio. Configuración router quagga

55
en la zona media se encuentra una entrada de texto, se diseñó para que el usuario pueda
consultar comandos en específico, se escribe la orden, se presiona el botón “Enviar” y se muestra
el resultado en la zona 2.

En la Ilustración 24 se observan los parámetros iniciales a configurar en el router. Nos da la opción

de cambiar el hostname, la clave de inicio de sesión y la asignación de ip y máscara de red para
las interfaces, una vez colocados estos datos en los campos de entrada de texto se oprime el
botón enviar y quedan asignados en la configuración del router. Podemos verificar los parámetros
ingresados en el recuadro de la parte derecha.

Adicional se da la opción de activar características para realizar una configuración más completa,
si se va a trabajar con Ipv6, el enrutamiento de paquetes con este direccionamiento no viene
activo de forma predeterminada por lo que se debe activar. Para configurar la parte fundamental
del router como lo es el enrutamiento que puede ser estático y dinámico, para este último se
tienen 4 protocolos (RIPv1, RIPv2, EIGRP, OSPF).

Ilustración 24. Pestaña Configuración router quagga

56
Para configurar los protocolos de routing tenga en cuenta las direcciones que asignó a las
interfaces, en el caso del protocolo RIP solo será necesario introducir la dirección IP de la interfaz,
su máscara de subred y la versión del protocolo, como se muestra en la Ilustración 25.

Ilustración 25. Configuración protocolo RIP. Router Quagga

Para configurar el protocolo OSPF (Ilustración 26) se ingresa el parámetro router ID (este
parámetro identifica el dispositivo que origina o procesa la información del protocolo), luego se
ingresa la red y la máscara de subred en la que se quiere habilitar el protocolo y finalmente el
valor de área que integra el protocolo OSPF.

Ilustración 26. Configuración protocolo OSPF. Router Quagga

Para la configuración del enrutamiento estático (Ilustración 27) se debe tener en cuenta la
topología y el direccionamiento lógico, el primer parámetro que se nos solicita es la “Red de
destino”, esta hace referencia a la dirección de red destino a la cual queremos comunicarnos, la
“Máscara de red”, parámetro asociado a la red de destino y por último “Dirección siguiente salto”,
esta es la dirección IP del router directamente conectado por el cual queremos enrutar los
paquetes.

57
 Ilustración 27. Configuración enrutamiento estático. Router Quagga

Para programar un ACL estándar (Ilustración 28) basta con asignarle un número y colocar la
dirección de red a la que queremos permitir o denegar el tráfico, la máscara wildcard para
identificar o ignorar los bits correspondientes a la dirección IP

Ilustración 28. Configuración ACL estándar. Router Quagga

En el caso de la ACL extendida, al igual que en la ACL estándar se asocia un número para poderla
identificar, (se selecciona el botón “Permitir” o “Denegar” según corresponda), por ejemplo, en
la Ilustración 29 se selecciona permitir el tráfico desde la red 192.168.0.0 a los hosts que se
encuentren en la red 209.32.16.0.

58
 Ilustración 29. Configuración ACL extendida. Router Quagga

En la pestaña conectividad se tiene de manera intuitiva la herramienta Ping y Tracert para probar
si las configuraciones realizadas anteriormente se realizaron satisfactoriamente.

Ilustración 30. Pestaña conectividad. Router Quagga

Para la configuración del router como servidor DHCP se requiere asignar tres parámetros básicos
para la asignación de direcciones IP de forma dinámica (Ilustración 31), reservar un rango de
direcciones las que no se tendrán dentro del pool disponibles para ser asignadas, se debe
determinar el rango de direcciones que estarán dentro del pool disponible, y luego asignar la
interface designada para la recepción de peticiones de solicitud para la asignación de parámetros
DCHP.

59
 Ilustración 31. Parámetros DHCP

Una vez terminada la configuración en el router Quagga, se puede cerrar la ventana y volver a la
ventana de inicio (Ilustración 20), allí al presionar en el botón referente a CISCO se obtiene la
ventana de acceso a esta plataforma (recuerde que el router cisco debe tener configurada una
sesión SSH para poder acceder y configurarlo), una vez colocadas las credenciales correctas,
accedemos a la configuración, las aplicaciones a configurar son las mismas vistas en la
configuración Quagga, la diferencia más notable es el formato de las máscaras que en quagga es
con formato /24 y en cisco 255.255.255.0.

Ilustración 32. Credenciales acceso cisco

Para la creación de ACL’s se debe tener en cuenta el tipo de ACL que se creara, la interfaz a la que
se realizara la asignación y cuál será el sentido del flujo de paquetes al que se le realizara el
filtrado.
60
Para una ACL estándar los parámetros que se deben asignar son la dirección de red de origen del
tráfico que se va a filtrar, definiendo la wildcard que permitirá definir que bits de la dirección IP
que deben coincidir para permitir o denegar según se defina – sin olvidar el deny any implícito al
final de la ACL- el tráfico en ese router.

Ilustración 33. Parámetros ACL’s Estándar. Router Cisco

En las ACL’s Extendidas son más los parámetros que se deben tener en cuenta ya que este tipo
de ACL’s filtran de acuerdo a la dirección de origen, de destino, a los protocolos capa 4 –Modelo
OSI- o al puerto de origen y destino, estos parámetros son solicitados en una ventana emergente
(Ilustración 36) cuando es seleccionada la opción de ACL extendida en la interfaz.

Ilustración 34. Parámetros configuración ACL Extendida

61
Para configurar un router con el protocolo NAT, se debe tener claro el pool de direcciones públicas
asignadas y privadas dentro de nuestra red que van a ser objeto para la traducción, y la interfaz
por el que va a ingresar el tráfico y la de salida hacia el ISP y así poder realizar la salida a internet
o a una red externa por medio de una dirección pública. Los parámetros mínimos de configuración
que se requieren para habilitar NAT se muestran en la Ilustración 35.

Ilustración 35. Parámetros de configuración NAT

Ya teniendo los parámetros de configuración y de enrutamiento funcionando podemos realizar

pruebas desde cualquier dispositivo de nuestra red aunque es recomendable generar tráfico
desde los dispositivos de red finales verificando parámetros relacionados con los configurados,
desde la interfaz en relación en la última pestaña (Ilustración 29), se encuentra la relación de las
pruebas de conectividad básicas como es el ping ejecutado por el protocolo ICMP y tracert que
nos muestra los saltos realizados por un paquete generado igualmente por el protocolo ICMP con
Tiempos de vida (TTL) que varían de acuerdo al salto, estas pruebas se pueden generar desde el
PC o si esta la conexión remota establecida desde el router cisco.

62
 13.1. ADMINISTRACION DE LA RED

Según el concepto de administración de la red el cual sugiere que los pasos para asignar
direcciones IP, mantener tabla de enrutamiento, aplicar los protocolos necesarios para generar
conectividad entre dispositivos terminales, además de configurar y mantener la disponibilidad,
integridad y confiabilidad de los servicios de red, para lo que se aplican las configuraciones en los
dispositivos de red de acuerdo a lo establecido.

Ilustración 37. Red de prueba implementada

En la ilustración 37 se encuentra implementada la red según la topología simulada en packet

tracer (Ilustración 39), luego de ejecutar la aplicación y enviar la información solicitada en cada
entrada de texto de la aplicación de acuerdo a los requerimientos de funcionamiento de la red,
se comprueba mediante la función de consulta de la ventana principal, la que ejecuta el comando
“show running” dentro del dispositivo y muestra la configuración que está corriendo.

63
 Ilustración 38. Ejemplo implementación de comandos

En la ilustración 38, se observa la simplicidad de la implementación de comandos para la

administración de la red ya que los comandos se ejecutan internamente directo al sistema
operativo mediante la conexión SSH, mediante la información solicitada de forma intuitiva.

64
 14. RESULTADOS

Ilustración 38. Topología Implementada

Ilustración 39. Función de consulta configuración en ejecución

Ilustración 40. Tabla de enrutamiento después de ejecutar aplicación

65
Luego de implementar la topología de red (Ilustración 38), mediante protocolo ICMP, enviando
ping desde la interfaz hacia los equipos terminales, se puede verificar la conectividad de la red y
la correcta programación de los equipos intermedios, se procede a verificar características de la
red por medio del programa analizador de redes “iperf3”, proporcionando información del
rendimiento de la red, se realizaron las siguientes pruebas:

Ilustración 41. Equipo cliente. Programa iperf (red quagga – cisco)

El Jitter se define técnicamente como la variación en el tiempo en la llegada de los paquetes,

causada por congestión de red, perdida de sincronización o por las diferentes rutas seguidas
por los paquetes para llegar al destino.

VALORES RECOMENDADOS:
El Jitter entre el punto inicial y final de la comunicación debiera ser inferior a 100 ms. Si el valor
es menor a 100 ms el Jitter puede ser compensado de manera apropiada. En caso contrario
debiera ser minimizado. (VoipForo, s.f.)

El Throughput es una medida de cuántas unidades de información, un sistema puede procesar en

una cantidad de tiempo dada. Se aplica ampliamente a sistemas que van desde varios aspectos
de sistemas informáticos y de redes a organizaciones. Las medidas relacionadas con la
productividad del sistema incluyen la velocidad con que se puede completar una carga de trabajo
66
específica y el tiempo de respuesta, la cantidad de tiempo entre una solicitud de usuario
interactiva única y la recepción de la respuesta.

En la red implementada el rendimiento no tienen mucha varianza respecto a las medidas de

rendimiento físicas y lógicas entregadas por los nodos, ya que se encuentra en sobredimensión
de acuerdo al tipo y cantidad de tráfico generado, el estado de la red de acuerdo a las pruebas se
acercan de gran manera a una red en un estado ideal.

En la Ilustración 41 se observa el comando “iperf3 –c 10.0.0.10 –u –t 10”, con el cual se envían al

equipo servidor flujos de paquetes udp durante 10 segundos, con un tamaño total de 1.24
MBytes, ancho de banda de 1.04 MBytes/seg, Jitter 0.132 ms y pérdida de paquetes del 0%.

Ilustración 42. Equipo cliente. Programa iperf (red wifi Pc a PC)

Haciendo una comparación entre la transmisión hecha por la red cableada y la inalámbrica se
evidencia un aumento considerable del Jitter (de 0,132ms a 4,607 ms), se confirma disminución
en el tiempo de llegada de los datagramas.

67
 Ilustración 43. Equipo cliente transmitiendo a máxima capacidad

En la ilustración 43 se ejecuta el comando “iperf3 –c 10.0.0.10 –w 50000”, con el que se envían

50Mbytes con el fin de evaluar el ancho de banda y la velocidad de transferencia máxima que se
puede alcanzar con la red implementada (las tarjetas de red implementadas en el ordenador
quagga son fast ethernet), se evidencia en la imagen que el enlace llega hasta un ancho de banda
de 93,6 Mbits/seg.

Ilustración 44. Captura de paquetes mediante Wireshark

Mediante el sniffer WireShark se realiza la captura de paquetes del flujo generado por el iperf3
usando el protocolo de capa TCP donde se observan los campos, el tamaño y la longitud, del
paquete, evidenciando el tráfico generado y valores asignados a los campos según los valores
asignados por iperf3 al datagrama.
68
 Ilustración 45. Estadísticas protocolo Netflow

Ilustración 46. Grafica estadísticas protocolo Netflow

69
 Netflow es una Tecnología desarrollada por Cisco para recolectar información de sus
interfaces y comprender mejor el comportamiento de éstas en la red. Los dispositivos
de Cisco enviarán información vital a un Servidor en la red conocido como el Netflow
Collector. (Araque, s.f.)

Después de ingresar los comandos para la captura de tráfico mediante el protocolo NetFlow
se puede obtener estadísticas de acuerdo a la información presentada como lo son: los
protocolos usados de la capa de transporte y aplicación, se puede observar la cantidad de
paquetes por flujo y analizarlos por si se presentaran retardos en la transmisión o pérdida de
estos.

Ilustración 46. Acceso al servidor FTP

Se configuro un servidor ftp en uno de los equipos terminales, en la Ilustración 46 se muestra

el acceso a la IP del PC servidor, esto realizado desde el equipo cliente, colocando los datos de
inicio de sesión del PC servidor.

70
 Ilustración 47. Lista de archivos PC servidor

Ilustración 48. Archivo descargado por medio del servidor FTP

El archivo de 2.2 Gb tardo en descargarse 2:56 segundos a una velocidad de 10.9 MB/s. La
descarga del archivo fue constante sin retrasos. Siendo el resultado muy similar al entregado
por el programa de análisis de tráfico iperf.

71
 15. USO DE LA PLATAFORMA

15.1. DESCRIPCIÓN

Se describe el uso e interacción del usuario directo con la interfaz gráfica (referenciado de forma
de caso de uso para facilidad de comprensión) que le facilitara realizar la programación de dos
tecnologías de router’s, incluyendo módulos intuitivos de gestión de comandos, de manera
secuencial hasta llegar a la configuración inicial recomendada por el fabricante para realizar
interconexión de funcional entre dispositivos intermedios y finales de red.

15.2. FLUJO PRINCIPAL

15.2.1. Ejecución Interfaz

Se debe realizar por parte del actor que va a hacer uso la ejecución de la interfaz por medio de
unos comandos en la terminal de Linux.

15.2.2. Ingreso de credenciales

El sistema emerge una ventana en la cual se debe ingresar el usuario y password que debe
coincidir con los configurados en los router’s, para ingresar a la ventana de inicio, inicialmente no
se debe restringir el ingreso ya que no están configurados los router’s.

15.2.3. Ingreso a usuario EXEC.

El ingreso inicial conecta a los router’s de manera de usuario básico, para ingresar al modo de
usuario privilegiado en el router quagga, se selecciona la opción “Quagga”, luego se despliega una
ventana que solicita la clave de ingreso, para el cisco se da click en ssh y se configuran los
parámetros y se obtiene acceso al CLI.

15.2.4. Revisar parámetros configurados

Para realizar una revisión en los router’s la configuración en ejecución es necesario emitir el
comando show running, con el resultado de este se podrá obtener información como interfaces
y los estados en que se encuentran, usuarios, etc.

72
 15.2.5. Configuración de parámetros

Ya con la información necesaria y los permisos concedidos, se puede iniciar con la configuración,
ingresando los parámetros solicitados cumpliendo con los pasos y secuencia de forma correcta.
Al finalizar se debe dar click en enviar, finalizando la etapa de configuración.

15.2.6. Verificación pruebas

Para la finalización del proceso se diseñó la etapa final basándose en el protocolo de control ICMP,
se ejecuta comandos para la prueba de conectividad y traza de rutas las cuales como resultado
mostraran el funcionamiento de los equipos.

15.3. FLUJOS ALTERNATIVOS

15.3.1. Usuario y contraseña errónea

No se habilitará el ingreso a la interfaz de configuración si no se tienen las credenciales necesarias

como para el usuario básico, como para el modo privilegiado y la comunicación SSH por lo que no
se iniciara el proceso.

15.3.2. Configurar parámetros incompletos

Se puede configurar lo que estrictamente necesario, lo que significa que podría presentarse el
caso de no necesitar todos los parámetros presentados en la interfaz, lo que no presentara error
al enviar y terminara el proceso.

73
15.4. DIAGRAMA DEL CASO DE USO

Ilustración 49. Diagrama de casos de uso

74
 16. DIAGRAMA DE FLUJO

El diagrama de flujo representa el algoritmo del código fuente de la plataforma cuando inicia su
ejecución, es la forma secuencial en que trabaja el algoritmo esperando las “señales” generadas
por los eventos ocurridos desde la interfaz, ejecutando el método asignado mediante el
namespaces relacionado en la clase inicial del programa.

75
Ilustración 50. Diagrama de flujo

76
 17. CONCLUSIONES

 Debido a la variedad de distribuciones Linux puede no ser tan intuitivo y viable para un
usuario promedio utilizar programas de routing en software libre, sin embargo, con la
implementación de la interfaz gráfica se logra de una manera amigable que los usuarios
administren su red sin necesidad de adentrarse en comandos propios del sistema
operativo y/o de la configuración del paquete de enrutamiento.
 Añadiendo una tarjeta de red a una CPU y usando un software de enrutamiento se obtiene
un mejoramiento en las capacidades de la máquina, ya que aparte de ser usada para
tareas de oficina, simultáneamente puede usarse como un elemento eficiente de
networking, reduciendo costes y espacio, se mantiene la productividad con menos
hardware.
 El uso del sistema operativo Ubuntu como base de la interfaz ofrece un funcionamiento
estable al ser soportado por la empresa canonical, adicionalmente es de destacar la
facilidad que provee el software libre para interactuar directamente sobre la terminal de
comandos y así poder generar programación y comunicación con dispositivos externos.
 La eficiencia medible mediante el tiempo de programación de los equipos se reduce
mediante la eliminación de redundancia cíclica en los procedimientos para la inserción
código, cuando el programador debe ingresar continuamente a los diferentes modos de
usuario que existen en los IOS de los dispositivos de manera tradicional, procesos que se
automatizan en la interfaz.
 Integrando software como cisco IOS y quagga se fomenta la interoperabilidad en redes y
se muestra al usuario final una herramienta que le permite interactuar con enrutadores
software y hardware conjuntamente, permitiendo de esta manera comparar, analizar y
extrapolar aspectos positivos y negativos de cada uno.
 La puesta en marcha de la interfaz gráfica muestra al usuario lineamientos de
programación de redes de una manera organizada para facilitar la asimilación de los
mismos y así contribuir a un aprendizaje más dinámico si se usa en el entorno educativo

77
 18. BIBLIOGRAFÍA

Araque, A. (s.f.). Colombia Virtualizada. Obtenido de http://www.colombiavirtualizada.com:

http://www.colombiavirtualizada.com/2013/09/24/protocolo-netflow-de-cisco/

Ares, R. (1999). Componentes de redes IP. Obtenido de http://www.robertoares.com.ar/wp-

content/uploads/2010/06/Seccion-3.pdf

Capacity. (s.f.). Capacity - Information Technology Academy. Obtenido de

http://blog.capacityacademy.com/2014/10/22/quagga-implementacion-de-enrutamiento-

dinamico-en-linux/

Cisco. (2014). Principios de Routing Switching (CCNA 2). Pearson.

Cisco. (s.f.). www.cisco.com. Obtenido de www.cisco.com:

https://www.cisco.com/c/es_mx/support/docs/security/ios-firewall/23602-

confaccesslists.html

Cisco_Systems. (s.f.). CCNA Exploration II. Conceptos y protocolos de enrutamientos.

Collado, E. (2009). Fundamentos de Routing. Madrid: Autor-Editor.

Cuenca, F. (2012). ¿Qué es Linux? Obtenido de

http://www.investigacion.frc.utn.edu.ar/labsis/Publicaciones/QueEsLinux/QueEsLinux.ht

ml

Finlay, J., Villar, R., & Gil, L. (s.f.). www.pygtk.org. Obtenido de

http://www.pygtk.org/pygtk2tutorial-es/index.html

Francois, J. (16 de 10 de 2008). CCM. Obtenido de http://es.ccm.net/contents/271-nat-

conversion-de-direcciones-de-red-habilitacion-de-puertos-y

78
GNOME_Developer. (2005 - 2014). Manual del diseñador de interfaces de ususario Glade.

Obtenido de The GNOME Proyect: https://developer.gnome.org/glade/3.12/glade.html

GNOME_Developer. (2005 - 2014). Part I GTK+ Overview. Obtenido de The GNOME Project:

https://developer.gnome.org/gtk3/3.22/gtk.html

González Sojo, D. W. (s.f.). bibing.us.es. Obtenido de

http://bibing.us.es/proyectos/abreproy/11300/fichero/PROYECTO%252FCapitulo3.pdf

González, L. (s.f). Protocolos de enrutamiento. Sevilla, Esapña. Obtenido de

http://www.ieslosviveros.es/alumnos/asig8/carpeta812/PROTOCOLOS_DE_ENRUTAM

IENTO.pdf

Guias_Ubuntu. (18 de Octubre de 2011). Guia Ubuntu. Obtenido de https://www.guia-

ubuntu.com/index.php/Ubuntu

Guimi. (2008). guimi.net. Obtenido de http://guimi.net/descargas/Monograficos/G-

Lenguajes_de_programacion.pdf

Hallberg, B. (2007). Fundamentos de redes. Mexico, D.F.: McGRAW-HILL.

Herrera, J., García, J., & Parramón, X. (2014). Aspectos avazados de seguridad en redes.

Cataluña: Eureka Media.

Hertzog, R., & Mas, R. (2012 - 2015). The Debian Administrator's Handbook. Free Software

Foundation.

Ishiguro, K. (Marzo de 2017). Savannah. Obtenido de A routing software package for TCP/IP

networks: http://www.nongnu.org/quagga/docs/quagga.pdf

Islas, M. (2006). Desarrollo de alicaciones con Python, PyGTK y Glade. Instituto de Ciencias

superiores de Poza Rica. Obtenido de

79
 https://radiosyculturalibre.com.ar/biblioteca/PROGRAMACION/Python/Desarrollo%20d

e%20aplicaciones%20con%20Python%20PyGTK%20y%20Glade.pdf

Jakma, P. (11 de Septiembre de 2004). Quagga Routing Suite. Obtenido de Quagga:

http://www.fis.agh.edu.pl/wfitj/complab/doc/Quagga/www.quagga.net/docs/docs-

info.html#SEC126

Jorba, J., & Suppi, R. (2004). Administración Avanzada de GNU/Linux. Cataluña: Eureca Media.

Obtenido de http://www.utic.edu.py/citil/images/Manuales/Admin_GNULinux.pdf

Joyanes, L., & Zahonero, I. (1999). Programación en C. Metodología, algoritmos y estructura de

datos. Madrid: Mc Graw Hill.

Mier, E., & Mier, G. (2008). Protocolos de Enrutamiento. RIP, OSPF y EIGRP. Cartagena.

Obtenido de http://biblioteca.unitecnologica.edu.co/notas/tesis/0045016.pdf

Pérez, J. (2014). Definición.de. Obtenido de Definición.de: https://definicion.de/red-de-datos/

Recursos_Python. (2 de Junio de 2014). recursos python. Obtenido de

http://recursospython.com/guias-y-manuales/como-empezar-con-python/.

Spurrier, N. (2013). Read The Docs. Obtenido de https://pexpect.readthedocs.io/en/stable/

Ubuntu ORG. (2011). Historia de ubuntu. Obtenido de Ubuntu Mexico:

http://www.ubuntumx.org/historia.php

Vázquez, J. (2009). Implementación de un router bajo linux. México.

VoipForo. (s.f.). VoipForo. Obtenido de http://www.voipforo.com/QoS/QoS_Jitter.php

80
 19. ANEXOS

19.1. CÓDIGO DE LA APLICACIÓN

#!/usr/bin/env python
#-*- coding: utf-8 -*-

# Se importan módulos requeridos para la aplicación

from gi.repository import Gtk
import os
import pexpect

#Se crean variables globales ###################################################

flag = 2
pos1= 0
texto1 = ""
texto2 = ""
texto3 = ""
texto4 = ""
texto5 = ""
cmmsend = []
commands='telnet localhost ‘,'enable ‘, 'configure terminal ','hostname ','password ',
'interface ', 'ip address ', 'exit’, ‘?’, 'ipv6 forwarding’, 'show running’, 'access-list ‘, 'permit ‘,
'deny ‘, 'ip route ‘, '\r’, 'ip nat inside ', 'ip nat outside ', 'network '
commandcsc = '?'
pos = 8
user = 0
prot = ''
routerid = ''
network = ''
area = ''
text_user_ssh = ''
text_address = ''
text_psw_ssh=''

# Función que retorna elección en los menús desplegables ###########################

def valor_combobox(combobox):
model = combobox.get_model()
activo = combobox.get_active()
if activo < 0:
81
 return None
return model[activo][0]

# Función de envío de protocolo OSPF o RIP a tecnología quagga ######################

def Enviar_protocolo(txt_cmm):

global prot , routerid , area , network

textbuffer = Gtk.TextBuffer()

if prot == 'RIP':
x = 'ripd'
prot = 'rip'
if prot == 'OSPF':
x = 'ospfd'
prot = 'ospf'

child = pexpect.spawn(commands[0] + x)
child.timeout = 0.5
child.expect('Password: ')
child.sendline('zebra')
child.sendline(commands[1])
child.sendline(commands[2])
child.sendline('router ' + prot)

if prot == 'rip':
child.sendline('network ' + netrip)
child.sendline('version ' + version)
textbuffer.insert_at_cursor('router ' + prot + '\r' + 'network ' + netrip + '\r' +
'version ' + version)

if prot == 'ospf':

child.sendline('router-id ' + routerid)

child.sendline('network ' + network + ' area ' + area)
textbuffer.insert_at_cursor('router ' + prot + '\r' + 'router-id ' + routerid + '\r' +
'network ' + network + ' area ' + area)

txt_cmm.set_buffer(textbuffer)
child.sendcontrol('z')
child.sendline(commands[7])
child.interact()
82
# Función para la autenticación y envío de comandos al Router Cisco ###################

def ingresar_cisco(textviewcmm , textviewcmm2 , txt_cmm):

global text_psw_ssh

child = pexpect.spawn('ssh ' + text_user_ssh + '@' + text_address)

child.timeout = 1
child.expect('Password: ')
child.sendline(text_psw_ssh)
textbuffer = Gtk.TextBuffer()

if user == 1:
child.sendline(commands[pos] + '\r'*50)
child.sendline(commands[7])
next_line = child.readline()
while next_line != '' :

print (next_line.strip())
textbuffer.insert_at_cursor(next_line.strip() + '\r')
textviewcmm.set_buffer(textbuffer)
try:
next_line = child.readline()

except pexpect.TIMEOUT:
pass
break

if user == 3:

child.sendline(commands[2])
child.sendline('ipv6 unicast-routing' + '\r')
textbuffer.set_text('ipv6 unicast-routing' + '\r')
txt_cmm.set_buffer(textbuffer)

if user == 4:

for i in range(0 , pos1):

child.sendline(cmmsend[i] + '\r')

next_line = child.readline()
83
 while next_line != '' :

print (next_line.strip())
textbuffer.insert_at_cursor(next_line.strip() + '\r')
textviewcmm2.set_buffer(textbuffer)

try:
next_line = child.readline()

except pexpect.TIMEOUT:
pass
break

if user == 5:

child.sendline(commands[2])

if len(texto1) > 0:
child.sendline(commands[3] + texto1)
textbuffer.insert_at_cursor(commands[3] + texto1 +'\r')
txt_cmm.set_buffer(textbuffer)
if len(texto3) > 0:
child.sendline('username admin ' + commands[4] + texto3)
text_psw_ssh = texto3
textbuffer.insert_at_cursor(commands[4] + texto3 + '\r')
txt_cmm.set_buffer(textbuffer)
if len(texto4) > 0 and len(texto5) > 0:
child.sendline(commands[5] + texto4)
child.sendline(commands[6] + texto5)
child.sendline('no shutdown')
textbuffer.insert_at_cursor(commands[5] + texto4 + '\r' + commands[6] +
texto5 + '\r' + 'no shutdown' + '\r')
txt_cmm.set_buffer(textbuffer)

if user == 6:

child.sendline(commands[2])
child.sendline(commands[11] + nAcl1 +' '+ commands[pos] + addAcl1 +' ' +
wildAcl1 )
textbuffer.insert_at_cursor(commands[11] + nAcl1 + ' ' + commands[pos] +
addAcl1 + ' ' + wildAcl1 + '\r')

84
 if len(intAcl) > 0:

child.sendline(commands[5] + intAcl)
child.sendline('ip access-group ' + nAcl1 + interAcl)
textbuffer.insert_at_cursor(commands[5] + intAcl + '\r' + 'ip access-group '
+ nAcl1 + interAcl)

txt_cmm.set_buffer(textbuffer)

if user == 7:

child.sendline(commands[2])
child.sendline(commands[11] + nAclx1 +' '+ commands[pos] + selprot +
addsAclx1 + ' ' + wildsAclx1 +' '+ selop1 + ports + ' ' + adddAclx1+' ' + wilddAclx1 +' '+ selop2 +
portd)
textbuffer.insert_at_cursor(commands[11] + nAclx1 +' '+ commands[pos] +
selprot + addsAclx1 + ' ' + wildsAclx1 +' '+ selop1 + ports + ' ' + adddAclx1 +' ' + wilddAclx1 +'
'+ selop2 + portd + '\r')

if len(intAclx) > 0:

child.sendline(commands[5] + intAclx)
child.sendline('ip access-group ' + nAclx1 + interAclx)
textbuffer.insert_at_cursor(commands[5] + intAclx + '\r' + 'ip access-group
' + nAclx1 + interAclx)

txt_cmm.set_buffer(textbuffer)

if user == 8:

child.sendline(commands[2])
child.sendline('router rip')
child.sendline('version ' + str(verrip))
child.sendline(commands[pos] + netrip1)
textbuffer.insert_at_cursor('router rip' + '\r' + 'version ' + str(verrip) + '\r' +
commands[pos] + netrip1)
if len(version1) > 0:
child.sendline('passive-interface ' + version1)
txt_cmm.set_buffer(textbuffer)

if user == 9:

child.sendline(commands[2])
85
 child.sendline('ip dhcp excluded-address ' + add_start + ' ' + add_end)
child.sendline('ip dhcp pool ' + name_pool)
child.sendline('network ' + pooladd_start + ' ' + pooladd_end)
child.sendline('default-router ' + gateway)

if user == 10:

if nat == 'static':

child.sendline(commands[2])
child.sendline(commands[16] + 'source static ' + ippriv + ' ' + ippub)
textbuffer.insert_at_cursor(commands[16] + 'source static ' + ippriv + ' ' +
ippub)

if nat == 'dynamic overload':

child.sendline(commands[2])
child.sendline('ip nat pool ' + namenat + ' ' + pubst + ' ' + pubend + '
netmask ' + pubsub)
child.sendline(commands[11] + acc + ' permit ' + prist + ' ' + priwild)
child.sendline(commands[16] + 'source list ' + acc + ' pool ' + namenat + '
overload')
textbuffer.insert_at_cursor('ip nat pool ' + namenat + ' ' + pubst + ' ' +
pubend + ' netmask ' + pubsub)
textbuffer.insert_at_cursor(commands[11] + acc + ' permit ' + prist + ' ' +
priwild)
textbuffer.insert_at_cursor(commands[16] + 'source list ' + acc + ' pool ' +
namenat + ' overload')

if nat == 'dynamic':

child.sendline(commands[2])
child.sendline('ip nat pool ' + namenat + ' ' + pubst + ' ' + pubend + '
netmask ' + pubsub)
child.sendline(commands[11] + acc + ' permit ' + prist + ' ' + priwild)
child.sendline(commands[16] + 'source list ' + acc + ' pool ' + namenat)
textbuffer.insert_at_cursor('ip nat pool ' + namenat + ' ' + pubst + ' ' +
pubend + ' netmask ' + pubsub)
textbuffer.insert_at_cursor(commands[11] + acc + ' permit ' + prist + ' ' +
priwild)
textbuffer.insert_at_cursor(commands[16] + 'source list ' + acc + ' pool ' +
namenat)

86
 child.sendline(commands[5] + ' ' + ethin)
child.sendline(commands[16])
child.sendline(commands[5] + ' ' + ethout)
child.sendline(commands[17])
txt_cmm.set_buffer(textbuffer)

if user == 11:

child.sendline(commands[2])
child.sendline('router ospf ' + process)
child.sendline('router-id ' + routerid1)
child.sendline('network ' + network1 + ' area ' + area1)
textbuffer.insert_at_cursor('router ospf ' + process + '\r' + 'router id ' + routerid1
+ '\r' + 'network ' + network1 + ' area' + area1)
txt_cmm.set_buffer(textbuffer)

if user == 12:

child.sendline(commands[2])
child.sendline('router eigrp ' + process)
child.sendline('eigrp router-id ' + routerid1)
child.sendline('network ' + network1 + ' ' + area1)
textbuffer.insert_at_cursor('router eigrp ' + process + '\r' + 'eigrp router id ' +
routerid1 + '\r' + 'network ' + network1 + area1)
txt_cmm.set_buffer(textbuffer)

if user == 13:

child.sendline(commands[2])
child.sendline(commands[pos] + netdes1 + ' ' + mask1 + ' ' + hop1)
textbuffer.insert_at_cursor(commands[pos] + netdes1 + ' ' + mask1 + ' ' + hop1)
txt_cmm.set_buffer(textbuffer)

child.sendcontrol('z')
child.sendline(commands[7])
child.interact()

# Función para la autenticación y envío de comandos al Router Quagga #################

def ingresar_quagga(textviewcmm , textviewcmm2 , txt_cmm):

global texto2,texto3,commands,pos,user,pos1,cmmsend,pos2
87
child = pexpect.spawn(commands[0] + '2601')
child.timeout = 0.5
child.expect('Password: ')
child.sendline(texto2)
child.sendline(commands[1])

if user == 1:

child.sendline(commands[pos])
textbuffer = Gtk.TextBuffer()
next_line = child.readline()
while next_line != '' :
print (next_line.strip())
textbuffer.insert_at_cursor(next_line.strip() + '\r')
textviewcmm.set_buffer(textbuffer)
try:
next_line = child.readline()

except pexpect.TIMEOUT:
pass
break

if user == 2:
child.sendline(commands[pos])

if user == 3:

child.sendline(commands[2])
child.sendline(commands[pos])
textbuffer3 = Gtk.TextBuffer()
textbuffer3.set_text(commands[pos] + '\r')
print commands[pos] + texto2
txt_cmm.set_buffer(textbuffer3)

if user == 4:

for i in range(0 , pos1):

child.sendline(cmmsend[i] + '\r')

textbuffer1 = Gtk.TextBuffer()
next_line = child.readline()
while next_line != '' :
print (next_line.strip())
88
 textbuffer1.insert_at_cursor(next_line.strip() + '\r')
textviewcmm2.set_buffer(textbuffer1)
try:
next_line = child.readline()

except pexpect.TIMEOUT:
pass
break

if user == 5:
child.sendline(commands[2])
textbuffer2 = Gtk.TextBuffer()
if len(texto1) > 0:
child.sendline(commands[3] + texto1)
textbuffer2.insert_at_cursor(commands[3] + texto1 +'\r')
txt_cmm.set_buffer(textbuffer2)
if len(texto3) > 0:
child.sendline(commands[4] + texto3)
texto2=texto3
textbuffer2.insert_at_cursor(commands[4] + texto3 + '\r')
txt_cmm.set_buffer(textbuffer2)
if len(texto4) > 0 and len(texto5) > 0:
child.sendline(commands[5] + texto4)
child.sendline(commands[6] + texto5)
textbuffer2.insert_at_cursor(commands[5] + texto4 + '\r' + commands[6]
+ texto5 + '\r')
txt_cmm.set_buffer(textbuffer2)

if user == 6:
child.sendline(commands[2])
textbuffer3 = Gtk.TextBuffer()
child.sendline(commands[11] + xentry_nAcl +' '+ commands[pos] +
xentry_addAcl +' ' + xentry_wildAcl )
textbuffer3.insert_at_cursor(commands[11] + xentry_nAcl +' '+ commands[pos]
+ xentry_addAcl +' ' + xentry_wildAcl )
txt_cmm.set_buffer(textbuffer3)

if user == 7:

child.sendline(commands[2])
textbuffer3 = Gtk.TextBuffer()
child.sendline(commands[11] + xentry_nAclx +' '+ commands[pos] +'ip '+
xentry_addsAclx +' ' + xentry_wildsAclx +' '+ xentry_adddAclx +' ' + xentry_wilddAclx)
89
 textbuffer3.insert_at_cursor(commands[11] + xentry_nAclx +' '+ commands[pos]
+'ip '+ xentry_addsAclx +' ' + xentry_wildsAclx +' '+ xentry_adddAclx +' ' + xentry_wilddAclx)
txt_cmm.set_buffer(textbuffer3)

if user == 8:

textbuffer3 = Gtk.TextBuffer()
child.sendline(commands[2])
child.sendline(commands[pos] + netdes + ' ' + mask + ' ' + hop)
textbuffer3.insert_at_cursor(commands[pos] + netdes + ' ' + mask + ' ' + hop)
txt_cmm.set_buffer(textbuffer3)

child.sendcontrol('z')
child.sendline(commands[7])
child.interact()

# Función de verificación credenciales ############################################

def acceder(window2, error, ventana_in, dialog_error, combox_prt, button_conf_nat,

button_conf_dhcp,ssh):

if flag == 0:

child = pexpect.spawn('ssh ' + text_user_ssh + '@' + text_address)

child.TIMEOUT = 0.5
child.expect('Password: ')
child.sendline(text_psw_ssh)
i = child.expect(['Password: ' , pexpect.TIMEOUT] , timeout = 4)

if i == 0:

error('Credenciles erradas')
print 'Credenciales erradas'
ssh.show_all()

if i == 1:

child.sendline(commands[7])
window2.show()
child.interact()

elif flag == 1:

90
 if texto_user_in == "admin":
child = pexpect.spawn(commands[0] + '2601')
child.TIMEOUT = 0.5
child.expect('Password: ')
child.sendline(texto2)
i = child.expect(['Password: ' , pexpect.TIMEOUT] , timeout = 1)

if i == 0:

error("La clave es errada")

print "La clave es errada"
ventana_in.show_all()

elif i == 1:
window2.show()
child.sendline(commands[1])
child.sendline(texto2)
child.sendline(commands[2])
child.sendline('no ' + commands[1] + commands[4])
child.sendcontrol('z')
child.sendline(commands[7])
combox_prt.hide()
dialog_error.hide()
button_conf_nat.hide()
button_conf_dhcp.hide()
child.interact()

else:
error("El usuario esto errado")
print "El usuario esta errado"
ventana_in.show_all()

#Clase Principal
class MainGui():

# Funcion que llama widgets desde interface gráfica y se ejecuta ventana inicial ##########

def __init__(self):
self.builder = Gtk.Builder()
self.builder.add_from_file("Proyecto3.glade")

manejadores = {

91
 "on_button_quagga_clicked": self.evento_quagga,
"on_window_in_destroy": self.event_close,
"on_button_cisco_clicked": self.evento_cisco,
"on_button_in_clicked": self.btt_in,
"on_button_sn2_clicked": self.on_button_sn2_clicked,
"on_button_cancel_clicked": self.btt_cancel,
"on_button_SSH_w_clicked": self.SSH_click,
"on_button_send1_clicked": self.send1_click,
"on_combobox_prot_changed": self.on_combox_prot,
"on_protocolo_delete_event": self.on_protocolo_delete,
"on_button_sendpro_clicked": self.sendpro_click,
"on_button_conf_dhcp_clicked": self.conf_dhcp_click,
"on_DHCP_delete_event":self.on_DHCP_delete_event,
"on_Acl_estandar_delete_event": self.on_Acl_estandar_delete_event,
"on_button_conf_acl_clicked": self.on_button_conf_acl_clicked,
"on_button_conf_nat_clicked": self.on_button_conf_nat_clicked,
"on_nat_overload_delete_event": self.on_nat_overload_delete_event,
"on_nat_static_delete_event": self.on_nat_static_delete_event,
"on_button_rqs1_clicked": self.on_button_rqs1_clicked,
"on_button_on_ipv6_clicked": self.on_button_on_ipv6_clicked,
"on_combobox_prot1_changed": self.on_combobox_prot1_changed,
"on_Acl_extendida_delete_event": self.on_Acl_extendida_delete_event,
"on_button_acl_estandar_clicked": self.on_button_acl_estandar_clicked,
"on_button_acl_extendida_clicked":
self.on_button_acl_extendida_clicked,
"on_button_ping_clicked": self.on_button_ping_clicked,
"on_button_tracert_clicked":self.on_button_tracert_clicked,
"on_ssh_delete_event": self.on_ssh_delete_event,
"on_button_dhcp_clicked": self.on_button_dhcp_clicked,
"on_button_nat_overload_clicked": self.on_button_nat_overload_clicked,
"on_button_static_clicked": self.on_button_static_clicked,
"on_button_sendpro1_clicked":self.on_button_sendpro1_clicked,
"on_protocolo1_delete_event": self.on_protocolo1_delete_event,
"on_button_acl_estandar1_clicked":
self.on_button_acl_estandar1_clicked,
"on_button_acl_extendida1_clicked":
self.on_button_acl_extendida1_clicked,
"on_Acl_estandar1_delete_event": self.on_Acl_estandar1_delete_event,
"on_Acl_extendida1_delete_event":
self.on_Acl_extendida1_delete_event,
"on_ventana_delete_event": self.on_ventana_delete_event,

"gtk_main_quit": self.gtk_main_quit
92
}

self.builder.connect_signals(manejadores)

self.window2 = self.builder.get_object("ventana")
self.notebook = self.builder.get_object("notebook")
self.textviewcmm = self.builder.get_object("textviewcmm")
self.textviewcmm2 = self.builder.get_object("textviewcmm2")
self.entry_cmm1 = self.builder.get_object("entry_cmm1")

self.entry_hs = self.builder.get_object("entry_hs")
self.entry_psw_st = self.builder.get_object("entry_psw_st")
self.entry_nm_int = self.builder.get_object("entry_nm_int")
self.entry_ip_int = self.builder.get_object("entry_ip_int")
self.txt_cmm = self.builder.get_object("text_cmm")
self.combox_prt = self.builder.get_object("combobox_prot")
self.combox_prt1 = self.builder.get_object("combobox_prot1")
self.combox3 = self.builder.get_object("combobox3")
self.combox4 = self.builder.get_object("combobox4")
self.combox5 = self.builder.get_object("combobox5")
self.button_conf_nat = self.builder.get_object("button_conf_nat")
self.button_conf_dhcp = self.builder.get_object("button_conf_dhcp")
self.radio_acl_stnd = self.builder.get_object("radio_acl_stnd")
self.radio_acl_extd = self.builder.get_object("radio_acl_extd")

self.protocolo = self.builder.get_object("protocolo")
self.overlay1 = self.builder.get_object("overlay1")
self.overlay2 = self.builder.get_object("overlay2")
self.overlay5 = self.builder.get_object("overlay5")
self.entry_routerid = self.builder.get_object("entry_routerid")
self.entry_net = self.builder.get_object("entry_net")
self.entry_area = self.builder.get_object("entry_area")
self.entry_netdes = self.builder.get_object("entry_netdes")
self.entry_mask = self.builder.get_object("entry_mask")
self.entry_hop = self.builder.get_object("entry_hop")
self.entry_netrip = self.builder.get_object("entry_netrip")
self.entry_version = self.builder.get_object("entry_version")

self.protocolo1 = self.builder.get_object("protocolo1")
self.overlay3 = self.builder.get_object("overlay3")
self.overlay4 = self.builder.get_object("overlay4")
self.overlay6 = self.builder.get_object("overlay6")
93
self.entry_routerid1 = self.builder.get_object("entry_routerid1")
self.entry_net1 = self.builder.get_object("entry_net1")
self.entry_area1 = self.builder.get_object("entry_area1")
self.entry_process = self.builder.get_object("entry_process")
self.entry_netdes1 = self.builder.get_object("entry_netdes1")
self.entry_mask1 = self.builder.get_object("entry_mask1")
self.entry_hop1 = self.builder.get_object("entry_hop1")
self.entry_netrip1 = self.builder.get_object("entry_netrip1")
self.entry_version1 = self.builder.get_object("entry_version1")
self.label_netwild = self.builder.get_object("label26")
self.label_area = self.builder.get_object("label72")
self.label_process = self.builder.get_object("label25")

self.entry_nAcl = self.builder.get_object("entry_nAcl")
self.entry_addAcl = self.builder.get_object("entry_addAcl")
self.entry_wildAcl = self.builder.get_object("entry_wildAcl")
self.radio_permit = self.builder.get_object("radio_permit")
self.radio_deny = self.builder.get_object("radio_deny")

self.entry_nAcl1 = self.builder.get_object("entry_nAcl1")
self.entry_addAcl1 = self.builder.get_object("entry_addAcl1")
self.entry_wildAcl1 = self.builder.get_object("entry_wildAcl1")
self.radio_permit1 = self.builder.get_object("radio_permit1")
self.radio_deny1 = self.builder.get_object("radio_deny1")
self.entry_intAcl = self.builder.get_object("entry_intAcl")
self.radio_inAcl = self.builder.get_object("radio_inAcl")
self.radio_outAcl = self.builder.get_object("radio_outAcl")

self.entry_nAclx = self.builder.get_object("entry_nAclx")
self.entry_addsAclx = self.builder.get_object("entry_addsAclx")
self.entry_wildsAclx = self.builder.get_object("entry_wildsAclx")
self.entry_adddAclx = self.builder.get_object("entry_adddAclx")
self.entry_wilddAclx = self.builder.get_object("entry_wilddAclx")
self.radio_permitx = self.builder.get_object("radio_permitx")
self.radio_denyx = self.builder.get_object("radio_denyx")

self.entry_nAclx1 = self.builder.get_object("entry_nAclx1")
self.entry_addsAclx1 = self.builder.get_object("entry_addsAclx1")
self.entry_wildsAclx1 = self.builder.get_object("entry_wildsAclx1")
self.combo_protAcl = self.builder.get_object("combo_protAcl")
self.combo_op1 = self.builder.get_object("combo_op1")
self.entry_ports = self.builder.get_object("entry_ports")
self.entry_adddAclx1 = self.builder.get_object("entry_adddAclx1")
94
self.entry_wilddAclx1 = self.builder.get_object("entry_wilddAclx1")
self.combo_op2 = self.builder.get_object("combo_op2")
self.entry_portd = self.builder.get_object("entry_portd")
self.entry_intAclx = self.builder.get_object("entry_intAclx")
self.radio_permitx1 = self.builder.get_object("radio_permitx1")
self.radio_denyx1 = self.builder.get_object("radio_denyx1")
self.radio_inAclx = self.builder.get_object("radio_inAclx")
self.radio_outAclx = self.builder.get_object("radio_outAclx")

self.entry_test = self.builder.get_object("entry_test")
self.text_ex = self.builder.get_object("text_ex")

self.entry_test = self.builder.get_object("entry_test")
self.txt_ex = self.builder.get_object("text_ex")

self.window = self.builder.get_object("ventana_inicio")

self.ventana_in = self.builder.get_object("window_in")
self.entry_psw = self.builder.get_object("entry_psw_in")
self.entry_user = self.builder.get_object("entry_user_in")
self.title_in = self.builder.get_object("title_in")

self.ssh = self.builder.get_object("ssh")
self.entry_address = self.builder.get_object("entry_address")
self.entry_user_ssh = self.builder.get_object("entry_user_ssh")
self.entry_psw_ssh = self.builder.get_object("entry_psw_ssh")
self.entry_cmm1 = self.builder.get_object("entry_cmm1")

self.dhcp = self.builder.get_object("DHCP")
self.entry_add_start = self.builder.get_object("entry_add_start")
self.entry_add_end = self.builder.get_object("entry_add_end")
self.entry_namepool = self.builder.get_object("entry_namepool")
self.entry_pooladd_start = self.builder.get_object("entry_pooladd_start")
self.entry_pooladd_end = self.builder.get_object("entry_pooladd_end")
self.entry_gateway = self.builder.get_object("entry_gateway")

self.Acl_estandar = self.builder.get_object("Acl_estandar")
self.Acl_extendida = self.builder.get_object("Acl_extendida")
self.Acl_estandar1 = self.builder.get_object("Acl_estandar1")
self.Acl_extendida1 = self.builder.get_object("Acl_extendida1")

self.nat_overload = self.builder.get_object("nat_overload")
self.nat_static = self.builder.get_object("nat_static")
95
 self.radio_dynamic = self.builder.get_object("radio_dynamic")
self.radio_static = self.builder.get_object("radio_static")
self.entry_pubstart = self.builder.get_object("entry_pubstart")
self.entry_pubend = self.builder.get_object("entry_pubend")
self.entry_pubsubmask = self.builder.get_object("entry_pubsubmask")
self.entry_pristart = self.builder.get_object("entry_pristart")
self.entry_priwild = self.builder.get_object("entry_priwild")
self.entry_ethin = self.builder.get_object("entry_ethin")
self.entry_ethout = self.builder.get_object("entry_ethout")
self.entry_ippriv = self.builder.get_object("entry_ippriv")
self.entry_ippub = self.builder.get_object("entry_ippub")
self.entry_ethinst = self.builder.get_object("entry_ethinst")
self.entry_ethoutst = self.builder.get_object("entry_ethoutst")
self.entry_nacc_nat = self.builder.get_object("entry_nacc_nat")
self.entry_namenat = self.builder.get_object("entry_namenat")
self.check_overload = self.builder.get_object("check_overload")

self.dialog_error = Gtk.MessageDialog(parent=None, flags=0)

self.combox_prt.set_active(0)
self.combox_prt1.set_active(0)
self.combo_op1.set_active(0)
self.combo_op2.set_active(0)
self.combo_protAcl.set_active(0)

self.window.show_all()

# Función que despliega ventana para ingreso credenciales Router Cisco ################

def evento_cisco(self,widget):

global flag
flag = 0
self.title_in.set_text("AUTORIZACION ROUTER CISCO")
self.ssh.show()
self.window.hide()
self.dialog_error.hide()

# Función que despliega ventana para ingreso credenciales Router Quagga ##############

def evento_quagga(self,widget):

global flag
96
 flag = 1
self.title_in.set_text("AUTORIZACION ROUTER QUAGGA")
self.ventana_in.show()
self.window.hide()
self.dialog_error.hide()

# Función que captura y envía los comandos iniciales ################################

def on_button_sn2_clicked(self, widget):

global user,texto1,texto3,texto4,texto5
user = 5
texto3 = self.entry_psw_st.get_text()
texto1 = self.entry_hs.get_text()
texto4 = self.entry_nm_int.get_text()
texto5 = self.entry_ip_int.get_text()

if flag == 0:
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

if flag == 1:
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

# Función de consulta configuración inicial ########################################

def on_button_rqs1_clicked(self, widget):

global pos , pos2 , user , flag

pos=10
user=1
if flag == 0:
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
if flag == 1:
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

# Función de ejecución del cierre de la ventana inicial ###############################

def on_ventana_delete_event (self, widget, event, data=None):

self.window2.hide()
self.window.show()
return True
97
# Función de envío de comandos manual #########################################

def send1_click(self , widget):

global cmmsend , pos1 , user

user = 4
cmmsend.append(self.entry_cmm1.get_text())
self.entry_cmm1.set_text('')
pos1=pos1+1
if flag == 0:
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
if flag == 1:
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

# Función de ejecución del botón cancelar #######################################

def btt_cancel(self, widget):

self.ventana_in.hide()
self.window.show_all()

# Función de ejecución del botón ingresar #########################################

def btt_in(self, widget):

global texto_psw_in , texto_user_in , texto2

texto_psw_in = self.entry_psw.get_text()
texto_user_in = self.entry_user.get_text()
texto2 = self.entry_psw.get_text()
self.ventana_in.hide()
acceder(self.window2, self.error, self.ventana_in, self.dialog_error,
self.combox_prt, self.button_conf_nat, self.button_conf_dhcp, self.ssh)

# Función de ejecución del cierre de la ventana de ingreso ###########################

def event_close(self, widget, event, data=None):

self.ventana_in.hide()
self.window.show_all()
return True

98
#Función de ejecución del botón para el envio SSH ##################################

def SSH_click(self, widget):

global text_address , text_user_ssh , text_psw_ssh

text_address = self.entry_address.get_text()
text_user_ssh = self.entry_user_ssh.get_text()
text_psw_ssh = self.entry_psw_ssh.get_text()
self.ssh.hide()
acceder(self.window2, self.error, self.ventana_in, self.dialog_error,
self.combox_prt, self.button_conf_nat, self.button_conf_dhcp, self.ssh)

# Función de ejecución del cierre de la ventana SSH ################################

def on_ssh_delete_event(self, widget, event, data=None):

self.window.show()
self.ssh.hide()
return True

# Función de activacion enrutamiento ipv6 #######################################

def on_button_on_ipv6_clicked(self, widget):

global pos, user

user = 3
pos = 9
if flag == 0:
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
if flag == 1:
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

# Función de seleccion del protocolo a configurar en Router Cisco ####################

def on_combox_prot(self, widget):

global prot1
selec = valor_combobox(self.combox_prt)

if selec == "RIPv1" or selec == "RIPv2":

self.protocolo1.show()
99
 self.overlay3.hide()
self.overlay4.hide()
self.overlay6.show()

elif selec == "OSPF" :

self.protocolo1.show()
self.label_netwild.set_text("Network/Wildcard")
self.label_area.set_text("Area")
self.label_process.set_text("Proceso")
self.overlay3.hide()
self.overlay4.show()
self.overlay6.hide()

elif selec == "EIGRP":

self.protocolo1.show()
self.label_netwild.set_text("Network")
self.label_area.set_text("Wildcard")
self.label_process.set_text("AS")
self.overlay3.hide()
self.overlay4.show()
self.overlay6.hide()

elif selec == "ESTATICO":

self.protocolo1.show()
self.overlay3.show()
self.overlay4.hide()
self.overlay6.hide()

prot1 = selec

# Función de seleccion del protocolo a configurar en Router Quagga ###################

def on_combobox_prot1_changed(self, widget):

global prot
selec = valor_combobox(self.combox_prt1)
if selec == "RIP":
self.protocolo.show()
self.overlay1.hide()
self.overlay2.hide()
100
 self.overlay5.show()

if selec == "OSPF":
self.protocolo.show()
self.overlay1.hide()
self.overlay2.show()
self.overlay5.hide()

elif selec == "ESTATICO":

self.protocolo.show()
self.overlay1.show()
self.overlay2.hide()
self.overlay5.hide()

prot = selec

# Función de ejecución del cierre de la ventana del protocolo de enrumientamiento Cisco ##

def on_protocolo_delete(self, widget, event, data=None):

self.protocolo.hide()
return True

# Función de envio parámetros para la configuración del protocolo de enrutamiento Quagga

def sendpro_click(self, widget):

global pos , user , routerid , network , area , netdes , mask , hop , netrip , version ,
prot

netdes = self.entry_netdes.get_text()
mask = self.entry_mask.get_text()
hop = self.entry_hop.get_text()
routerid = self.entry_routerid.get_text()
network = self.entry_net.get_text()
area = self.entry_area.get_text()
netrip = self.entry_netrip.get_text()
version = self.entry_version.get_text()

if prot == 'ESTATICO':

user = 8
pos = 14
101
 ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

elif prot == 'OSPF' or prot == 'RIP':

Enviar_protocolo(self.txt_cmm)

self.protocolo.hide()
return True

# Función de envio parámetros para la configuración del protocolo de enrutamiento Cisco #

def on_button_sendpro1_clicked(self, widget):

global pos , user , routerid1 , network1 , area1 , process , netdes1 , mask1 , hop1
, netrip1 , version1 , prot , verrip

netdes1 = self.entry_netdes1.get_text()
mask1 = self.entry_mask1.get_text()
hop1 = self.entry_hop1.get_text()
routerid1 = self.entry_routerid1.get_text()
network1 = self.entry_net1.get_text()
area1 = self.entry_area1.get_text()
netrip1 = self.entry_netrip1.get_text()
version1 = self.entry_version1.get_text()
process = self.entry_process.get_text()

if prot1 == 'RIPv1':

user = 8
pos = 18
verrip = 1

ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

elif prot1 == 'RIPv2':

user = 8
pos = 18
verrip = 2

ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

elif prot1 == 'OSPF':

102
 user = 11
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

elif prot1 == 'EIGRP':

user = 12
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

elif prot1 == 'ESTATICO':

user = 13
pos = 14
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

self.protocolo1.hide()
return True

# Función de ejecución del cierre de la ventana del protocolo de enrutamiento Quagga ##

def on_protocolo1_delete_event(self, widget, event, data=None):

self.protocolo1.hide()
return True

# Función de envío parámetros Acl Estándar Quagga ##############################

def on_button_acl_estandar_clicked(self, widget):

global pos, user , xentry_nAcl , xentry_addAcl , xentry_wildAcl , xentry_intAcl

user = 6
xentry_nAcl = self.entry_nAcl.get_text()
xentry_addAcl = self.entry_addAcl.get_text()
xentry_wildAcl = self.entry_wildAcl.get_text()

if self.radio_permit.get_active():

pos = 12

if self.radio_deny.get_active():

pos = 13
103
 ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
self.Acl_estandar.hide()
return True

# Función de envío parámetros Acl Extendida Quagga ##############################

def on_button_acl_extendida_clicked(self, widget):

global pos, user , xentry_nAclx , xentry_addsAclx , xentry_wildsAclx ,

xentry_adddAclx , xentry_wilddAclx
user = 7
xentry_nAclx = self.entry_nAclx.get_text()
xentry_addsAclx = self.entry_addsAclx.get_text()
xentry_wildsAclx = self.entry_wildsAclx.get_text()
xentry_adddAclx = self.entry_adddAclx.get_text()
xentry_wilddAclx = self.entry_wilddAclx.get_text()

if self.radio_permitx.get_active():

pos = 12

if self.radio_denyx.get_active():

pos = 13

ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

self.Acl_extendida.hide()
return True

# Función de envío parámetros Acl Estándar Cisco ###############################

def on_button_acl_estandar1_clicked(self, widget):

global pos, user , nAcl1 , addAcl1 , wildAcl1 , intAcl , interAcl

user = 6
nAcl1 = self.entry_nAcl1.get_text()
addAcl1 = self.entry_addAcl1.get_text()
wildAcl1 = self.entry_wildAcl1.get_text()
intAcl = self.entry_intAcl.get_text()

if self.radio_permit1.get_active():
104
 pos = 12

if self.radio_deny1.get_active():

pos = 13

if self.radio_inAcl.get_active():

interAcl = ' in'

if self.radio_outAcl.get_active():

interAcl = ' out'

ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

self.Acl_estandar1.hide()
return True

# Función de envío parámetros Acl Extendida Cisco #################################

def on_button_acl_extendida1_clicked(self, widget):

global pos, user , nAclx1 , addsAclx1 , wildsAclx1 , adddAclx1 , wilddAclx1 , ports ,

portd , intAclx , interAclx , selprot , selop1 , selop2
user = 7
nAclx1 = self.entry_nAclx1.get_text()
addsAclx1 = self.entry_addsAclx1.get_text()
wildsAclx1 = self.entry_wildsAclx1.get_text()
adddAclx1 = self.entry_adddAclx1.get_text()
wilddAclx1 = self.entry_wilddAclx1.get_text()
ports = self.entry_ports.get_text()
portd = self.entry_portd.get_text()
intAclx = self.entry_intAclx.get_text()

selprot = valor_combobox(self.combo_protAcl)
selop1 = valor_combobox(self.combo_op1)
selop2 = valor_combobox(self.combo_op2)

if selop1 == 'OPERADOR':
selop1 = ''
ports = ''
if selop2 == 'OPERADOR':
105
 selop2 = ''
portd = ''
if self.radio_permitx1.get_active():
pos = 12

if self.radio_denyx1.get_active():
pos = 13

if self.radio_inAclx.get_active():
interAclx = ' in'

if self.radio_outAclx.get_active():
interAclx = ' out'

ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

self.Acl_extendida1.hide()
return True

# Función de ejecución ventana DHCP ############################################

def conf_dhcp_click(self, widget):

self.dhcp.show_all()

# Función de envío parámetros de configuración DHCP ##############################

def on_button_dhcp_clicked(self, widget):

global user, add_start, add_end, name_pool, pooladd_start, pooladd_end,

gateway

add_start = self.entry_add_start.get_text()
add_end = self.entry_add_end.get_text()
name_pool = self.entry_namepool.get_text()
pooladd_start = self.entry_pooladd_start.get_text()
pooladd_end = self.entry_pooladd_end.get_text()
gateway = self.entry_gateway.get_text()\

user = 9

ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

self.dhcp.hide()
return True
106
# Función de ejecución del cierre de la ventana DHCP ###############################

def on_DHCP_delete_event (self, widget, event, data=None):

self.dhcp.hide()
return True

# Función de selección de tipo de Acl #############################################

def on_button_conf_acl_clicked(self, widget):

global flag
if flag == 0:
if self.radio_acl_stnd.get_active():
self.Acl_estandar1.show_all()
if self.radio_acl_extd.get_active():
self.Acl_extendida1.show_all()
if flag == 1:
if self.radio_acl_stnd.get_active():
self.Acl_estandar.show_all()
if self.radio_acl_extd.get_active():
self.Acl_extendida.show_all()

# Función de ejecución de cierre de la ventana Acl Estándar ##########################

def on_Acl_estandar_delete_event(self, widget, event, data=None):

self.Acl_estandar.hide()
return True

# Función de ejecución del cierre de la ventana Acl Extendida #########################

def on_Acl_extendida_delete_event(self, widget, event, data=None):

self.Acl_extendida.hide()
return True

# Función de ejecución del cierre de la ventana Acl Estándar Quagga ###################

def on_Acl_estandar1_delete_event(self, widget, event, data=None):

self.Acl_estandar1.hide()
107
 return True

# Función de ejecución del cierre de la ventana Acl Extendida Quagga ##################

def on_Acl_extendida1_delete_event(self, widget, event, data=None):

self.Acl_extendida1.hide()
return True

# Función de ejecución de la ventana Nat #########################################

def on_button_conf_nat_clicked(self, widget):

if self.radio_dynamic.get_active():
self.nat_overload.show_all()

if self.radio_static.get_active():
self.nat_static.show_all()

# Función de ejecución de la ventana Nat de Sobrecarga #############################

def on_button_nat_overload_clicked(self, widget):

global user , nat , pubst , pubend , pubsub , prist , priwild , ethin , ethout ,
namenat , acc

pubst = self.entry_pubstart.get_text()
pubend = self.entry_pubend.get_text()
pubsub = self.entry_pubsubmask.get_text()
prist = self.entry_pristart.get_text()
priwild = self.entry_priwild.get_text()
ethin = self.entry_ethin.get_text()
ethout = self.entry_ethout.get_text()
acc = self.entry_nacc_nat.get_text()
namenat = self.entry_namenat.get_text()
if self.check_overload.get_active():
nat = 'dynamic overload'
else:
nat = 'dynamic'
user = 10

ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

108
 self.nat_overload.hide()
return True

# Función de envío comandos configuración Nat estático #############################

def on_button_static_clicked(self, widget):

global user , ippriv , ippub , ethin , ethout , nat

ippriv = self.entry_ippriv.get_text()
ippub = self.entry_ippub.get_text()
ethin = self.entry_ethinst.get_text()
ethout = self.entry_ethoutst.get_text()
user = 10
nat = 'static'
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)

self.nat_static.hide()
return True

# Función de ejecución del cierre de la ventana nat dinámica #########################

def on_nat_overload_delete_event(self, widget, event, data=None):

self.nat_overload.hide()
return True

# Función de ejecución del cierre de la ventana nat estática ##########################

def on_nat_static_delete_event(self, widget, event, data=None):

self.nat_static.hide()
return True

# Función de ejecución ping ####################################################

def on_button_ping_clicked(self, widget):

textbuffer4 = Gtk.TextBuffer()
text_ping = self.entry_test.get_text()
p = pexpect.spawn('ping '+ text_ping)

109
 next_line = p.readline()
q=0
while next_line != '' :
print (next_line.strip())
textbuffer4.insert_at_cursor(next_line.strip() + '\r')
self.text_ex.set_buffer(textbuffer4)
next_line = p.readline()
if q == 4:
p.sendcontrol('z')
break
q=q+1

# Función de ejecución tracert ##################################################

def on_button_tracert_clicked(self, widget):

textbuffer4 = Gtk.TextBuffer()
text_ping = self.entry_test.get_text()
p = pexpect.spawn('traceroute '+ text_ping)
next_line = p.readline()

while next_line != '' :

print (next_line.strip())
textbuffer4.insert_at_cursor(next_line.strip() + '\r')
self.text_ex.set_buffer(textbuffer4)
next_line = p.readline()

# Función de ejecución de destruccion de la ventana y cierre de la ejecución #############

def gtk_main_quit(self, *args):

Gtk.main_quit(*args)

# Función de ejecución ventana de error ##########################################

def error(self,message):

global flag
"Display the error dialog "
self.dialog_error = Gtk.MessageDialog(parent=None, flags=0)
self.dialog_error.set_title("Error")
label = Gtk.Label(message)
self.dialog_error.vbox.pack_start(label, True, True, 0)
110
 button = Gtk.Button(stock=Gtk.STOCK_OK)
if flag == 0:
button.connect("clicked", self.evento_cisco)
if flag == 1:
button.connect("clicked", self.evento_quagga)
self.dialog_error.vbox.pack_start(button, False, False, 0)

# Con show_all() mostramos el contenido del cuadro de dialogo (en este #######
# caso solo tiene la etiqueta) si no se hace el dialogo aparece vacío ############
self.dialog_error.show_all()
# El run y destroy hace que la ventana se cierre al apretar el botón ############
self.dialog_error.run()
self.dialog_error.hide()
#self.evento_quagga()

#Función de ejecución del programa inicial ######################################

def main():
window = MainGui()
Gtk.main()
return 0

if __name__ == '__main__':
main()

111