Lines Matching refs:self
55 def assertSocketClosed(self, sock): argument
56 self.assertRaisesErrno(ENOTCONN, sock.getpeername)
58 def assertSocketConnected(self, sock): argument
61 def assertSocketsClosed(self, socketpair): argument
63 self.assertSocketClosed(sock)
65 def setUp(self): argument
66 super(SockDiagBaseTest, self).setUp()
67 self.sock_diag = sock_diag.SockDiag()
68 self.socketpairs = {}
70 def tearDown(self): argument
71 for socketpair in self.socketpairs.values():
74 super(SockDiagBaseTest, self).tearDown()
79 def assertSockDiagMatchesSocket(self, s, diag_msg): argument
81 self.assertEqual(diag_msg.family, family)
84 self.assertEqual(diag_msg.id.src, self.sock_diag.PaddedAddress(src))
85 self.assertEqual(diag_msg.id.sport, sport)
87 if self.sock_diag.GetDestinationAddress(diag_msg) not in ["0.0.0.0", "::"]:
89 self.assertEqual(diag_msg.id.dst, self.sock_diag.PaddedAddress(dst))
90 self.assertEqual(diag_msg.id.dport, dport)
92 self.assertRaisesErrno(ENOTCONN, s.getpeername)
94 def testFindsMappedSockets(self): argument
104 diag_msg = self.sock_diag.FindSockDiagFromFd(sock)
105 diag_req = self.sock_diag.DiagReqFromDiagMsg(diag_msg, IPPROTO_TCP)
106 self.sock_diag.GetSockDiag(diag_req)
109 def testFindsAllMySockets(self): argument
118 self.socketpairs = self._CreateLotsOfSockets()
119 sockets = self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, NO_BYTECODE)
120 self.assertGreaterEqual(len(sockets), NUM_SOCKETS)
125 addr = self.sock_diag.GetSourceAddress(diag_msg)
128 if (addr, sport, dport) in self.socketpairs:
130 elif (addr, dport, sport) in self.socketpairs:
134 self.assertEquals(2 * NUM_SOCKETS, len(cookies))
136 socketpairs = self.socketpairs.values()
141 self.assertSockDiagMatchesSocket(
143 self.sock_diag.FindSockDiagFromFd(sock))
144 cookie = self.sock_diag.FindSockDiagFromFd(sock).id.cookie
147 req = self.sock_diag.DiagReqFromSocket(sock)
149 diag_msg = self.sock_diag.GetSockDiag(req)
151 self.assertSockDiagMatchesSocket(sock, diag_msg)
153 def testBytecodeCompilation(self): argument
167 bytecode = self.sock_diag.PackBytecode(instructions)
177 self.assertMultiLineEqual(expected, bytecode.encode("hex"))
178 self.assertEquals(76, len(bytecode))
179 self.socketpairs = self._CreateLotsOfSockets()
180 filteredsockets = self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, bytecode)
181 allsockets = self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, NO_BYTECODE)
182 self.assertItemsEqual(allsockets, filteredsockets)
186 for socketpair in self.socketpairs.values()[:20]:
188 diag_msg = self.sock_diag.FindSockDiagFromFd(s)
195 bytecode = self.sock_diag.PackBytecode(instructions)
196 self.assertEquals(32, len(bytecode))
197 sockets = self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, bytecode)
198 self.assertEquals(1, len(sockets))
201 self.assertEquals(diag_msg.Pack(), sockets[0][0].Pack())
203 def testCrossFamilyBytecode(self): argument
213 self.assertFalse(self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, ""))
218 bytecode4 = self.sock_diag.PackBytecode([
220 bytecode6 = self.sock_diag.PackBytecode([
224 v4sockets = self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, bytecode4)
225 self.assertTrue(v4sockets)
226 self.assertTrue(all(d.family == AF_INET for d, _ in v4sockets))
228 v6sockets = self.sock_diag.DumpAllInetSockets(IPPROTO_TCP, bytecode6)
229 self.assertTrue(v6sockets)
230 self.assertTrue(all(d.family == AF_INET6 for d, _ in v6sockets))
235 diag_msgs = [self.sock_diag.FindSockDiagFromFd(s) for s in pair5]
236 v4sockets = [d for d, _ in self.sock_diag.DumpAllInetSockets(IPPROTO_TCP,
238 v6sockets = [d for d, _ in self.sock_diag.DumpAllInetSockets(IPPROTO_TCP,
240 self.assertTrue(all(d in v4sockets for d in diag_msgs))
241 self.assertTrue(all(d in v6sockets for d in diag_msgs))
243 def testPortComparisonValidation(self): argument
251 self.assertRaisesErrno(
253 self.sock_diag.DumpAllInetSockets, IPPROTO_TCP, bytecode.Pack())
255 def testNonSockDiagCommand(self): argument
257 sock_id = self.sock_diag._EmptyInetDiagSockId()
260 self.sock_diag._Dump(code, req, sock_diag.InetDiagMsg, "")
264 self.assertRaisesErrno(EINVAL, DiagDump, op + 17)
300 def testClosesSockets(self): argument
301 self.socketpairs = self._CreateLotsOfSockets()
302 for _, socketpair in self.socketpairs.iteritems():
307 self.sock_diag.CloseSocketFromFd(s)
309 diag_msg = self.sock_diag.FindSockDiagFromFd(s)
315 req = self.sock_diag.DiagReqFromDiagMsg(diag_msg, IPPROTO_TCP)
316 self.assertRaisesErrno(ENOENT, self.sock_diag.CloseSocket, req)
317 self.assertSocketConnected(s)
321 self.sock_diag.CloseSocket(req)
324 self.assertSocketsClosed(socketpair)
326 def testNonTcpSockets(self): argument
329 self.sock_diag.FindSockDiagFromFd(s) # No exceptions? Good.
330 self.assertRaisesErrno(EOPNOTSUPP, self.sock_diag.CloseSocketFromFd, s)
338 def __init__(self, sock, operation): argument
339 self.exception = None
340 super(SocketExceptionThread, self).__init__()
341 self.daemon = True
342 self.sock = sock
343 self.operation = operation
345 def run(self): argument
347 self.operation(self.sock)
349 self.exception = e
354 def testIpv4MappedSynRecvSocket(self): argument
361 netid = random.choice(self.tuns.keys())
362 self.IncomingConnection(5, tcp_test.TCP_SYN_RECV, netid)
363 sock_id = self.sock_diag._EmptyInetDiagSockId()
364 sock_id.sport = self.port
367 children = self.sock_diag.Dump(req, NO_BYTECODE)
369 self.assertTrue(children)
371 self.assertEqual(tcp_test.TCP_SYN_RECV, child.state)
372 self.assertEqual(self.sock_diag.PaddedAddress(self.remoteaddr),
374 self.assertEqual(self.sock_diag.PaddedAddress(self.myaddr),
380 def setUp(self): argument
381 super(SockDestroyTcpTest, self).setUp()
382 self.netid = random.choice(self.tuns.keys())
384 def CheckRstOnClose(self, sock, req, expect_reset, msg, do_close=True): argument
387 self.assertIsNone(req, "Must specify sock or req, not both")
388 self.sock_diag.CloseSocketFromFd(sock)
389 self.assertRaisesErrno(EINVAL, sock.accept)
391 self.assertIsNone(sock, "Must specify sock or req, not both")
392 self.sock_diag.CloseSocket(req)
395 desc, rst = self.RstPacket()
397 self.ExpectPacketOn(self.netid, msg, rst)
400 self.ExpectNoPacketsOn(self.netid, msg)
405 def CheckTcpReset(self, state, statename): argument
408 self.IncomingConnection(version, state, self.netid)
409 self.CheckRstOnClose(self.s, None, False, msg)
412 self.CheckRstOnClose(self.accepted, None, True, msg)
414 def testTcpResets(self): argument
416 self.CheckTcpReset(tcp_test.TCP_LISTEN, "TCP_LISTEN")
417 self.CheckTcpReset(tcp_test.TCP_ESTABLISHED, "TCP_ESTABLISHED")
418 self.CheckTcpReset(tcp_test.TCP_CLOSE_WAIT, "TCP_CLOSE_WAIT")
420 def FindChildSockets(self, s): argument
422 d = self.sock_diag.FindSockDiagFromFd(self.s)
423 req = self.sock_diag.DiagReqFromDiagMsg(d, IPPROTO_TCP)
426 children = self.sock_diag.Dump(req, NO_BYTECODE)
427 return [self.sock_diag.DiagReqFromDiagMsg(d, IPPROTO_TCP)
430 def CheckChildSocket(self, version, statename, parent_first): argument
433 self.IncomingConnection(version, state, self.netid)
435 d = self.sock_diag.FindSockDiagFromFd(self.s)
436 parent = self.sock_diag.DiagReqFromDiagMsg(d, IPPROTO_TCP)
437 children = self.FindChildSockets(self.s)
438 self.assertEquals(1, len(children))
450 self.sock_diag.GetSockDiag(child) # No errors? Good, child found.
452 self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child)
457 self.CheckRstOnClose(self.s, None, expect_reset, msg)
458 self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, parent)
462 self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child)
468 self.sock_diag.GetSockDiag(child)
469 self.CheckRstOnClose(None, child, is_established, msg)
470 self.assertRaisesErrno(ENOENT, self.sock_diag.GetSockDiag, child)
482 self.s.close()
487 self.s.close()
489 def testChildSockets(self): argument
491 self.CheckChildSocket(version, "TCP_SYN_RECV", False)
492 self.CheckChildSocket(version, "TCP_SYN_RECV", True)
493 self.CheckChildSocket(version, "TCP_NOT_YET_ACCEPTED", False)
494 self.CheckChildSocket(version, "TCP_NOT_YET_ACCEPTED", True)
496 def CloseDuringBlockingCall(self, sock, call, expected_errno): argument
500 self.sock_diag.CloseSocketFromFd(sock)
502 self.assertFalse(thread.is_alive())
503 self.assertIsNotNone(thread.exception)
504 self.assertTrue(isinstance(thread.exception, IOError),
506 self.assertEqual(expected_errno, thread.exception.errno)
507 self.assertSocketClosed(sock)
509 def testAcceptInterrupted(self): argument
512 self.IncomingConnection(version, tcp_test.TCP_LISTEN, self.netid)
513 self.CloseDuringBlockingCall(self.s, lambda sock: sock.accept(), EINVAL)
514 self.assertRaisesErrno(ECONNABORTED, self.s.send, "foo")
515 self.assertRaisesErrno(EINVAL, self.s.accept)
517 def testReadInterrupted(self): argument
520 self.IncomingConnection(version, tcp_test.TCP_ESTABLISHED, self.netid)
521 self.CloseDuringBlockingCall(self.accepted, lambda sock: sock.recv(4096),
523 self.assertRaisesErrno(EPIPE, self.accepted.send, "foo")
525 def testConnectInterrupted(self): argument
530 self.SelectInterface(s, self.netid, "mark")
532 remoteaddr = "::ffff:" + self.GetRemoteAddress(4)
535 remoteaddr = self.GetRemoteAddress(version)
538 self.CloseDuringBlockingCall(
540 desc, syn = packets.SYN(53, version, self.MyAddress(version, self.netid),
542 self.ExpectPacketOn(self.netid, desc, syn)
544 self.ExpectNoPacketsOn(self.netid, msg)