RCOM - Resumo

################################################################################
# 1. Introdução                                                                #
################################################################################
	Transport
	Network
	Data Link
	Physical

- Circuit Switching
	- Establece-se a ligação, é definido um caminho e é enviada a informação.

- Packet Switching
	- São enviados pacotes e o caminho é definido enquanto o pacote viaja.

- Tempo de Transmição
	Em Cirquit Switching
	T=Te+Tp+Td
	Te <- Tempo que demora a establecer a ligação
	Tp <- Tempo de propagação (~0)
	Td <- Tempo que demora a enviar os dados (Length/Bitrate)

	Em packet Switching
	Tpac=Sum(Ti)
	Ti=Tpi+Tdi

	Ti <- Tempo que demora a enviar um pacote numa ligação i (Length/Bitrate)
	Tpi <- Tempo de propagação numa ligação i

################################################################################
# 2. Physical Layer                                                            #
################################################################################

- Bitrate - Número de bits enviado por segundo;
- Baudrate - Número de symbolos enviados por segundo

- Conversão de um sinal digital s(t) num sinal analógico r(t)
	- r(t) - Convulução de s(t) com h(t)

- Quantos mais harmónicos possuir o sinal analógico, mais próximo será do
	sinal digital.

- Conversão de um sinal analógico r(t) num sinal digital s(t)
	- Um sinal digital de dois níveis (0 e 1) transformado numa onda de
	frequência B pode	ser	reconstruido se forem recebidas 2B amostras/s
		C = 2B
	- No entanto, caso sejam usados M níveis para armazenar a informação, a
	capacidade do canal passa a ser:
		C = 2Blog2(M)

	- Baudrate = 2B
	- Bitrate = 2Blog2(M) = C

- Códigos para definir s(t)
	- NRZ-L - 2 níveis, um representa um 0, outro representa um 1
	- NRZ-I	- Uma mudança de nível representa um 1
	- Manchester - Transição no meio de cada bit (Positivo->Negativo
		representa um 1 e vice versa)

- Tipos de modulação
	- Em amplitude
		- M-PAM
			- s(t)=A*cos(2PI*f*t)
			- fase = 0
	- Em frequência
	- Em fase
		- M-PSK
			- s(t)=A*cos(fase+2PI*f*t)
			- A = constante
	- Em apmlitutude e em fase
		- M-QAM
			- s(t)=A*cos(fase+2PI*f*t)

- Lei de Shannon
	Noise elevado -> low M (number of levels)
	High SNR -> high M
	- A capacidade máxima de uma canal é dada por:
		C=B*log2(1+SNR)
		- SNR <- Signal Noise Ratio = P/(NB)
		- B <- Frequência do canal (Hz)
		- P <- Potência recebida (W)
		- N <- Ruido Branco (10^-9 W/Hz)
		- NB <- Potência do ruído recebido na frequência B (W)

- Cabos
	- Pr=Pt*Ganho (em W)
	- Pr=Pt+Ganho (em dB)
	- Ganho=1/Atenuação (em W)
	- Ganho=-Atenuação (em dB)

- Comunicação sem fios
	- Quanto maior a distância e menor o comprimento de onda, maior será
	 a atenuação


################################################################################
# 3. Data Link Layer                                                           #
################################################################################

- Funções
	- Servir de Interface ao Network Layer
	- Eliminar/Reduzir Erros
	- Regular o Fluxo da Informação

- Framing
	- Separa a informação em frames, para saber onde a informação começa e acaba

	- Character Count
		- Primeiro byte do frame: Tamanho
		- Resto: Informação
		- Caso haja um erro no byte do tamanho, toda a informação fica corrrompida

	- Byte Stuffing
		- Coloca uma flag no inicio e no fim de cada frame
		- Usa um caracter de escape no stuffing (semelhante ao trabalho 1)

	- Start/End Flags com Bit Stuffing
		- Flags de inicio e fim 01111110 (01^60)
		- Stuffing 11111 -> 111110 (1^5->1^50)
		- Destuffing 111110 -> 11111 (1^50->1^5)

