def __init__(self, latency, limit=1000, loss=0, gap=0, duplicate=0, jitter=0):
"""Latency is in microseconds [us]"""
latency_ticks = nl_us2ticks(latency)
jitter_ticks = nl_us2ticks(jitter)
data = self.data_format.pack(latency_ticks, limit, loss,
gap, duplicate, jitter_ticks)
Attr.__init__(self, TCA_OPTIONS, data)
def __init__(self,
latency,
limit=1000,
loss=0,
gap=0,
duplicate=0,
jitter=0):
"""Latency is in microseconds [us]"""
latency_ticks = nl_us2ticks(latency)
jitter_ticks = nl_us2ticks(jitter)
data = self.data_format.pack(latency_ticks, limit, loss, gap,
duplicate, jitter_ticks)
Attr.__init__(self, TCA_OPTIONS, data)
def __init__(self, rate, ceil=0, mtu=1600, quantum=0, prio=0):
"""
rate, ceil, mtu: bytes
"""
if not ceil: ceil = rate
r = self.tc_ratespec.pack(3, 0, -1, 0, rate)
c = self.tc_ratespec.pack(3, 0, -1, 0, ceil)
hz = os.sysconf('SC_CLK_TCK')
buffer = tc_calc_xmittime(rate, (rate / hz) + mtu)
cbuffer = tc_calc_xmittime(ceil, (rate / hz) + mtu)
t = self.tc_htb_opt.pack(buffer, cbuffer, quantum, 0, prio)
data = r + c + t
Attr.__init__(self, TCA_HTB_PARMS, data)
def __init__(self, ifindex):
tc_mirred_parms = Attr(TCA_MIRRED_PARMS,
self.data_format.pack(0, 0, TCA_INGRESS_MIRROR, 0, 0,
TCA_EGRESS_REDIR, ifindex))
kind = Attr(TCA_ACT_KIND, "mirred\0")
options = Attr(TCA_ACT_OPTIONS, tc_mirred_parms.pack())
redir = Attr(TCA_EGRESS_REDIR, kind.pack()+options.pack())
super(u32_mirred_action, self).__init__(TCA_U32_ACT, redir.pack())
def test_drop(self):
self.assertEqual(os.getuid(), pwd.getpwnam("root").pw_uid,
"You have to be root to run this test")
# import netlink a create a connection as root
from shapy.framework import netlink
# http://stackoverflow.com/questions/2699907/dropping-root-permissions-in-python
# drop privileges to nobody
os.setuid(pwd.getpwnam("nobody").pw_uid)
#os.setgid(grp.getgrnam("nogroup").gr_gid)
#os.setgroups([])
# try to do operation on a netlink socket while being an unprivileged user
from shapy.framework.netlink.message import Message, Attr
from shapy.framework.netlink.tc import tcmsg
tcm = tcmsg(socket.AF_UNSPEC, self.if_index, self.qhandle, TC_H_ROOT, 0,
[Attr(TCA_KIND, 'pfifo\0')])
msg = Message(type=RTM_NEWQDISC,
flags=NLM_F_EXCL | NLM_F_CREATE | NLM_F_REQUEST | NLM_F_ACK,
service_template=tcm)
netlink.connection.send(msg)
# and observe we are out of luck :/
self.assertRaisesRegexp(OSError, "Operation not permitted",
netlink.connection.recv)
class IngressQdisc(QdiscClassless):
attrs = [Attr(TCA_KIND, 'ingress\0')]
def __init__(self, handle='ffff:', **kwargs):
QdiscClassless.__init__(self, handle, **kwargs)
def get_context(self):
return {'interface': self.interface,
'parent': TC_H_INGRESS}
def __init__(self, bands=3, priomap="1 2 2 2 1 2 0 0 1 1 1 1 1 1 1 1"):
pm = [ int(p) for p in priomap.split() ]
data = self.data_format.pack(bands, *pm)
Attr.__init__(self, TCA_OPTIONS, data)
def unpack(cls, data):
attr, rest = Attr.unpack(data)
opts = cls.data_struct._make(cls.data_format.unpack(attr.payload))
opts = opts._replace(latency=nl_ticks2us(opts.latency))
return cls(*opts), rest
def unpack(cls, data):
attr, rest = Attr.unpack(data)
data = self.data_format.unpack(attr.payload)
opts = cls.data_struct._make((data[0], data[1:]))
return cls(opts.bands, opts.priomap), rest
def unpack(cls, data):
attr, rest = Attr.unpack(data)
data = self.data_format.unpack(attr.payload)
opts = cls.data_struct._make((data[0], data[1:]))
return cls(opts.bands, opts.priomap), rest
def __init__(self, bands=3, priomap="1 2 2 2 1 2 0 0 1 1 1 1 1 1 1 1"):
pm = [int(p) for p in priomap.split()]
data = self.data_format.pack(bands, *pm)
Attr.__init__(self, TCA_OPTIONS, data)
class HTBQdisc(QdiscClassful):
attrs = [Attr(TCA_KIND, 'htb\0'),
HTBQdiscAttr(defcls=settings.HTB_DEFAULT_CLASS)]
class PRIOQdisc(QdiscClassful):
attrs = [Attr(TCA_KIND, 'prio\0'), PrioQdiscAttr()]
def __init__(self, defcls, r2q=10):
data = self.data_format.pack(0x20018, 3, r2q, defcls, 0, 0)
Attr.__init__(self, TCA_OPTIONS, data)
def unpack(cls, data):
attr, rest = Attr.unpack(data)
opts = cls.data_struct._make(cls.data_format.unpack(attr.payload))
opts = opts._replace(latency=nl_ticks2us(opts.latency))
return cls(*opts), rest
class pfifoQdisc(QdiscClassless):
attrs = [Attr(TCA_KIND, 'pfifo\0')]
def __init__(self, rate, mtu, cell_log=3):
rtab = tc_calc_rtable(rate, cell_log, mtu)
data = self.data_format.pack(*rtab)
Attr.__init__(self, TCA_HTB_CTAB, data)
def unpack(cls, data):
attr, rest = Attr.unpack(data)
d = cls.data_format.unpack(attr.data)
return cls(d[0], d[1], d[5], d[7])
def __init__(self, handle, latency, jitter, **kwargs):
self.attrs = [Attr(TCA_KIND, 'netem\0'),
NetemOptions(latency*1000, jitter=jitter*1000)]
QdiscClassless.__init__(self, handle, **kwargs)
def __init__(self, ifindex):
tc_mirred_parms = Attr(
TCA_MIRRED_PARMS,
self.data_format.pack(0, 0, TCA_INGRESS_MIRROR, 0, 0,
TCA_EGRESS_REDIR, ifindex))
kind = Attr(TCA_ACT_KIND, "mirred\0")
options = Attr(TCA_ACT_OPTIONS, tc_mirred_parms.pack())
redir = Attr(TCA_EGRESS_REDIR, kind.pack() + options.pack())
super(u32_mirred_action, self).__init__(TCA_U32_ACT, redir.pack())
