Correcciones gramaticales, espanol, ingles y codigos

README-en.md

 
 ### Classes
 
-A class is a description of the data and processes of an object. The class’s declaration establishes the attributes that each of the objects of the class will have, and the methods that it can invoke.
+A class is a description of the data and processes of an object. The class declaration establishes the attributes that each of the objects of the class will have, and the methods that it can invoke.
 
 The attributes and methods of a class can have one the following levels of access: private, protected and public. An object's **public** data members can be read or modified by any function that has access to the object (including external functions). An object's **private** data members can only be read or modified through the object's **member** functions .  Unless specified otherwise, the attributes and methods defined in a class will be **private**.  Protected members allow read/write access from member functions and those of inherited classes. 
 
 
 A packet sniffer (also known as packet analyzer - protocol analyzer - or network analyzer) is a computer program that can intercept and log traffic passing over a digital network, or network device. As data flows across the network, the sniffer captures each packet and, if needed, decodes the packet's raw data[1].
 
-Each packet captured by a sniffer has a structure similar to the ilustration in Figure 1.
+Each packet captured by a sniffer has a structure similar to the illustration in Figure 1.
 
 ---
 
 
 In this laboratory experience, you will complete a simple packet sniffer that captures all the IP packets that flow through your laboratory computer, and some additional information of the packets.  Additionally, it detects the non encrypted requests of images in the web, and displays the images in the GUI.
 
-For the purposes of this lab, we will think of TIP packets as being a *specialization* of Ethernet packets.  As such, it is a good strategy to implement the IP packet as class that is *derived* from the Ethernet packet class through inheritance. Thus, the IP packet class will have all the data members and methods of the Ethernet class (for example, source and destination MAC addresses) plus additional data members and methods that apply specifically to IP Packets (for example source and destination ports).
+For the purposes of this lab, we will think of IP packets as being a *specialization* of Ethernet packets.  As such, it is a good strategy to implement the IP packet as class that is *derived* from the Ethernet packet class through inheritance. Thus, the IP packet class will have all the data members and methods of the Ethernet class (for example, source and destination MAC addresses) plus additional data members and methods that apply specifically to IP Packets (for example source and destination ports).
 
 
 ---
 
 ## References
 
-[1] http://en.wikipedia.org/wiki/Packet_analyzer
+[1] http://en.wikipedia.org/wiki/Packet_analyzer

README-es.md

 
 Una clase es una descripción de los datos y procesos de un objeto. La declaración de una clase establece los atributos que tendrá cada objeto de esa clase y los métodos que pueden invocar.
 
-Los atributos y métodos de una clase pueden tener uno de los siguientes niveles de acceso: *private*, *protected* y *public*. Los miembros de datos que se declaran **public** pueden ser leidos y modificados desde cualquier función (inclusive de funciones externas). Los miembros de datos **private** solo pueden ser leidos o modificados por las funciones miembro de la clase. Si no se especifica lo contrario, los atributos y métodos definidos en una clase serán privados. Los miembros de datos **protected** solo pueden ser leidos/modificados por funciones miembro de la clase o de clases hijas. 
+Los atributos y métodos de una clase pueden tener uno de los siguientes niveles de acceso: *private*, *protected* y *public*. Los miembros de datos que se declaran **public** pueden ser leídos y modificados desde cualquier función (incluso de funciones externas). Los miembros de datos **private** solo pueden ser leídos o modificados por las funciones miembro de la clase. Si no se especifica lo contrario, los atributos y métodos definidos en una clase serán privados. Los miembros de datos **protected** solo pueden ser leídos/modificados por funciones miembro de la clase o de clases hijas. 
 
 Lo siguiente es el esqueleto de la declaración de una clase:
 
 
 ## Comunicación entre computadoras
 
-Las computadoras se comunican por medio del Internet utilizando el *Protocolo de Internet* (IP - por sus siglas en inglés). Cuando una computadora envía información a otra computadora, la información se envía por *Paquetes de Internet* que contienen la *dirección fuente* ("source address"), que es la dirección de Internet de la computadora que está enviando la información, y la *dirección destino* ("destination address"), que es la dirección de Internet de la computadora que debe recibir el mensaje. Las direcciones de Internet se usan para guiar la información de una computadora a otra, pero una vez el paquete llega a su destino, ¿quién se supone que reciba la información? ¿Cuál aplicación debe recibir la información?
+Las computadoras se comunican por medio del Internet utilizando el *Protocolo de Internet* (IP - por sus siglas en inglés). Cuando una computadora envía información a otra computadora, la información se envía por *Paquetes de Internet* que contienen la *dirección fuente* ("source address"), que es la dirección de Internet de la computadora que está enviando la información, y la *dirección destino* ("destination address"), que es la dirección de Internet de la computadora que debe recibir el mensaje. Las direcciones de Internet se usan para guiar la información de una computadora a otra, pero una vez el paquete llega a su destino, ¿quién se supone que reciba la información? ¿Qué aplicación debe recibir la información?
 
 Los paquetes de internet también deben especificar la aplicación que envía la información y la aplicación que debe recibirla. Podemos pensar que las direcciones de Internet son las direcciones de correo de una casa, y que las aplicaciones que envían y reciben la información, son las personas que envían y reciben la correspondencia. Para enviar una carta por correo, hay que especificar a qué persona se le está enviando la carta. Esto corresponde a especificar la aplicación que recibe la información. Para identificar la aplicación fuente y la aplicación de destino, el protocolo de Internet usa lo que se conoce como *números de puerto*. De este modo, mirando la información del paquete, se pueden identificar las direcciones y puertos de la fuente y del destino.
 
 Dentro de la estructura mostrada en la Figura 1 se encuentra:
 
 1. **Destination MAC Address** y **Source Mac Address**: son las direcciones MAC de la fuente y el destino.