- Detecção de Erros
	BER <- Bit Error Ratio
	FER <- Frame Error Ratio
	FER=1-(1-BER)^L
	L <- Tamanho do Frame

	Probabilidade de um frame ter N erros:
		L C N*P^N+(1-P)^L-N <- Semelhante a uma distribuição binomial

	- Métodos de detecção
		d - número minimo de erros necessários para o erro não ser detectado
		B - tamanho máximo de um "burst" de erros

		- Todos os métodos de detecção são baseados na redundância de dados

		- Parity Check
			A cada bloco adiciona-se um bit que indica se o número de 1's é par
			ou impar.
			Detecta erros se o número de erros for impar
			d=2

		- Bi-dimensional Parity
			Cada bloco é representado como uma linha
			É dada a informação da paridade do número de 1s de cada linha e de
			cada coluna
			d=4 (se houverem 4 erros núma configuração rectangular, é indetectavel)

		- Internet Checksum
			Soma de todos os conjuntos de 16bits em complemento para 1 com carry
		 	wrap-around
			d=2

		- Cyclic Redundancy Check (CRC)
			Conjunto de bits representado como um polinómio (101=x^2+1)
			Somas e subtracções como XOR (sem carry nem borrow)
			M(x) <- dados
			R(x) <- check bits
			T(x) <- informação final = M(x)*x^r+R(x)

			R(x) é gerado da seguinte forma:
				Tendo uma função G(x) que gere uma string de tamanho r+1, é necessário
			 	escolher um R(x) que faça T(x) múltiplo de G(x), ou seja:
					R(x)=resto ( M(X)*x^r/G(x) )
			d>3
			B=r
			Detecta todos os erros com um número impar de bits invertidos

ARQ

- Quando um pc B deteta erros enviados por A, é enviada uma resposta ARQ
- Pode ser efectuado Link-by-Link (Ligações Pouco Fiáveis) ou End-by-End
 (Ligações Fiáveis)

	- Stop and Wait
		Exº:
			- A envia uma trama I(0) e espera pela resposta de B;
			- Se B recebeu a trama correctamente, envia um ACK(1), caso contrário,
				envia um ACK(0);
			- Se A recebe um ACK(1), envia a trama I(1) seguinte, caso contrário,
				envia a trama I(0);
			- Se houver um timeout, o último frame enviado é retransmitido.
		- Eficiência = (1-FER)/(1+2a)
			a = Tp/Tf

	- Go Back N
		- Utiliza um mecanismo de janela flutuante
			- A pode enviar W frames sem receber um RR
		Exº:
			- A envia uma trama I(0),I(1)...I(W);
			- B recebe todas as tramas na sequência certa até X-1=W e envia o RR(X)
			 ou envia REJ(X) caso seja uma trama fora de ordem ou com erros (todas as
			  tramas seguintes fora de ordem são descartadas sem enviar REJ até que
				venha a trama X)
			- A recebe RR(X) ou REJ(X) e envia I(X),I(X+1)...I(W+X) ou, havendo um
			 timeout, pede por um RR
		- Eficiência = W/(1+2a) se W<(1+2a) ou 1 se W>(1+2a)

	- Selective Repeat
		Semelhante ao Go Back N, no entanto o receptor recebe tramas fora da
		sequência e, quando não recebe uma trama X (ou a recebe com erros), envia
		 um SREJ(X) (Continua a enviar RR).
		Por sua vez, o transmissor quando recebe um SREJ(X) só tem de enviar a
		trama X, podendo continuar a enviar o resto das tramas normalmente.

		Apenas funciona para valores grandes de W.


################################################################################
# 4. Delay                                                                     #
################################################################################

- Multiplexing do trafego da ligação

	- Cada ligação tem uma determinada capacidade máxima C (bit/s)
	- Diferentes pacotes numa ligação podem estar intercalados por técnicas de
	multiplexing

	- Statistical Multiplexing
		- Todos os pacotes de todas as fontes são colocados na mesma fila de espera
		- São transmitidos segundo uma estratégia first-come first-served
		- Tempo necessário para transmitir um pacote de tamanho L: L/C

	- Frequency Division Multiplexing
		- A capacidade da ligação é dividida em M porções
		- O canal de banda W é dividido em M canais de W/M Hz cada um
		- Capacidade de cada canal = C/M
		- Tempo necessário para transmitir um pacote de tamanho L: L*M/C

	- Time Division Multiplexing
		- O tempo é dividido em slots de tamanho predefinido (normalmente 1 octeto)
		- Capacidade de cada canal = C/M
		- Tempo necessário para transmitir um pacote de tamanho L: L*M/C

- Delay

	- Caracterizado por Modelos de fila de espera
		- Clientes chegam em alturas aleatórias a determinado serviço
		- Cliente = Pacote
		- Tempo que demora a efectuar o serviço = Tempo de transmissão do pacote

		- Distribuição de Poisson

			P(N=n) = Pn = (m^n * e^-m)/n!
			m = E[N] = Var[N] = dT
			d -> chegadas/s

			logo:
			P(n chegadas em T segundos) = Pn(t) = ((dT)^n * e^-(dT))/n!

			- Diferença entre chegadas deterministas e chegadas de Poisson
				Exº
				5 chegadas/s
				Deterministas |. . . . .|. . . . .|
				Poisson       |...  ..  |. ...   .|

		- Distribuição Exponêncial

			P(tempo de chegada entre duas chegadas ser <t) = P(A<t) = F(t)
			F(t) = 1 - e^-(dT)
			E[A]=1/d
			Var[A]=1/(d^2)

	- Processos de Markov
		- Propriedade de Junção
			Sendo A1, A2,... Ak diferentes Processos de Poisson com d1,d2,...dk
			Então A=sum(Ai) também é um processo de Poisson, com d=sum(di)

		- Propriedade de Separação
			Se vários pacotes seguirem um Processo de Poisson (A,d) e se dividirem
			com probabilidade p, vão ser divididos em dois processos:
				(A1,p*d) e (A1,(1-p)*d)

	- Modelo de fila de espera
		d <- chegada de clientes/s
		u <- número de clientes processados/s
		p=d/u <- intensidade do trafego

		- Notação de Kendal (A/S/s/K)
			A <- processo estatistico da chegada de clientes
			S <- processo estatistico do serviço
			s <- número de servidores
			K <- capacidade do sistema em buffers

		- Teorema de Little
			- N=d*T
			N <- Número de clientes no sistema
			T <- tempo médio de cada cliente no sistema

			- Nwait=d*Twait

			- Twait=Nwait/d
				Não depende de u, pois se d>u, o servidor crasha, se d<=u,
				u não interessa

		- Fila D/D/1
			- Chegadas e atendimentos seguem uma distribuição determinista

		- Fila M/M/1
			- Chegadas seguem uma distribuição de Poisson, tempo de atendimento
			 segue uma distribuição exponêncial
			- Modelada através de cadeias de Markov(máquina de estados probabilistica)
				- Estado k: k clientes na fila
					P(i,i+1)=d*g
					P(i,i-1)=u*g (i>0)
					P(0,i-1)=0
					P(i->i)=1-P(i,i+1)-P(i,i-1)
				- Probabilidade de estar no estado n
					P(n)=p^n*(1-p)
					p <- intensidade do trafego
				- Tamanho médio de uma fila
					N=d/(u-d)
				- Número médio de clientes em espera
					Nw=N-p

		- Fila M/M/1/B
			- Fila M/M/1 limitada a B buffers
			- Probabilidade de se perderem dados = P(B)
			- Probabilidade de estar no estado n
					P(n)=(p^n*(1-p))/(1-p^(B+1))
					se p=1 -> P(B)=1/(B+1)

		- Fila M/G/1
			- Chegadas seguem uma distribuição de Poisson, tempo de atendimento segue
			uma	distribuição arbitrária com determinado E[X] e E[X^2]
			- E[X]=1/u
			- Tempo de espera médio (Formula de Pollaczek-Khinchin)
				Tw=d*E[X^2]/(2*(1-p))
			- N=Nw+p

	- Redes de Linhas de Transmissão

		- Apróximação de Independência de Kleinrock
			- Cada ligação é modelada como uma fila M/M/1

		- Redes de Jackson, em cada estado, cada cliente tem uma determinada
		probabilidade de voltar a uma fila anterior


################################################################################
# 4. MAC                                                                       #
################################################################################

- A camada de Data Link é constituída por duas sub-camadas:
	- LLC (Logical Link Control)
		- Interface para a camada Network
		- Controlo de erros e de fluxo
	- MAC (Medium Access Control)
		- Transmissão/Recepção de frames
		- Endereçamento
		- Controlo de erros

