Direcciones, clases, redes y máscaras

En los primeros años de Internet, las propias direcciones IP contenían cierta información que permitían identificar fácilmente la red a la que pertenecían. Así pues, las direcciones IP se dividían en varias clases dependiendo del valor de los bits más significativos de la IP:

  • Clase A: IPs en el rango 0.0.0.0-127.255.255.255
  • Clase B: IPs en el rango 128.0.0.0-191.255.255.255
  • Clase C: IPs en el rango 192.0.0.0-223.255.255.255

Si pasamos a binario los rangos de cada una de estas clases observaremos que los bits más significativos de cada clase siguen un determinado patrón. En concreto, todas las direcciones de clase A comienzan con 0…, las redes de clase B empiezan con 10… y las redes de clase C con 110… Nótese, que hemos dejado un rango IP sin asignar (224.0.0.0-255.255.255.255). En realidad este rango incluye dos clases adicionales: D y E. La primera de estas clases (comienza con 1110…) se utilizaba para direcciones multicast y la segunda (comienza con 1111…) estaba reservado.

Además, cada una de estas clases podía albergar a un número de equipos diferente. Las direcciones IP de clase A utilizaban los 8 primeros bits para identificar a la red y los 24 restantes para identificar equipos dentro de esa red. Por lo que descontando el primer bit, que se usaba para identificar la clase, teníamos 2^7 = 128 redes de clase A, cada una de las cuales podía albergar hasta 2^24 = 16777216 equipos. De la misma forma, las redes de clase B utilizaban los 16-2 primeros bits para identificar la red y los 16 restante para equipos y, por último, las redes de clase C utilizaban 24-3 bits para identificar redes y 8 para equipos dentro de cada una de esas redes.

Por tanto, cuando una empresa u organización necesitaba tener visibilidad en Internet, se le asignaba una red de una determinada clase. La red que se le asignaba dependía de las necesidades de la organización. Así pues, se asignaban redes de clase A a gobiernos y empresas de gran tamaño, ya que podían albergar más de 16 millones de equipos. Aún así, muchas de estas direcciones IP quedaban sin asignar y lo mismo ocurría en redes de clase B y C.

Este desaprovechamiento de IPs supuso, con el tiempo, un cambio en la forma de asignar redes. Del direccionamiento basado en clases se pasó al direccionamiento sin clases (CIDR: Classless Inter-Domain Routing), que utilizaba máscaras para identificar la parte de la dirección IP correspondiente a la red y la parte correspondiente a equipos.

Una máscara no son más que una secuencia de 32 bits que comienza por una serie de 1’s seguida de una serie de 0’s, de tal manera que los bits a 1 indican la red a la que pertenece la IP y la parte a 0 indica el host dentro de esa red. Las máscaras se pueden representar como un numero natural o bien en notación punto decimal, al igual que las direcciones IP. Por ejemplo, la máscara 255.255.255.128 tiene los primeros 25 bits a 1 y los 7 restantes a 0, por lo que se trata de una máscara de 25 bits y puede representarse también de la siguiente forma: /25.

Dada una dirección IP y su máscara podemos conocer la red a la que pertenece aplicando sencillas operaciones lógicas a nivel de bit. En concreto, la dirección de red se puede obtener mediante la operación AND bit a bit de la dirección IP y la máscara. Sea, por ejemplo, la dirección IP 172.16.5.34 con máscara de red 255.255.255.192, o lo que es lo mismo 172.16.5.34/26, la dirección de red a la que pertenece este equipo es la 172.16.5.0. Veamos por qué:

(IP)   172.16.5.34     --> 1010 1100.0001 0000.0000 0101.0010 0010
(MASC) 255.255.255.192 --> 1111 1111.1111 1111.1111 1111.1100 0000   (AND)
--------------------------------------------------------------
(RED)  172.16.5.0      <-- 1010 1100.0001 0000.0000 0101.0000 0000

De manera similar, dada una dirección IP y su máscara podemos conocer la dirección IP de broadcast. La dirección de broadcast es una dirección especial que permite a un equipo enviar paquetes IP a todos los nodos de la red. La dirección de broadcast se obtiene haciendo la operación OR bit a bit de la dirección de red y la máscara invertida. Así, pues si para 172.16.5.34/26 la dirección de red es 172.16.5.0, la dirección de broadcast sería la 172.16.5.63. Más en detalle:

