README-en.md edited online with Bitbucket

README-en.md

 
 ![header.png](images/header.png)  
 
+[Verano 2016 - Ive]
+
 *Object Oriented Programming* (OOP) is a programming paradigm that promotes the design of programs by having different objects interacting together to solve a problem. C++ is one of the programming languages that promotes object oriented programming, allowing programmers to create their own classes from scratch or derive them from other existing classes. Other languages that promote OOP are Java, Python, Javascript and PHP.
 
 In OOP, each object encapsulates within itself certain properties about the entity being modeled (for example, an object that models a *point* encapsulates the coordinates *x* and *y* of the point being represented). Furthermore, each object allows certain actions to be carried out on itself with the  *methods* that the object contains. For example, an object of class *point* could carry out the action of changing the value of the *x* coordinate.
 
 When an object class we need to use in our program has not been predefined in a library, we need to declare and implement our own class. To do this, we define *classes* that contain data with certain *properties* or *attributes* and actions that we want to carry out with this data through the use of *methods* or *member functions*. This way, we can organize the information and processes in *objects* that have the properties and methods of a class. In today's laboratory experience you will practice defining a class and implementing some of its methods by completing a simple network sniffer. The sniffer captures all the internet protocol (IP) packets that flow through your computer in the lab, and some other packet information.
 
-##Objectives
+## Objectives
 
 1. Practice the implementation and declaration of classes in C++.
 2. Implement methods in a class.
 
 Before you get to the laboratory you should have:
 
-    1. Reviewed the implementation and declaration of C++ classes
-    2. Studied the concepts and instructions for this laboratory session.
-    3. Taken the Pre-Lab quiz in Moodle
+1. Reviewed the implementation and declaration of C++ classes
+2. Studied the concepts and instructions for this laboratory session.
+3. Taken the Pre-Lab quiz in Moodle
+
+---
+
+---
 
 ## Communication among computers
 
 
 ---
 
-## Packet Sniffer
+## Simple Packet Sniffer
 
 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 flow across the network, the sniffer captures each packet and, if needed decodes the packet's raw data[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 addtional information of the packets.  Additinally it detects the non encrypted requests of images in the web, and displays the images in a GUI.
 
 ---
+
 ---
 
 ## Laboratory session:
 
 The application that you will complete today allows the users to analyze network traffic and to monitor the images that are being tranfered through the net.
 
+Figure 2 shows an image of the application interface. Each row in the table is the information of each captured packet. The text box under the table presents a ASCII summary of a selected packet from the table. The list in the right presents the images that have been captured by the sniffer.  
+
 ---
 
 ![](images/ss.png)
 
 --- 
 
-
-Figure 2 shows an image of the application interface. Each row in the table is the information of each captured packet. The text box under the table presents a ASCII summary of a selected packet from the table. The list in the right presents the images that have been captured by the sniffer.  
-
 To create a packet sniffer you can use the *pcap* library that provides an interface to access the data passing across your network card.  This library contains a function that returns a raw stream of bytes of each packet captured. 
 
 The task of the sniffer programmer to decode the raw stream into human readable information.  Fortunately this is not your task, but you can learn how to do it, if you want, by reading the source code of this laboratory.  Your task is to follow the exercises below so you provide the packet sniffer with the needed objects (Classes) to process the packets.
 
-## Exercise 1: Familiriaze your self with the application
+### Exercise 1 - Familiarize yourself with the application
+
+#### Instructions:
+
+1. Load the project  `SimpleSniffer` into `QtCreator`. There are two ways to do this:
 
-Instructions
+    * Using the virtual machine: Double click the file `SimpleSniffer.pro` located in the folder `/home/eip/labs/classes-simplesniffer` of your virtual machine.
+    * Downloading the project’s folder from `Bitbucket`: Use a terminal and write the command `git clone http:/bitbucket.org/eip-uprrp/classes-simplesniffer` to download the folder `classes-simplesniffer` from `Bitbucket`. Double click the file `SimpleSniffer.pro` located in the folder that you downloaded to your computer.
 
-    1. To load this project you need to run qt creator with root privileges.
-        ```sudo qtcreator Documents/eip/simplesniffer/SimpleSniffer.pro```
-    2.The project `SimpleSniffer` is in the directory `Documents/eip/simplesniffer` of your computer. You can also go to `http://bitbucket.org/eip-uprrp/classes-simplesniffer` to download the folder `classes-simplesniffer` to your computer.
-    3. Configure the project.  The project consists of several files.  In this laboratory you will be working with the files `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` and `ip_packet.cpp`
+2. Configure the project.  The project consists of several files.  In this laboratory experience you will be working with the files `ethernet_hdr.h`, `ethernet_packet.h`, `ethernet_packet.cpp`, `ip_packet.h` and `ip_packet.cpp`.
 
 
-## Exercise 2: Complete the class ethernet_packet
+### Exercise 2: Complete the class ethernet_packet
 
 Study the file `ethernet_hdr.h`. This file contains the definition of the data structure that represents an Ethernet header.:
 
 };
 ```
 
-Note that each object of the class `ethernet_packet` only has one attribute:
-
-	* one structure of type `sniff_ethernet` named `ethernet`
+Note that each object of the class `ethernet_packet` only has one attribute: a structure of type `sniff_ethernet` named `ethernet`
 
 The rest are methods that act as interface to the attribute:
 
-* `void setEtherDHost(u_char [])`: is a *setter* to the field `ether_dhost` of the attribute `ethernet`
-
-
-* `void setEtherSHost(u_char [])`: is a *setter* to the field `ether_shost` of the attribute `ethernet`
-
-* `void setEtherType(u_short)`:  is a *setter* for the field `ether_type` of the attribute `ethernet`
-
-* `getEtherDHost()` and `getEtherSHost()` are *getters* that return the values of `ether_dhost` and `ether_shost` in a human readable format, i.e. 6 pairs of hexadecimal digits (for example, `e0:f8:47:01:e9:90`).
-
-* `getEtherType()` is a *getter*  that returns the value of `ether_type` as *unsigned char*.
-
-* the private method `string mac2string(u_char [])` receives an array of six *unsigned characters* and returns the corresponding string to its hexadecimal representation. For example, if it receives `{ 0x8A, 0x11, 0xAB, 0xFF, 0x12, 0x34}` it must return the string `"8A:11:AB:FF:12:34"`.
+    * `void setEtherDHost(u_char [])`: is a *setter* to the field `ether_dhost` of the attribute `ethernet`
+    * `void setEtherSHost(u_char [])`: is a *setter* to the field `ether_shost` of the attribute `ethernet`
+    * `void setEtherType(u_short)`:  is a *setter* for the field `ether_type` of the attribute `ethernet`
+    * `getEtherDHost()` and `getEtherSHost()` are *getters* that return the values of `ether_dhost` and `ether_shost` in a human readable format, i.e. 6 pairs of hexadecimal digits (for example, `e0:f8:47:01:e9:90`).
+    * `getEtherType()` is a *getter*  that returns the value of `ether_type` as *unsigned char*.
+    * the private method `string mac2string(u_char [])` receives an array of six *unsigned characters* and returns the corresponding string to its hexadecimal representation. For example, if it receives `{ 0x8A, 0x11, 0xAB, 0xFF, 0x12, 0x34}` it must return the string `"8A:11:AB:FF:12:34"`.
 
 Your task in this exercise is to implement the seven functions listed above in the file `ethetnet_packet.cpp`.  The headers of some of the functions are provided in the file.