Improvisa

############################################
# Variable de configuración
############################################

BAJADA=8700
SUBIDA=700

# Estableceremos la interfaz que conecta a internet al llamar al script.
INTERFAZ=$1

# Si necesitasemos establecer el servidor asterisk o el telefono VoIP
# Si no queremos establecer uno en especial lo dejeremos vacio, IPSVOIP=""
IPSVOIP=""

# Para establecer los puertos que utilizaremos en iptables para meter el
# trafico en las distintas colas colas seguiremos esta nomenclatura:
# 53-udp-s
# 53 para el puerto, udp para el protocolo y s para indicar que es source port
# Algunos ejemplos:
# 10001:20000-udp-sd
# Rango de puerto del 10000 al 20000 protocolo udp y ambos sentidos.
# 80-tcp-d
# Puerto de destino 80 protocolo tcp

# Puertos utilizar en la cola de Baja latencia o 1:3
PUERTOSBAJALATENCIA="5060-udp-sd 10001:20000-udp-sd"

# Puertos que iran a parar a la cola de trafico web
PUERTOSWEB="80-tcp-d 443-tcp-d"

# Los puertos con menor prioridad
PUERTOSBAJAPRIORIDAD="110-tcp-d 25-tcp-d 21-tcp-d 143-tcp-d 445-tcp-d 137:139-tcp-d 4662-tcp-d 4664-tcp-d 6881:6999-tcp-d"

####################################################
# Función clasifica_por_pueto
####################################################
# Esta función la utilizaremos más adelante para mandar cada puerto a su cola.

clasifica_por_pueto() {
    PUERTO=`echo $1|cut -d"-" -f1`
    PROTOCOLO=`echo $1|cut -d"-" -f2`
    DIRECCION=`echo $1|cut -d"-" -f3`
        CLASE=$2
    case "$DIRECCION" in
            d)
            iptables -t mangle -A QOS -p $PROTOCOLO –dport $PUERTO -j CLASSIFY –set-class $CLASE
            ;;
        s)
            iptables -t mangle -A QOS -p $PROTOCOLO –sport $PUERTO -j CLASSIFY –set-class $CLASE
            ;;
        ds|sd)
            iptables -t mangle -A QOS -p $PROTOCOLO –dport $PUERTO -j CLASSIFY –set-class $CLASE
            iptables -t mangle -A QOS -p $PROTOCOLO –sport $PUERTO -j CLASSIFY –set-class $CLASE

            ;;
        *)
            echo "******** Error en la definición de algún puerto"
            exit
            ;;
    esac
}

#######################################################
# Función para_qos
#######################################################

function para_qos() {
        # Eliminamos colas de la interfaz
        tc qdisc del dev $INTERFAZ root    > /dev/null 2>&1
        tc qdisc del dev $INTERFAZ ingress > /dev/null 2>&1

        # Eliminamos de iptables las reglas creadas para marcar los paquetes
        iptables -t mangle –delete POSTROUTING -o $INTERFAZ -j QOS > /dev/null 2>&1
        iptables -t mangle –flush QOS 2> /dev/null > /dev/null
        iptables -t mangle –delete-chain QOS 2> /dev/null > /dev/null
        echo "Colas y reglas iptables eliminadas de $INTERFAZ."
}

function inicia_qos() {
    # Añadimos la qdisc raiz del tipo HFSC, el tráfico que no venga marcado se ira
    # a la cola 5, por eso escribimos default 5
    echo "    Creando qdisc raiz"
        tc qdisc add dev $INTERFAZ root handle 1: hfsc default 5

    # Añadimos la clase hija 1:1 donde estableceremos limites de subida, tendremos un
    # máximo de subida ul y con sc establecemos el caudal minimo para esta cola (rt)
    # y compartiremos entre todas las colas el ancho de banda sobrante (ls), recordad
    # que sc establece rt y ls con los mismo valores.
    echo "    Creando qdisc 1:1"
        tc class add dev $INTERFAZ parent 1: classid 1:1 hfsc sc rate ${SUBIDA}kbit ul rate ${SUBIDA}kbit

    # Crearemos la cola para el tráfico interactivo, el que necesita salir más rapido.
    # Inicialmente le daremos todo el ancho de subida (m1) en 50ms (d) muy baja latencia,
    # para que al final acabe quedandose con un caudal minimo (parte rt) de 5/10 y
    # comparta si no lo usa (parte ls) 7/10 del ancho de banda de su cola con las demás,
    # además establecemos como caudal máximo toda nuestra subida con ul.
    echo "    Creando qdisc 1:2"
        tc class add dev $INTERFAZ parent 1:1  classid 1:2 hfsc
                rt m1 ${SUBIDA}kbit d 50ms m2 $((5*$SUBIDA/10))kbit
                ls m1 ${SUBIDA}kbit d 50ms m2 $((7*$SUBIDA/10))kbit
                ul rate ${SUBIDA}kbit

     # Crearemos la cola para el tráfico de baja latencia, donde primeramente iran
    # nuestro paquetes con TOS de baja latencia (marcaremos con iptables), paquetes
    # paquetes VoIP….
    # estableceremos con sc los caudales minimos y la comparticion del ancho de
    # banda con otras colas a 3/10. Como caudal inical tendremos para esta cola
    # todo el ancho de subida y se lo daremos en 200 ms. Además estableceremos con
    # ul el caudal máximo que podrá tener esta cola, es decir todo. Recordad que sc
    # establece rt y ls.
    echo "    Creando qdisc 1:3"
        tc class add dev $INTERFAZ parent 1:1  classid 1:3 hfsc
                sc m1 ${SUBIDA}kbit d 200ms m2 $((3*$SUBIDA/10))kbit
                ul rate ${SUBIDA}kbit

     # Para el trafico Web no garantizaremos nada (m1) hasta el primer segundo, no significa
    # que no naveguemos rapido, sino que si hay otro trafico antes, retardaremos su
    # salida, priorizando asi el trafico que necesitamos. A partir de ese segundo esta cola
    # tendrá como minimo 1/10 del caudal total (m2), con un máximo de caudal del total
    # de la conexión (ul). Recordad que con sc establecemos el valor ls que lo que hace
    # es compartir el ancho de banda de la cola, que es lo que deseamos.
    echo "    Creando qdisc 1:4"
        tc class add dev $INTERFAZ parent 1:1 classid 1:4 hfsc
                sc m1 0 d 1s m2 $((1*$SUBIDA/10))kbit
                ul rate ${SUBIDA}kbit

     # Para el trafico que no marcamos, no garantizaremos nada (m1) hasta el 2º segundo (d)
    # y a partir de ese momento le     garantizaremos 1/20 del caudal total (m2) contando
    # siempre que este disponible con el maximo de la linea (ul). Recordad que con sc
    # establecemos el valor ls que lo que hace es compartir el ancho de banda de la cola.
    echo "    Creando qdisc 1:5"
        tc class add dev $INTERFAZ parent 1:1 classid 1:5 hfsc
                sc m1 0 d 2s m2 $((1*$SUBIDA/20))kbit
                ul rate ${SUBIDA}kbit

    # Para el trafico de Baja Prioridad, por ejemplo P2P o SMTP, no garantiremos nada (m1)
    # los 10 primeros segundos (d) y aprtir de ahí le garantizaremos 1/20 del caudal (m2)
    # Si la conexion esta libre, esta cola podrá utilizar todo el ancho de banda (ul).
    # Recordad que sc establece tambien ls.
    echo "    Creando qdisc 1:6"
        tc class add dev $INTERFAZ parent 1:1  classid 1:6 hfsc
                sc m1 0 d 10s m2 $((1*$SUBIDA/20))kbit
                ul rate ${SUBIDA}kbit

     # Crearemos la nueva cadena donde llamada QOS donde iremos enviando el trafico para
    # marcarlo según nuestras necesidades.
    echo "    Creando cadena QOS de iptables"   
        iptables -t mangle -N QOS
   
    # Paquetes con banderas TCP especiales y menores de 64 los mandamos a 1:2 Trafico Interactivo
    iptables -t mangle -A QOS -p tcp -m tcp –tcp-flags FIN,SYN,RST,ACK ACK -m length –length :64 -j CLASSIFY –set-class 1:2
   
    # El trafico ICMP superior a 512 lo mnadamos a la cola de trafico web o cola 1:4
        iptables -t mangle -A QOS -p icmp -m length –length 512: -j CLASSIFY –set-class 1:4
   
    # El resto de tráfico ICMP lo mandamos a la cola 1:2 de Trafico Interactivo
    iptables -t mangle -A QOS -p icmp -m length –length :512 -j CLASSIFY –set-class 1:2
   
    # Con la ayuda de la función clasifica_por_puerto marcaremos los paquetes segun
    # sea nuestra necesidad. A esta función debemos pasarle el puerto y la cola:
    for puerto in $PUERTOSINTERACTIVOS; do clasifica_por_pueto $puerto 1:2; done
        for puerto in $PUERTOSBAJALATENCIA; do clasifica_por_pueto $puerto 1:3; done
        for puerto in $PUERTOSWEB; do clasifica_por_pueto $puerto 1:4; done
        for puerto in $PUERTOSBAJAPRIORIDAD; do clasifica_por_pueto $puerto 1:6; done
   
    # Marcaremos el trafico proveniente de las IPS de los telefonos o del servidor
    # asterisk si lo hemos configurado arriba.
        for ipsvoip in $IPSVOIP
        do
                iptables -t mangle -A QOS –src $ipsvoip -j CLASSIFY –set-class 1:2
                iptables -t mangle -A QOS –dst $ipsvoip -j CLASSIFY –set-class 1:2
        done

    # Crearemos ahora la cola de bajada o ingress, en esta solo realentizaremos un
    # poco el trafico de bajada para que asi nuestro ISP deje algo de caudal libre
    # intentando que el ISP deje de mandar paquetes, acordaros que TCP es orientado
    # a conexion y tarda un tiempo en establecer la velocidad, si descartamos paquetes
    # nuestro peticion tcp no nos mandará mas dejando de esa forma algo de caudal sin
    # usar.
    # Crearemos la cola con nombre ffff del tipo ingress
    echo "    Creando la cola ingress para tráfico de bajada"
    tc qdisc add dev $INTERFAZ handle ffff: ingress

    # Filtraremos todos los paquetes y les reduciremos la velocidad a la que marcamos
    # en la configuracion de las variables, que si se hizo lo que dije, debe estar
    # un poquito por debajo de la realidad.
    tc filter add dev $INTERFAZ parent ffff: protocol ip prio 50 u32 match ip src 0.0.0.0/0 police rate ${BAJADA}kbit burst 10k drop flowid :1
}

case "$2" in
        stop)
                para_qos
                exit 1
                ;;
        status)
        echo "****** [qdisc] ******"
            tc -s qdisc show dev $INTERFAZ

            echo ""
            echo "****** [class] ******"
            tc -s class show dev $INTERFAZ

            echo ""
            echo "****** [filter] ******"
            tc -s filter show dev $INTERFAZ

            echo ""
            echo "****** [iptables] ******"
            iptables -t mangle -L QOS -v -n -x 2> /dev/null
            exit
        ;;
        monitor)
        watch tc -s class ls dev $INTERFAZ
        exit 1
                ;;
        start|restart|reload)
        echo "Parando QOS en la interfaz $INTERFAZ. "
        para_qos
        echo "Iniciando el servicio QOS en la interfaz $INTERFAZ. "
        inicia_qos
        echo "HECHO"
                exit 1
                ;;
        *)
                echo "Modo de uso: $0 [intefaz] [] (start|stop|status|monitor|restart|reload)"
                exit 1
                ;;