(MASC) 255.255.255.192 --> 1111 1111.1111 1111.1111 1111.1100 0000   (~)
--------------------------------------------------------------
(~MASC)                <-- 0000 0000.0000 0000.0000 0000.0011 1111
(RED)  172.16.5.0      --> 1010 1100.0001 0000.0000 0101.0000 0000   (OR)
--------------------------------------------------------------
(BCAST)172.16.5.63     <-- 1010 1100.0001 0000.0000 0101.0011 1111

Se puede comprobar que con una máscara de 24 bits tendríamos una red con características muy similares a las redes de clase C tradicionales, con un máscara de 16 bits tendríamos una similar a una red clase B clásica y con una de 8 bits, tendríamos una red similar a una clase A. La diferencia principal radica en que con la notación CIDR, la IP menos significativa del rango se utiliza para identificar a la red y no puede ser asignada a ningún equipo. Por lo que se siempre se “pierde” una IP en cada subred, la que identifica a la dirección de red. Esto no ocurría con direcciones classfull tradicionales. En ambos casos, se utiliza una dirección de broadcast, que será la más significativa dentro del rango.

Como el número de direcciones IP dentro de una red viene determinado por la máscara, si queresmos diseñar una red aprovechando al máximo el rango de IPs, debemos tener en cuenta que dos de esas direcciones no pueden ser asignadas a equipos (la dirección de red y la dirección de broadcast). Es decir, en una red con máscara de 25 bits, tendremos 7 bits para direcciones dentro de esa red, es decir, 2^7 = 128 direcciones. Por lo que en una red con esta máscara podríamos tener un máximo de 128-2 equipos.

Anuncios

Acelerando el Emulador de Android

El emulador de Android puede llegar a ser extremadamente lento. Esto se debe esencialmente a que se trata de emular un procesador ARM sobre una arquitectura x86. Sin embargo, para la mayoría de desarrolladores esto es innecesario y conlleva un sobrecoste demasiado elevado.

Si contamos con un procesador Intel podemos acelerar el emulador utilizando las imágenes Intel x86 que hay disponibles para las distintas APIs e instalando el paquete Intel x86 Emulator Accelerator (HAXM installer), como se puede ver en la figura que mostramos a continuación:

sdk packets

Para comprobar si el módulo está instalado podemos utilizar el siguiente comando desde la terminal (en Mac):

$ kextstat | grep intel

Si el paquete esta correctamente instalado el comando ofrecerá información sobre el módulo com.intel.kext.intelhaxm. En caso de no obtener ninguna significa que el paquete no está aún instalado (únicamente se ha descargado el instalador). En este punto es necesario moverse a la carpeta donde tengamos el Android SDK y navegar hasta “sdk/extras/intel/Hardware_Accelerated_Execution” donde se encuentra el instalador IntelHAXM_1.0.8.dmg
Durante el proceso de instalación de Intel HAXM debemos asegurarnos de que reservamos memoria suficiente para el tipo de dispositivo que queremos emular. Por ejemplo, si queremos emular un Nexus5 con 2048MB de RAM deberemos reservar al menos esa cantidad.

haxm

En caso de reservar una cantidad de memoria insuficiente, el acelerador no se ejecutará y obtendremos un mensaje de error similar a este:

emulator: The memory needed by this VM exceeds the driver limit.
HAX is not working and emulator runs in emulation mode


Obtener datos de figuras MatLab

En alguna ocasión me ha ocurrido que he guardado una figura MatLab (.fig) pero no el código con el que la generé originalmente. Si más adelante quieres utilizar esos datos para generar una nueva gráfica o cualquier otra cosa necesitas recuperar esos datos. A continuación se explica cómo hacerlo:

  1. Es necesario abrir la figura cuyos datos queremos extraer. Esto se puede hacer a través del interfaz gráfico (con doble click) o bien mediante el comando open
    open figura.fig
    
  2. Una vez abierta la figura, es necesario obtener la referencia (handle) a la figura para lo cual utilizamos el comando gcf
    h = gcf;
    
  3. Obtenemos una referencia a los ejes de la figura mediante la función comando get(·)
    cAxes = get(h, 'CurrentAxes');
    

    Las figuras en MatLab son estructuras de datos entre los cuales se encuentra el nombre, el tipo de papel, la posición, etc. De entre estas propiedades la que nos interesa es ‘CurrentAxes’. Esta propiedad alberga todo lo relativo a cada uno de los ejes, incluidos los datos.
    Nota: La función get(h) permite consultar las propiedades de una referencia h.

  4. Seguidamente, los datos de cada uno de los ejes están contenidos en la propiedad ‘Children’ y a su vez en ‘XData’, ‘YData’ y ‘ZData’. De manera que podemos acceder a estos datos haciendo lo siguiente:
    cData = get(cAxes, 'Children');
    XData = get(cData, 'XData');
    YData = get(cData, 'YData');
    ZData = get(cData, 'ZData');
    

