def test_raw_socket_close(self):
self.god.stub_function(socket, 'setdefaulttimeout')
s = self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# close without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.close()
except error.TestError:
pass
else:
self.assertEquals(1, 0)
# close after open
socket.setdefaulttimeout.expect_call(1)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
sock.open(protocol=None)
s.close.expect_call()
sock.close()
self.god.check_playback()
def test_raw_socket_close(self):
self.god.stub_function(socket, 'setdefaulttimeout')
s = self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# close without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.close()
except error.TestError:
pass
else:
self.assertEquals(1, 0)
# close after open
socket.setdefaulttimeout.expect_call(1)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
sock.open(protocol=None)
s.close.expect_call()
sock.close()
self.god.check_playback()
def test_raw_socket_send(self):
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
self.god.stub_function(socket, 'send')
# send without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.send('test this packet')
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to send a packet
s = net_utils_mock.socket_stub('eth0', socket, socket)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
packet = '\xFF\xAA\xBB\xCC\xDD\x11packet data\x00\x00'
s.send.expect_call(packet)
sock.open(protocol=1234)
sock.send(packet)
self.god.check_playback()
def test_raw_socket_send(self):
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
self.god.stub_function(socket, 'send')
# send without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.send('test this packet')
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to send a packet
s = net_utils_mock.socket_stub('eth0', socket, socket)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
packet = '\xFF\xAA\xBB\xCC\xDD\x11packet data\x00\x00'
s.send.expect_call(packet)
sock.open(protocol=1234)
sock.send(packet)
self.god.check_playback()
def test_raw_socket_open(self):
self.god.stub_function(socket, 'setdefaulttimeout')
s = self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# open without a protocol
socket.setdefaulttimeout.expect_call(1)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
sock.open(protocol=None)
self.god.check_playback()
# double open should throw an exception
try:
sock.open()
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol
socket.setdefaulttimeout.expect_call(1)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
sock.open(protocol=1234)
self.god.check_playback()
def test_raw_socket_open(self):
self.god.stub_function(socket, 'setdefaulttimeout')
s = self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# open without a protocol
socket.setdefaulttimeout.expect_call(1)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
sock.open(protocol=None)
self.god.check_playback()
# double open should throw an exception
try:
sock.open()
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol
socket.setdefaulttimeout.expect_call(1)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
sock.open(protocol=1234)
self.god.check_playback()
def test_raw_socket_send_to(self):
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
self.god.stub_function(socket, 'send')
# send without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.send_to('0', '1', 1, 'test this packet')
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to send a packet
s = net_utils_mock.socket_stub('eth0', socket, socket)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
packet = '\x00\x00packet data\x00\x00'
s.send.expect_call(packet)
sock.open(protocol=1234)
try:
sock.send_to(None, None, 1, packet)
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
dst_mac = '\x00\x01\x02\x03\x04\x05'
src_mac = '\xFF\xEE\xDD\xCC\xBB\xAA'
protocol = 1234
s.send.expect_call(dst_mac + src_mac + '%d' % protocol + packet)
sock.send_to(dst_mac, src_mac, protocol, packet)
self.god.check_playback()
def test_raw_socket_send_to(self):
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
self.god.stub_function(socket, 'send')
# send without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.send_to('0', '1', 1, 'test this packet')
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to send a packet
s = net_utils_mock.socket_stub('eth0', socket, socket)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
packet = '\x00\x00packet data\x00\x00'
s.send.expect_call(packet)
sock.open(protocol=1234)
try:
sock.send_to(None, None, 1, packet)
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
dst_mac = '\x00\x01\x02\x03\x04\x05'
src_mac = '\xFF\xEE\xDD\xCC\xBB\xAA'
protocol = 1234
s.send.expect_call(dst_mac+src_mac+'%d'%protocol+packet)
sock.send_to(dst_mac, src_mac, protocol, packet)
self.god.check_playback()
def test_raw_socket_recv_from(self):
def __set_clock(sock):
time.clock.expect_call().and_return(0.0)
time.clock.expect_call().and_return(0.0)
time.clock.expect_call().and_return(float(sock.socket_timeout()) + 0.5)
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# rcv without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.recv_from(None, None, None)
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to get packets of varying sizes
# I could not get socket.recv to get a mock expect_call. To keep
# on going, added a socket stub
s = net_utils_mock.socket_stub('eth0', socket, socket)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock.open(protocol=1234)
s.recv_val = ''
dst_mac = net_utils.ethernet.mac_string_to_binary('00:01:02:03:04:05')
src_mac = net_utils.ethernet.mac_string_to_binary('16:17:18:19:1A:1B')
t_mac = net_utils.ethernet.mac_string_to_binary('E6:E7:E8:E9:EA:EB')
protocol = 2030
t_protocol = 1234
data = '\xEE' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE)
# no data to receive at socket
self.assertEquals(sock.recv_from(None, None, None), None)
self.assertEquals(sock.recv_from(dst_mac, None, None), None)
self.assertEquals(sock.recv_from(None, src_mac, None), None)
self.assertEquals(sock.recv_from(None, None, protocol), None)
# receive packet < min size
s.recv_val = (struct.pack("!6s6sH", dst_mac, src_mac, protocol) +
'packet_to_short')
self.assertEquals(sock.recv_from(None, None, None), None)
# receive packet, filtering on mac address and protocol
s.recv_val = struct.pack("!6s6sH", dst_mac, t_mac, t_protocol) + data
frame = net_utils.ethernet.unpack(s.recv_val)
self.assertEquals(sock.recv_from(None, None, None), frame)
self.assertEquals(sock.recv_from(dst_mac, None, None), frame)
# use time clock to speed up the timeout in send_to()
self.god.stub_function(time, 'clock')
__set_clock(sock)
self.assertEquals(sock.recv_from(dst_mac, src_mac, None), None)
__set_clock(sock)
self.assertEquals(sock.recv_from(dst_mac, None, protocol), None)
__set_clock(sock)
self.assertEquals(sock.recv_from(dst_mac, src_mac, protocol), None)
self.god.unstub(time, 'clock')
s.recv_val = struct.pack("!6s6sH", dst_mac, src_mac, protocol) + data
frame = net_utils.ethernet.unpack(s.recv_val)
self.assertEquals(sock.recv_from(dst_mac, None, None), frame)
self.assertEquals(sock.recv_from(dst_mac, src_mac, None), frame)
self.assertEquals(sock.recv_from(dst_mac, src_mac, protocol), frame)
self.assertEquals(sock.recv_from(None, None, protocol), frame)
self.assertEquals(sock.recv_from(None, src_mac, None), frame)
self.god.stub_function(time, 'clock')
__set_clock(sock)
self.assertEquals(sock.recv_from(None, None, t_protocol), None)
__set_clock(sock)
self.assertEquals(sock.recv_from(None, t_mac, None), None)
self.god.unstub(time, 'clock')
self.god.check_playback()
def test_raw_socket_recv(self):
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# rcv without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.recv(10)
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to get packets of varying sizes
# I could not get socket.recv to get a mock expect_call. To keep
# on going, added a socket stub
s = net_utils_mock.socket_stub('eth0', socket, socket)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock.open(protocol=1234)
s.recv_val = ''
self.assertEquals(sock.recv(1), (None, 0))
s.recv_val = '\xFF' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE - 5)
self.assertEquals(sock.recv(1), (None, 0))
# when receiving a packet, make sure the timeout is not change
s.recv_val = '\xEE' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE - 4)
self.assertEquals(sock.recv(1), (s.recv_val, 1))
s.recv_val = '\xDD' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE)
self.assertEquals(sock.recv(1), (s.recv_val, 1))
s.recv_val = '\xCC' * (net_utils.ethernet.ETH_PACKET_MAX_SIZE)
self.assertEquals(sock.recv(1), (s.recv_val, 1))
s.recv_val = '\xBB' * (net_utils.ethernet.ETH_PACKET_MAX_SIZE + 1)
packet, time_left = sock.recv(1)
self.assertEquals(len(packet), net_utils.ethernet.ETH_PACKET_MAX_SIZE)
self.assertEquals(packet,
s.recv_val[:net_utils.ethernet.ETH_PACKET_MAX_SIZE])
# test timeout
s.recv_val = ''
s.throw_timeout = False
sock.recv(5)
self.assertEquals(sock.recv(1), (None, 0))
s.throw_timeout = True
sock.recv(5)
self.assertEquals(sock.recv(1), (None, 0))
self.god.check_playback()
def test_raw_socket_recv_from(self):
def __set_clock(sock):
time.clock.expect_call().and_return(0.0)
time.clock.expect_call().and_return(0.0)
time.clock.expect_call().and_return(float(sock.socket_timeout()) + 0.5)
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# rcv without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.recv_from(None, None, None)
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to get packets of varying sizes
# I could not get socket.recv to get a mock expect_call. To keep
# on going, added a socket stub
s = net_utils_mock.socket_stub('eth0', socket, socket)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock.open(protocol=1234)
s.recv_val = ''
dst_mac = net_utils.ethernet.mac_string_to_binary('00:01:02:03:04:05')
src_mac = net_utils.ethernet.mac_string_to_binary('16:17:18:19:1A:1B')
t_mac = net_utils.ethernet.mac_string_to_binary('E6:E7:E8:E9:EA:EB')
protocol = 2030
t_protocol = 1234
data = '\xEE' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE)
# no data to receive at socket
self.assertEquals(sock.recv_from(None, None, None), None)
self.assertEquals(sock.recv_from(dst_mac, None, None), None)
self.assertEquals(sock.recv_from(None, src_mac, None), None)
self.assertEquals(sock.recv_from(None, None, protocol), None)
# receive packet < min size
s.recv_val = (struct.pack("!6s6sH", dst_mac, src_mac, protocol) +
'packet_to_short')
self.assertEquals(sock.recv_from(None, None, None), None)
# receive packet, filtering on mac address and protocol
s.recv_val = struct.pack("!6s6sH", dst_mac, t_mac, t_protocol) + data
frame = net_utils.ethernet.unpack(s.recv_val)
self.assertEquals(sock.recv_from(None, None, None), frame)
self.assertEquals(sock.recv_from(dst_mac, None, None), frame)
# use time clock to speed up the timeout in send_to()
self.god.stub_function(time, 'clock')
__set_clock(sock)
self.assertEquals(sock.recv_from(dst_mac, src_mac, None), None)
__set_clock(sock)
self.assertEquals(sock.recv_from(dst_mac, None, protocol), None)
__set_clock(sock)
self.assertEquals(sock.recv_from(dst_mac, src_mac, protocol), None)
self.god.unstub(time, 'clock')
s.recv_val = struct.pack("!6s6sH", dst_mac, src_mac, protocol) + data
frame = net_utils.ethernet.unpack(s.recv_val)
self.assertEquals(sock.recv_from(dst_mac, None, None), frame)
self.assertEquals(sock.recv_from(dst_mac, src_mac, None), frame)
self.assertEquals(sock.recv_from(dst_mac, src_mac, protocol), frame)
self.assertEquals(sock.recv_from(None, None, protocol), frame)
self.assertEquals(sock.recv_from(None, src_mac, None), frame)
self.god.stub_function(time, 'clock')
__set_clock(sock)
self.assertEquals(sock.recv_from(None, None, t_protocol), None)
__set_clock(sock)
self.assertEquals(sock.recv_from(None, t_mac, None), None)
self.god.unstub(time, 'clock')
self.god.check_playback()
def test_raw_socket_recv(self):
self.god.stub_function(socket, 'setdefaulttimeout')
self.god.create_mock_class(socket.socket, "socket")
self.god.stub_function(socket, 'socket')
# rcv without open
socket.setdefaulttimeout.expect_call(1)
sock = net_utils.raw_socket('eth0')
try:
sock.recv(10)
except error.TestError:
pass
else:
self.assertEquals(1, 0)
self.god.check_playback()
# open a protocol and try to get packets of varying sizes
# I could not get socket.recv to get a mock expect_call. To keep
# on going, added a socket stub
s = net_utils_mock.socket_stub('eth0', socket, socket)
socket.socket.expect_call(socket.PF_PACKET,
socket.SOCK_RAW,
socket.htons(1234)).and_return(s)
self.god.stub_function(s, 'bind')
self.god.stub_function(s, 'settimeout')
s.bind.expect_call(('eth0', net_utils.raw_socket.ETH_P_ALL))
s.settimeout.expect_call(1)
sock.open(protocol=1234)
s.recv_val = ''
self.assertEquals(sock.recv(1), (None, 0))
s.recv_val = '\xFF' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE-5)
self.assertEquals(sock.recv(1), (None, 0))
# when receiving a packet, make sure the timeout is not change
s.recv_val = '\xEE' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE-4)
self.assertEquals(sock.recv(1), (s.recv_val, 1))
s.recv_val = '\xDD' * (net_utils.ethernet.ETH_PACKET_MIN_SIZE)
self.assertEquals(sock.recv(1), (s.recv_val, 1))
s.recv_val = '\xCC' * (net_utils.ethernet.ETH_PACKET_MAX_SIZE)
self.assertEquals(sock.recv(1), (s.recv_val, 1))
s.recv_val = '\xBB' * (net_utils.ethernet.ETH_PACKET_MAX_SIZE+1)
packet, time_left = sock.recv(1)
self.assertEquals(len(packet), net_utils.ethernet.ETH_PACKET_MAX_SIZE)
self.assertEquals(packet,
s.recv_val[:net_utils.ethernet.ETH_PACKET_MAX_SIZE])
# test timeout
s.recv_val = ''
s.throw_timeout = False
sock.recv(5)
self.assertEquals(sock.recv(1), (None, 0))
s.throw_timeout = True
sock.recv(5)
self.assertEquals(sock.recv(1), (None, 0))
self.god.check_playback()