- Ligações de Múltiplo Acesso
	 - Point to Point
		- PPP em acesso dial-up
		- Ligações Ethernet entre switch e host
	- Broadcast
		- Antigas ligações Ethernet
		- Wireless LAN

	- Protocolo de Múltiplo Acesso Ideal
		- Uma estação quer transmitir -> usa R bit/s
		- M estações querem transmitir -> cada uma usa R/M bit/s
		- Descentralizada e simples

	- Definições
		- Estação:
			- Transmite um frame de cada vez
			- A probabilidade de um frame ser gerado em g:p1(g)=d*g
			- Segue uma distribuição de Poisson
		- Colisão
			- Duas estações transmitem ao mesmo tempo
		- Tempo Contínuo/Tempo Particionado
			- Contínuo: Um frame pode ser transmitido a qualquer altura
			- Particionado: Um frame só pode ser transmitido no ínicio da sua
				partição (time slot)
		- Carrier Sense:
			- Com Carrier Sense: Sabe se um canal está ocupado antes de o usar
			- Sem Carrier Sense: A estação não sabe como está o canal

	- Protocolos MAC
		- Channel Partitioning (Pouco eficientes em canais pouco carregados)
			- Time Division Multiplexing
			- Frequency Division Multiplexing

		- Random Access (Pouco eficientes em canais sobrecarregados)
			- O canal não é dividido, são permitidas colisões
			- Quando uma estação quer enviar um pacote, transmite-o a C bit/s
			- Duas estações a transmitir ao mesmo tempo -> Colisão
			- O protocolo define quando enviar, como detectar colisões e como
				as recuperar

			- ALOHA
				- O pacote está pronto? Se sim, transmite a informação.
				- Espera pelo round-trip propagation delay (tempo de enviar o pacote
					e receber o ACK)
				- Recebeu um ACK, se sim envia outro pacote, se não:
					- Calcula um inteiro de backoff aleatório (k)
					- Atrasa k tempo de transmissão de pacotes
					- Retransmite

				- Slotted ALOHA
					- O tempo é particionado, sendo o tempo de cada partição o tempo
					necessário para enviar um frame
					- Só são transmitidos frames no início da partição

				- Pure ALOHA
					- A estação transmite quando tiver um frame para transmitir

			- CSMA
				- Ouve a rede antes de transmitir, não interrompe as outras estações
					- Canal Livre -> Transmite
					- Canal Ocupado -> Espera

				- Continuam a poder haver colisões, por causa do atraso de propagação
					- Probabilidade de colisão = Tprop/Tframe
					- Em caso de colisão: Espera-se um tempo aleatório e repete-se a
					 	transmissão
					- Persistencia: O que fazer quando o canal está ocupado

				- CSMA Persistent
					- Meio Livre: Transmite
					- Meio Ocupado: Espera que o meio fique livre e transmite(Persistente)

				- CSMA Non-persistent
					- Meio Livre: Transmite
					- Meio Ocupado: Espera um tempo aleatório e repete o algoritmo
						(Não persistente)

				- CSMA p-persistent
					- Tempo de partição = Round-trip time = 2*Tprop
					- Meio Livre: Transmite com probabilidade p ou espera pela próxima
					 	partição
					- Meio Ocupado: Espera que esteja livre e repete o algoritmo
						(caso tenha sido atrasado, teria havido uma colisão)

			- CSMA/CD (com collision detection)
				- Semelhante ao CSMA Persistent, mas com detecção de colisão:
					- A estação ouve o meio enquanto envia, se houver uma colisão:
						- Aborta a transmissão
						- Retransmite com um atraso calculado por um algoritmo de Binary
							Exponential Back-off

					- Binary Exponential Back-off
						- Tempo dividido em partições 2*Tprop
						- Depois da i-ésima colisão consecutiva:
							- Espera um número de aleatório slots distribuido uniformemente
								entre [0,2^i-1]
							- Retransmite

					- Só funciona se Tf>2*Tprop, caso contrário, não detecta a colisão

			- CSMA/CA (com collision avoidance)
				- Monitoriza o canal até este estar livre durante um período maior
					ou igual ao DIFS
					- DIFS: Distributed Inter-Frame Space
				- Se o meio estiver livre, transmite
				- Caso esteja ocupado:
					- Define um tempo de back-off aleatório que vai sendo decrementado
						enquanto o	canal estiver livre
					- Se surgir uma nova transmissão para de decrementar
					- Volta a devrementar quando o canal estiver livre por um período
					maior ou igual que o DIFS
					- Retransmite quando o contador chega a 0

				- Para evitar a captura do canal
					- Espera um tempo aleatório entre duas transmissões consecutivas,
					mesmo que o	meio tenha estado livre durante o DIFS
				- Necessita de ACK

		- Taking Turns
			- Cada estação tem o seu turno
			- Estações com mais informação a enviar podem ter turnos maiores

			- Polling
				- Controlado por uma estação mestre
				- Problemas:
					- Polling Overhead
					- Latência
					- Falhando a estação mestre, falha tudo

			- Passagem de tokens
				- As estações vão passando um token entre si,
					dizendo quem pode transmitir
				- Problemas:
					- Token Overhead
					- Latência
					- Falhando o envio/recepção do token, falha tudo

- Endereço MAC
	- Endereço de 48bit
	- Único para cada adaptador
	- Endereço de broadcast FF-FF-FF-FF-FF-FF

- Ethernet
	- Protocolo MAC utilizado: CSMA/CD

	- Topologias:
		- Bus (tudo ligado no mesmo barramento)
			- Popular em meados de 90
			- Todas as estações estão no mesmo domínio de colisões
		- Star (tudo ligado a um switch)
			- Topologia actual
			- Cada estação corre o seu próprio protocolo Ethernet
			- As estações não colidem entre si

	- Actualmente o CSMA/CD praticamente já não é usado, devido à topologia actual
	- Da Ethernet original já só sobra o MAC address e o formato das frames

- Switch
	- Dispositivo que faz o trabalho do link layer
	- Reenvia frames Ethernet
	- Transparente para cada host
	- Plug n' Play/Self-learning
	- Possui uma forwarding table

	- Self-learning
		- Quando recebe um pacote:
			- Vê o endereço da fonte
			- Preenche a forwarding table com o endereços MAC e a porta correspondente
			- Caso não conheça o endereço de destino, faz flood

- VLANs
	- Uma Bridge/Switch simula diferentes redes/domínios de broadcast

####################################################################################################
# 5. Network                                                                                       #
####################################################################################################

- Camada responsável pela transferência de pacotes

- Transmissor
	- Encapsula a informação em pacotes

- Receptor
	- Recebe os pacotes
	- Envia a informação para o transport layer

- Router
	- Examina o cabeçalho dos pacotes
	- Reencaminha os pacotes para o sítio certo
		- Tem de saber o caminho mais curto para determinar o caminho

- Rede de datagramas
	- Serviço não orientado à ligação
	- Não há o conceito de circuíto
	- Os pacotes são redireccionados de acordo com a fonte e o destino
	- Pacotes com o mesmo par fonte-destino podem seguir caminhos diferentes

- Circuítos Virtuais
	- Serviço orientado à ligação
	- Fases:
		1 - Establecer o circuíto
		2 - Transferência de dados
		3 - Terminação do circuíto
	- Cada pacote carrega um identificador do circuíto virtual
	- Caminho da fonte ao destino -> sequência de identificadores virtuais, um para cada ligação
	- Estado de cada circuíto mantido pelo router, que pode aloca recursos por circuíto

- Forwarding Table
	Contém prefixos e a respectiva porta de saída
	<Endereço/Mask,port)
		Exº
			172.16.24.0/24 1 // todos os IPs começados em 172.16.24 saiem pela porta 1

- Arquitectura do router
	- Funções principais:
		- Correr algoritmos de roteamento
		- Reencaminhar pacotes
	- Composto por:
		- Input Port
			- Physical Layer
			- Data Link Layer
			- Queuing (se os pacotes chegarem rápido demais)
			- Lookup + Forwarding (faz algum reencaminhamento imediatamente)
		- Output Port
			- Buffering + Queuing (com disciplina de agendamento)
			- Data Link Layer
			- Physical Layer
		- Switching Fabric
			- Controla o reencaminhamento (físicamente ou através dum CPU)
		- Routing Processor

- Internet Protocol
	- Cada pacote contém:
		- Versão do protocolo IP
		- Tamanho do Header
		- Tipo de serviço
		- Tamanho da informação
		- Identificador + Flags + Offset de Fragmento (Permite fragmentar mensagens em vários pacotes)
		- Time To Live (para os pacotes não ficarem indefinidamente perdidos na rede)
		- Upper Layer Protocol
		- Checksum do Header
		- IP de Origem
		- IP de Destino
		- Opções (opcional)
		- Informação (Normalmente pacote TCP ou UDP)

	- Fragmentação
		- Identificador <- Identifica o pacote
		- fragflag <- 1 se houver mais informação, 0 se for o último fragmento
		- Offset <- Offset do fragmento em bytes / 8

	- Endereço IP: Endereço de 32 bit (IPv4)
		- Tem uma interface associada

	- Subnets
		- Parte mais significativa do IP: Subnet
		- Parte menos significativa: Interface
		- Cada computador consegue aceder a outro sem intervenção do router

	- Endereços especiais:
		0.0.0.0 <- este host
		127.0.0.0 <- loopback
		255.255.255.255 <- broadcast
		x.x.255.255 <- broadcast na subnet x.x.0.0/16
		x.x.0.0 <- subnet x.x.0.0/16

	- De Notar:
		- Uma subrede xx.xx.xx.0/24 suporta 255 endereços, no entanto, dois já estão resercados
		(xx.xx.xx.0 e xx.xx.xx.255), logo só suporta 253 máquinas

- ARP
	- Permite associar um endereço IP a um endereço MAC
	- Usando ARP request e ARP reply

- Como obter um endereço IP
	- Parte do endereço da subnet é definido pelo ISP
	- O ISP depois trata internamente das suas subredes
	- O ISP obtém endereços pela ICANN

	- DHCP
		- Permite descobrir e obter um endereço ao juntar a uma rede
			- O host faz broadcast de "DHCP discover"
			- O servidor DHCP oferece um endereço, enviando em broadcast "DHCP offer"
			- O host pede esse endereço enviando em broadcast "DHCP request"
			- Se tudo estiver em ordem, o DHCP responde em broadcast com um "DHCP ACK"
		- Todas as mensagens entre o host e o DHCP possuem um id de transação

- NAT
	- Permite que cada computador tenha um IP interno numa rede, sendo o IP externo diferente
	- Para isso, possui uma hash table a que associa um ip interno e uma porta a um número, que será
	a porta de saída
	- Caso um cliente se queira ligar a um servidor dentro de uma rede com NAT, é necessário
	configurar o port forwarding

- IMCP
	- Usado para mandar mensagens de erro ou de controlo (como o ping)
	- Permite fazer traceroute enviando mensagens com TTL=1,2,3... e esperando respostas de erro
	"TTL expired" até receber um "Host unreachable"
	- ICMP Redirect <- Permite informar outros hosts do caminho mais rápido para determinado
	destino

####################################################################################################
# 6. Transport                                                                                     #
####################################################################################################

- UDP
	- Protocolo orientado ao datagrama
	- Não é confiável -> Sem contrlo de erros
	- Não é orientado à ligação
	- Permite às aplicações aceder ao protocolo IP com o mínimo de overhead possível

	- Cabeçalho UDP
		- Porta de Origem
		- Porta de Destino
		- Tamanho do Pacote
		- Checksum do cabeçalho