A continuación, se propone una versión completa en la que se unifican los pasos 2 y 3 gracias al comando gca, que permite obtener los ejes de la figura actual.

open figura.fig
cData = get(gca, 'Children');
XData = get(cData, 'XData');
YData = get(cData, 'YData');
ZData = get(cData, 'ZData');

Manejo de variables en Ruby (accessors)

En muchos lenguajes de programación es necesario definir métodos para permitir el acceso y modificación de las variables de una instancia. En Ruby estos métodos pueden definirse de la siguiente forma:

# Acceso: Devuelve el valor de la variable X
def getVariableX
    @X
end
# Modificación: Cambia el valor de la variable X
def setVariableX (value)
    @X = value
end

Ruby proporciona una forma más cómoda y simplificada de definir estos métodos mediante las siguientes construcciones:

attr_reader :X   #genera el método de acceso
attr_writer :X   #genera al método de modificación
attr_accessor :X #genera ambos métodos

Es interesante tener en cuenta que definir una variable con acceso de escritura (writer) no implica lectura (reader). Por tanto, si queremos tener acceso de lectura/escritura debemos definir ambas construcciones o bien usar attr_accessor.


Desplegar un archivo .war en Tomcat

Los archivos .war (Web Application Archive) son aplicaciones web basadas en Java. Estos archivos tienen paginas jsp, html, javascript, servlets y otros ficheros necesarios para el despliegue de estas aplicaciones en contenedores web como el proporcionado por Tomcat.

Existen diversas formas de instalar estos archivos en Tomcat pero quizá la más rápida sea mediante línea de comandos. Para ello basta con tres sencillos pasos:

  1. Copiamos el archivo al directorio webapps 
     sudo cp archivo.war $CATALINA_BASE/webapps
  2. En caso de ser necesario, añadimos usuarios y roles para la aplicación
     sudo nano $CATALINA_BASE/conf/tomcat-users.xml
  3. Reiniciamos Tomcat
     sudo /etc/init.d/tomcat restart

La necesidad de realizar el paso 2 viene determinado por la existencia de security constraints en el fichero /WEB-INF/web.xml de la aplicación. Para más información más detallada se puede ver el consejo número 5 de O’reilly o acudir aquí.


Instalación de Tomcat 7 en Ubuntu 12.04

Apache Tomcat es un servidor web de código abierto con soporte para aplicaciones web basadas en Java (servlets y páginas JSP). Los pasos a realizar para instalar este servidor en Ubuntu son los siguientes:

  • Instalar los paquetes de Tomcat7
sudo apt-get install tomcat7
  • Instalar Java Development Kit
sudo apt-get install default-jdk
  • Declarar algunas variables de entorno requeridas por Tomcat en $CATALINA_BASE/bin/setenv.sh (como se sugiere en $CATALINA_HOME/bin/catalina.sh). El contenido del fichero setenv.sh será el siguiente:
export JAVA_HOME=/usr/lib/jvm/default-java
export CATALINA_HOME=/usr/share/tomcat7
export CATALINA_BASE=/var/lib/tomcat7

Esto es necesario para poder ejecutar como root el siguiente paso. Otra opción sería definir estar variables de entorno en el fichero .bashrc del usuario root (no basta con hacerlo para un usuario sin privilegios de administrador). O bien definier estas variables en el .bashrc del usuario y que este lance el script siguiente con la opción -E (i.e., sudo -E, para que se utilicen las variables de entorno del usuario)

  • Lanzar el script de Tomcat para comprobar que todo es correcto
sudo $CATALINA_HOME/bin/startup.sh

Gráficos en MatLab

MatLab es una herramienta muy potente para representar figuras y proporciona varios formatos para visualizar datos en 2D como 3D. A modo de resumen las más importantes son: