Tráfego de entrada com limitação de taxa

Eu nunca entendi direito se é possível ou não limitar o tráfego de entrada . Percebo que não existe um método direto para controlar a taxa de envio de pacotes do servidor remoto (a menos que você esteja no controle dos dois pontos de extremidade), mas levando em consideração essa limitação, como exatamente os gerenciadores de download permitem definir com êxito os limites de velocidade de download ?

Existe algum link entre o início lento do TCP e o tráfego de entrada com limitação de taxa? É possível usar os métodos descritos pelo início lento para limitar artificialmente a taxa de envio de pacotes pelo remetente?

Como uma consideração adicional, deve-se observar que o servidor no qual eu gostaria de implementar a modelagem de tráfego estabelece a própria conexão PPPoE e atua como um roteador para o restante da rede.

Atualização: As respostas até agora forneceram uma visão geral justa das perguntas que fiz, mas ainda não sei como os gerenciadores de download conseguem limitar o tráfego recebido e, mais especificamente, se é possível implementar uma estratégia semelhante em um Caixa de gateway Linux.

Os gerenciadores de download provavelmente funcionam como explicado no documento comum .

Um processo utilizando soquetes BSD pode executar sua própria limitação de taxa. Para limitar o upstream, o aplicativo pode fazer isso limitando simplesmente a taxa de dados gravados em um soquete. Da mesma forma, para limitar a jusante, um aplicativo pode limitar a taxa de dados que lê de um soquete. No entanto, a razão pela qual isso funciona não é imediatamente óbvia. Quando o aplicativo deixa de ler alguns dados de um soquete, seu soquete recebe buffers preenchidos. Isso, por sua vez, fará com que o TCP receptor anuncie uma janela menor do receptor (rwnd), criando uma contrapressão na conexão TCP subjacente, limitando assim o fluxo de dados. Eventualmente, esse efeito "trickle-down" atinge limitação de taxa de ponta a ponta. Dependendo do buffer em todas as camadas da pilha de rede, esse efeito pode levar algum tempo para se propagar.

Se você ocasionalmente precisar limitar a taxa de um único programa em um sistema UNIX, uma solução simples será complicada . A modelagem de tráfego real, como você executaria em um gateway, pode ser concluída tc. Isso está documentado no Capítulo 9. Disciplinas de enfileiramento para gerenciamento de largura de banda do HOWTO avançado de controle de tráfego e roteamento do Linux.

No caso de um modem de 56k versus uma linha DSl de 4 Mbps, geralmente não há modelagem que faça a diferença de velocidade, é apenas uma diferença na velocidade do link.

A razão pela qual é difícil moldar o tráfego de entrada é que não há buffer no meio de transmissão. Você aceita os bits recebidos ou eles são perdidos. Para o tráfego que está prestes a sair de uma interface, você pode armazenar em buffer e reordenar os pacotes o quanto quiser (ou, pelo menos, até a memória buffer disponível no dispositivo).

Para protocolos que possuem uma camada sobre o TCP (não sei se é o caso de torrents), seria uma simples questão de solicitar solicitações de dados adicionais. Caso contrário, o aplicativo precisaria se comunicar com o sistema operacional para atrasar a aceitação dos pacotes. A maioria dos protocolos baseados em UDP terá, por necessidade, uma lógica ACK / reenviar no protocolo específico do aplicativo, portanto, nesse ponto, é quase trivial acompanhá-los.

Uma rota possível seria modelar o tráfego da Internet no lado da LAN do seu roteador DSL, pois nesse momento você estaria configurando uma porta de saída.

Não sei responder por que você não encontrou nenhuma solução que permita moldar os dados recebidos (e não sabe nada de antemão), mas como o remetente sabe com que rapidez o receptor pode receber dados:

O design básico do TCP / IP é que, para cada pacote que a fonte envia ao destino, ele precisa aguardar a resposta do destino (com um ACKpacote) dizendo que recebeu o pacote.

Portanto, se você tiver um remetente de 4 Mbps e um receptor de 56 Kbps, o remetente terá que esperar e aguardar entre o envio de pacotes para que o receptor responda a cada pacote (existem alguns detalhes técnicos para reduzir essa sobrecarga, mas a premissa ainda permanece em um resumo nível).

Então, o que acontece se o remetente já estiver enviando 56Kbps de dados e tentar enviar um pouco mais?

O pacote se perde. (Bem, potencialmente enfileirado no buffer de um comutador, mas quando isso é preenchido, o pacote se perde). Como o pacote foi perdido, o receptor nunca o recebe e, portanto, nunca envia um ACKpacote. Como o remetente nunca recebe esse ACKpacote (porque nunca foi enviado, mas também pode ser perdido ou haver uma interrupção na rede), é necessário que o remetente reenvie o pacote extra. Ele fica parado e tenta reenviar o pacote até que ele seja finalizado e a ACKresposta volte a ele.

Portanto, para recapitular, uma vez que o remetente tenha maximizado a largura de banda do receptor, ele deverá parar e reenviar o próximo pacote repetidas vezes até que haja largura de banda disponível suficiente para que ele seja transmitido. Isso reduz efetivamente a velocidade de envio ao máximo que o cliente pode receber. (E existem métodos de otimização para reduzir o número de vezes que um pacote deve ser reenviado nesse caso, em que basicamente o remetente fica mais lento cada vez que é necessário reenviar um pacote, mas isso está além do escopo dessa descrição simplificada.

Você pode fazer isso com uma interface ifb.

Com uma interface ifb, você pode rotear o fluxo de entrada eth0 (ou o que for) para a saída em ifb0 (por exemplo) e aplicar as regras de limite.

Verifique este URL da Linux Foundation: http://www.linuxfoundation.org/collaborate/workgroups/networking/ifb

E esses scripts que limitam a largura de banda de entrada e saída: https://github.com/rfrail3/misc/blob/master/tc/traffic-control.sh

Confira wondershaper: http://lartc.org/wondershaper/

Em relação ao tráfego recebido:

This is slightly trickier as we can't really influence how fast the internet
ships us data. We can however drop packets that are coming in too fast,
which causes TCP/IP to slow down to just the rate we want. Because we don't
want to drop traffic unnecessarily, we configure a 'burst' size we allow at
higher speed.

Now, once we have done this, we have eliminated the downstream queue totally
(except for short bursts), and gain the ability to manage the upstream queue
with all the power Linux offers.

use UFW (muro de incêndio não complicado) http://ubuntuforums.org/showthread.php?t=1260812

Este segmento mostra um exemplo simples que tem como padrão IPs com 6 ocorrências em 30 segundos:

sudo ufw limit ssh/tcp

Também um comando mais 'avançado' com valores especificados para o tempo e a contagem de ocorrências

sudo iptables -A INPUT -i eth0 -p tcp --dport 22 -m state --state NEW -m recent --set --name SSH

sudo iptables -A INPUT -i eth0 -p tcp --dport 22 -m state --state NEW -m recent --update --seconds 60 --hitcount 8 --rttl --name SSH -j DROP