-3. **Ether Type**: se utiliza para indicar el tipo de de protocolo utilizado en el **payload**. Uno de los **payloads** posibles es un paquete de IP.
+3. **Ether Type**: se utiliza para indicar el tipo de protocolo utilizado en el **payload**. Uno de los **payloads** posibles es un paquete de IP.
 4. **Payload**: contiene un paquete de IP (en realidad puede contener otras cosas, pero para esta experiencia de laboratorio asumiremos que solamente contiene IP).
 
 

mainwindow.cpp

 
     /* Starts the sniffer thread and connect the signals between
        the sniffer and the GUI
-       Comienza el hilo del sniffer y conecta las sinales entre
+       Comienza el hilo del sniffer y conecta las senales entre
        el sniffer y el GUI
     */
     pause = 0;
 
 /// \fn void MainWindow::slot_netwManagerFinished(QNetworkReply *reply)
 /// \~English
-/// \brief This slot is called when an image is successfuly retreived.
+/// \brief This slot is called when an image is successfuly retrieved.
 /// The image is then added to the GUI display.
 /// \param reply object that contains the reply to our request.
 /// \~Spanish

mainwindow.h

 
     /// \fn void MainWindow::on_capture_clicked()
     /// \~English
-    /// \brief Signal that starts or pause the capture of the packets in the sniffer.
+    /// \brief Signal that starts or pauses the capture of the packets in the sniffer.
     /// \~Spanish
-    /// \brief Senal que inicial o pausa la captura de paquetes en el sniffer
+    /// \brief Senal que inicia o pausa la captura de paquetes en el sniffer
     void on_capture_clicked();
 
     /// \fn void MainWindow::on_packetDisplay_itemClicked(QTableWidgetItem *item)
 
     /// \fn void MainWindow::slot_netwManagerFinished(QNetworkReply *reply)
     /// \~English
-    /// \brief This slot is called when an image is successfuly retreived.
+    /// \brief This slot is called when an image is successfuly retrieved.
     /// The image is then added to the GUI display.
     /// \param reply object that contains the reply to our request.
     /// \~Spanish

sniffer.cpp

     }
 
     /* make sure we're capturing on an Ethernet device */
-    /* se asegura que se esta caputando en un dispositivo de Ethernet */
+    /* se asegura que se esta capturando en un dispositivo de Ethernet */
     if (pcap_datalink(handle) != DLT_EN10MB) {
      fprintf(stderr, "%s is not an Ethernet\n", dev);
      exit(EXIT_FAILURE);
 
 /// \fn void Sniffer::got_packet(const struct pcap_pkthdr *, const u_char *packet)
 /// \~English
-/// \brief Disects the received packet. Takes out the info needed.
+/// \brief Dissects the received packet. Takes out the info needed.
 /// \param pcap_pkthdr header of the pcap packet
 /// \param packet recieved packet
 /// \~Spanish

sniffer.h

 
     /// \fn string Sniffer::format_payload(const char *payload, int len)
     /// \~English
-    /// \brief Formats the payload from a byte stream into a string of ascci
+    /// \brief Formats the payload from a byte stream into a string of ascii
     /// \param payload payload of the packet
     /// \param len length of the packet
     /// \return the payload in a string of ascii
     /// \brief Sets the device to capture packets to dev
     /// \param dev name of the device
     /// \~Spanish
-    /// \brief Ajusta el dispositivo para caputurar paquetes a dev
+    /// \brief Ajusta el dispositivo para capturar paquetes a dev
     /// \param dev nombre del dispositivo
     void setDevice(string) ;
 
 
     /// \fn void Sniffer::got_packet(const struct pcap_pkthdr *, const u_char *packet)
     /// \~English
-    /// \brief Disects the received packet. Takes out the info needed.
+    /// \brief Dissects the received packet. Takes out the info needed.
     /// \param pcap_pkthdr header of the pcap packet
     /// \param packet recieved packet
     /// \~Spanish