Przy włączonym kolejkowaniu (extended_queue=yes) tworzona jest jedna klasa główna i 4 podklasy dla każdego pracującego użytkownika. Klasa główna ma numer tworzony na zasadzie X:Y - gdzie X to identyfikator klasy, Y - pozycja (wiersz) wpisu numeru IP w pliku iplist.X (licząc same wpisy bez komentarzy i pustych lini) plus 4. I tak na przykład jeśli w pliku iplist.X mamy wpisany pierwszy numer IP 192.168.1.2, identyfikator interfejsu internetowego (np. eth0) tego użytkownika (inter_int) mamy 1 a interfejsu lokalnego (np. eth1), przez który ten użytkownik pracuje mamy 2 to numer klasy dla download mamy 2:5 a dla upload 1:5. Wpisując komendę
tc -s class show dev eth0
możemy zobaczyć miedzy innymi klasę dla tego numeru IP (w przykładzie używana klasa HTB):
class htb 2:5 parent 2:1 prio 3 rate 214Kbit ceil 214Kbit burst 27391b cburst 1872b
Sent 27025335 bytes 34960 pkts (dropped 0, overlimits 0)
rate 21702bps 28pps
lended: 0 borrowed: 0 giants: 0 injects: 0
tokens: 778767 ctokens: 15581
A dla upload:
tc -s class show dev eth0
zobaczymy coś takiego (w przykładzie używana klasa CBQ):
class cbq 1:5 parent 1:1 rate 14Kbit (bounded) prio 5
Sent 554775 bytes 4674 pkts (dropped 0, overlimits 0)
borrowed 30 overactions 0 avgidle 379301 undertime 0
Dodatkowe 4 podklasy do kolejkowania mają numery tworzone zgodnie z zasadą X:Y
gdzie X to identyfikator klasy, Y = (4*(A+4))+PRIO
gdzie A - pozycja numeru IP w pliku iplist.X, PRIO - priorytet, możliwe są 4 priorytety:
100 (najwyższy), 101, 102 i 103 (najniższy - wpada do tej klasy cały ruch nieprzesłany
przez klasy z wyższym priorytetem). Poniżej znajdują się regułki dla iptables dla
jednego uzytkownika tworzone przy starcie shapera. Niestety - nie są tworzone odpowiednie
regułki dla ipchains - i proszę mnie nie prosić o przykłady - jak bym wiedział jak to na
ipchains zrobić to w shaperze by to było. Przykład:
# download
# najwyzszy priorytet download - klasa 2:120
iptables -t mangle -A FORWARD -d 192.168.1.2 -m tos --tos 0x10 -j MARK --set-mark 2120
# sredni priorytet download - klasa 2:121
iptables -t mangle -A FORWARD -d 192.168.1.2 -m tos --tos 0x08 -j MARK --set-mark 2121
# niski priorytet download - 2:122
iptables -t mangle -A FORWARD -d 192.168.1.2 -m tos --tos 0x04 -j MARK --set-mark 2122
# Pozostały ruch z polem tos innym niż podane trafi do klasy 2:123.
Teraz przykład skryptu do tworzenia regułek dla firewalla na podstawie wpisów w pliku
/etc/shaper/queue_download_high.0, które ustawią odpowiednie TOS dla odpowiedniego ruchu.
Analogicznie do tego przykładu należy sobie dorobić pętle dla pozostałych plików konfiguracyjnych.
#!/bin/sh
extqueue=`grep extended_queue=yes /etc/shaper/shaper.0.cfg | wc -l`
IFS=';'
if [ $extqueue -eq 1 ];then
grep -E -v "^#|^$" /etc/shaper/queue_download_high.0 | while read prot src sport dst dport
do
if [ "$prot" == "*" ];then
prot="!icmp"
fi
if [ "$src" == "*" ];then
src="0/0"
fi
if [ "$dst" == "*" ];then
dst="0/0"
fi
if [ "$sport" == "*" ];then
sport="0:65535"
fi
if [ "$dport" == "*" ];then
dport="0:65535"
fi
if [ "$prot" != "icmp" ];then
iptables -t mangle -I FORWARD -p $prot -s $src --sport $sport -d $dst --dport $dport -j TOS --set-tos 0x10
else
iptables -t mangle -I FORWARD -p $prot -s $src -d $dst -j TOS --set-tos 0x10
fi
done
fi
Znacznik (MARK) wyliczamy ze wzoru:
M = (1000 * X) + PRIO + (4 * (A + 4))
gdzie: M - znacznik, X - identyfikator klasy (w tym przypadku 2 - dla local_int), A - pozycja numery IP w pliku iplist.X
Sprawdźmy teraz czy dobrze wyliczyliśmy. Po przeliczeniu tej liczby na system szesnastkowy dostajemy w wyniku liczbę 0x848. Piszemy:
tc -s filter show dev eth1 | grep 848
i dostajemy w wyniku:
filter parent 2: protocol ip pref 10 fw handle 0x848 classid 2:120
Czyli ruch zaznaczony przez tą regułkę trafi do klasy 2:120. Teraz możemy sobie obserwować ruch wpadający do tej klasy:
watch tc -s class show dev eth1
i jeśli tylko połączymy się pod ssh lub telnetem z jakimś zewnętrznym serwerem to zobaczymy:
class htb 2:120 parent 2:5 leaf a688: prio 0 rate 273Kbit ceil 273Kbit burst 15Kb cburst 1948b
Sent 10644 bytes 133 pkts (dropped 0, overlimits 0)
rate 11bps
lended: 133 borrowed: 0 giants: 0 injects: 0
tokens: 315623 ctokens: 39721
I jak widać 10644 bajty przeszły przez klasę 2:120
Teraz stworzymy regułkę na firewallu dla ruchu wychodzącego:
# upload
# najnizszy priorytet upload - klasa 1:123
iptables -t mangle -A FORWARD -s 192.168.1.2 -d ! 192.168.0.0/16 -j MARK --set-mark 1123
# najwyzszy priorytet upload - klasa 1:120
iptables -t mangle -A FORWARD -s 192.168.1.2 -d ! 192.168.0.0/16 -m tos --tos 0x10 -j MARK --set-mark 1120
# sredni priorytet upload - klasa 1:121
iptables -t mangle -A FORWARD -s 192.168.1.2 -d ! 192.168.0.0/16 -m tos --tos 0x08 -j MARK --set-mark 1121
# niski priorytet upload - klasa 1:122
iptables -t mangle -A FORWARD -s 192.168.1.2 -d ! 192.168.0.0/16 -m tos --tos 0x10 -j MARK --set-mark 1122
Wzór do obliczenia znacznika jest identyczny jak powyżej - zwracam uwagę, że upload
ograniczany jest na interfejsie internetowym a nie jak download na lokalnym więc w tym
przypadku identyfikator klasy mamy taki jak dla inter_int czyli w tym przypadku
1. Teraz sprawdzamy:
tc -s filter show dev eth0 | grep 460
i dostajemy w wyniku:
filter parent 1: protocol ip pref 10 fw handle 0x460 classid 1:120
Czyli wszystko jest prawidłowo. Możemy teraz obserwować klasę 1:120:
watch tc -s class show dev eth0
aby zobaczyć czy coś przez nią przechodzi. I widzimy:
class cbq 1:120 parent 1:5 leaf a69c: rate 18Kbit prio 3
Sent 12122 bytes 208 pkts (dropped 0, overlimits 0)
borrowed 0 overactions 0 avgidle 8.07342e+06 undertime 0
Czyli jak widać, przez klasę przeszły 12122 bajty.
Teraz tworzymy regułki dla ruchu od serwera do internetu:
iptables -t mangle -A POSTROUTING -p tcp -s 213.97.124.129/32 --sport 22:23 -d 0/0 -j MARK --set-mark 1164
iptables -t mangle -A POSTROUTING -p udp -s 213.97.124.129/32 --sport 22:23 -d 0/0 -j MARK --set-mark 1164
numer IP serwera znajduje się w pliku iplist.X na pozycji 12 (wpis w iplist.X: 213.97.124.129=eth0 eth0).
tc -s filter show dev eth0 | grep 48c
i wynik:
filter parent 1: protocol ip pref 10 fw handle 0x48c classid 1:164
I cały ruch wychodzący z serwera z portu 22 lub 23 będzie miał najwyższy priorytet.
Wszystkie przykłady bazują na iptables ponieważ nie posiadam systemu na
ipchains i nie mam jak tego przetestować.
W archiwum shapera dołożonych zostało 12 dodatkowych plików, w tym 3, które są uzywane przez shapera
przy tworzeniu regułek tylko w przypadku gdy używany jest firewall na iptables (queue_upload_serwer_high|med|low):
/etc/shaper/queue_download_default.X
/etc/shaper/queue_download_high.X
/etc/shaper/queue_download_med.X
/etc/shaper/queue_download_low.X
/etc/shaper/queue_upload_default.X
/etc/shaper/queue_upload_high.X
/etc/shaper/queue_upload_med.X
/etc/shaper/queue_upload_low.X
/etc/shaper/queue_upload_server_default.X
/etc/shaper/queue_upload_server_high.X
/etc/shaper/queue_upload_server_med.X
/etc/shaper/queue_upload_server_low.X
Trzy ostatnie pliki konfiguracyjne są używane przez shaperd do tworzenia regułek.
Pozostałe 6 plików w chwili obecnej nie są używane przez shaperd i trzeba sobie napisać skrypt
operujący na nich.
Jeśli komuś nic nie przechodzi przez klasy to proszę do mnie nie pisać - nie daję
żadnych gwarancji, że będzie to działać na każdej dystrybucji i systemie. Jak komuś
bardzo zależy aby to działało - to pofatyguję się do niego osobiście i mu zainstaluję
taki system że będzie to działać - zgodnie z tym co napisałem w
ofercie.