- TCP
	- Protocolo orientado à ligação
	- Stream de bytes
	- Full-duplex (Comunicação nos dois sentidos)
	- Controlo de fluxo
		- Mecanismo ARQ
		- Controlo de congestionamento do receptor
	- Controlo de congestionamento de rede

	- Transmissor:
		- Divide a informação em segmentos
		- O protocolo TCP usa um timer enquanto espera por o ACK de um segmento
		- Segmentos que não recebam ACK são retransmitidos

	- Receptor:
		- Verifica erros pela checksum
		- Envia ACK se a informação estiver correcta
		- Ordena os segmentos
		- Descarta segmentos duplicados

	- Controlo de fluxo baseado em janela flutuante

	- Cabeçalho TCP
		- Porta de Origem
		- Porta de Destino
		- Número de Sequência
			- Identifica unicamente a informação que está a ser enviada
		- Número de ACK
			- Indica o próximo ACK que se está à espera
		- Tamanho do Header TCP
		- Flags
		- Tamanho da Janela
			- Usado para o controlo de fluxo (mecanismo ARQ)
			- Tamanho em bytes
		- Checksum
			- Tanto do Header como da Informação
		- Urgent Pointer
		- Opções (opcional)
		- Informação

	- Números de Sequência
		- O protocolo TCP vê a informação como um stream de bytes
		- Esse stream é dividido em segmentos
		- Cada pacote tem um número de sequência que corresponde ao primeiro byte do segmento

	- Retransmissão
		- Variante do Go-Back-N
 			- O ACK apenas contém um número de sequência
			- Considera que todos os pacotes com número menor foram recebidos
			- O que faz com que envie ACKs dubplicados quando recebe pacotes fora de ordem
			- O transmissor apenas retransmite um pacote de cada vez
			- Controlo de erros baseado em sequências de bytes e não em pacotes

	- Controlo de Fluxo
		- Tanto o transmissor como o receptor possuem um buffer
			- Buffer do transmissor: LastByteACKed <-> LastByteWritten
				- Effective Window = Advertised Window - (LastByteSent-LastByteACKed)
			- Buffer do receptor: LastByteRead <-> LastByteRcvd+1
				- Advertised Window = MaxRcvBuff - (LastByteRcvd-LastByteRead)

	- Retransmissão Adaptativa (Algoritmo Original)
		- RTT <- Round Trip Time
		- sampleRTT medido para cada par segmento-ACK
		- RTT = a*RTT+(1-a)*sampleRTT
		- a normalmente está em [0.8,0.9]
		- Timeout=2*RTT

	- Algoritmo de Karn/Partridge
		- O sampleRTT não é medido quando há uma retransmissão
		- Quando há uma retransmissão duplica-se o tempo de timeout

	- Selective ACK (SACK)
		- Usa uma bitmask de pacotes recebidos
		- Definido como uma opção TCP
		- Retransmite quando 3 pacotes estão fora de ordem

	- Controlo de Congestionamento TCP
		- Cada fonte define a sua capacidade
		- Os ACKs recebidos regulam a transmissão de pacotes
		- Cada ligação passa a ter uma Congestion Window
		- bitrate=CongestionWindow/RTT

		- Additive Increase/Multiplicative Decrease
			- Para cada RTT: CongestionWindow+1
			- Para cada Timeout: CongestionWindow/2
			- Comporta-se "em serra"

		- Slow-Start
			- CongestionWindow=1
			- Para cada RTT: CongestionWindow*2
			- Para cada Timeout:
				Threshold=CongestionWindow/2
				CongestionWindow=1
			- Se CongestionWindow>Threshold: Passa para congestion avoidance

		- Congestion Avoidance
			- Para cada RTT: CongestionWindow+1
			- Recebendo 3 ACKs Repetidos:
				- Considera que o pacote foi perdido
				- Retransmite o pacote
				- CongestionWindow/2
			- Ocorrendo um Timeout:
				- Volta a Slow-Start

		- Fast-retransmition/Fast-recovery
			- Após 3 ACKs repetidos, retransmite-se imediatamente o frame pedido

####################################################################################################
# 7. Routing                                                                                       #
####################################################################################################

- Minimum Spanning Tree
	- Escolher sempre os vértices com menor peso que liguem a um nó não visitado até toda a árvore
	ter sido visitada

- Shortest-path
	- Dijkstra (Shortest First Search)

- Cada router guarda informações das suas ligações (up, down e custo)
- Cada router corre o algoritmo Dijkstra

- Detecção da topologia: Mandar mensagens de "Hello" de tempo a tempo
- Routers actualizam a sua informação e fazem flood da rede

- Diminuição do overhead: Routers separados por áreas

- Em redes pequenas: Distance Vector em vez de dijkstra
	- Cada ligação sabe a distância aos vértices adjacentes
	- A informação vai sendo trocada e cada estação vai actializando a sua informação de distâncias

- BGP
	- Um router pergunta aos routers adjacentes que caminho estão a usar para chegar a determinado
	destino

- Spanning Tree
	- Usada no nível de Networking

	- Os switches escolhem uma raiz da árvore (normalmente é o switch com o identificador mais baixo)
	- Cada switch diz se a sua interface está no caminho mais próximo da raiz:
		- Mensagens (Raiz,Distância,Fonte)

	- Todos os switches mandam a mensagem (X,0,X)
	- Quando recebem uma mensagem de um id Y<X, actualizam a raiz para Y
	- Calculam a sua distância à raiz adicionando 1 à distância mais curta recebida