pyrad 2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

pyrad/proxy.py

@@ -25,7 +25,7 @@ class Proxy(Server):
         self._proxyfd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self._fdmap[self._proxyfd.fileno()] = self._proxyfd
         self._poll.register(self._proxyfd.fileno(),
-                (select.POLLIN | select.POLLPRI | select.POLLERR))
+                            (select.POLLIN | select.POLLPRI | select.POLLERR))
 
     def _HandleProxyPacket(self, pkt):
         """Process a packet received on the reply socket.
@@ -41,7 +41,7 @@ class Proxy(Server):
         pkt.secret = self.hosts[pkt.source[0]].secret
 
         if pkt.code not in [packet.AccessAccept, packet.AccessReject,
-                packet.AccountingResponse]:
+                            packet.AccountingResponse]:
             raise ServerPacketError('Received non-response on proxy socket')
 
     def _ProcessInput(self, fd):

pyrad/server.py

@@ -114,7 +114,7 @@ class Server(host.Host):
         """
         results = set()
         try:
-            tmp = socket.getaddrinfo(addr, 'www')
+            tmp = socket.getaddrinfo(addr, 80)
         except socket.gaierror:
             return []
 
@@ -123,10 +123,9 @@ class Server(host.Host):
 
         return results
 
-
     def BindToAddress(self, addr):
-        """Add an address to listen to.
-        An empty string indicated you want to listen on all addresses.
+        """Add an address to listen on a specific interface.
+        String "0.0.0.0" indicates you want to listen on all interfaces.
 
         :param addr: IP address to listen on
         :type  addr: string
@@ -151,7 +150,6 @@ class Server(host.Host):
                 coafd.bind((address, self.coaport))
                 self.coafds.append(coafd)
 
-
     def HandleAuthPacket(self, pkt):
         """Authentication packet handler.
         This is an empty function that is called when a valid
@@ -247,7 +245,6 @@ class Server(host.Host):
         :type  pkt: Packet class instance
         """
         self._AddSecret(pkt)
-        pkt.secret = self.hosts[pkt.source[0]].secret
         if pkt.code == packet.CoARequest:
             self.HandleCoaPacket(pkt)
         elif pkt.code == packet.DisconnectRequest:
@@ -255,7 +252,6 @@ class Server(host.Host):
         else:
             raise ServerPacketError('Received non-coa packet on coa port')
 
-
     def _GrabPacket(self, pktgen, fd):
         """Read a packet from a network connection.
         This method assumes there is data waiting for to be read.

pyrad/server_async.py

@@ -4,7 +4,6 @@
 
 import asyncio
 import logging
-import traceback
 
 from abc import abstractmethod, ABCMeta
 from enum import Enum
@@ -58,7 +57,7 @@ class DatagramProtocolServer(asyncio.Protocol):
         if addr[0] in self.hosts:
             remote_host = self.hosts[addr[0]]
         elif '0.0.0.0' in self.hosts:
-            remote_host = self.hosts['0.0.0.0'].secret
+            remote_host = self.hosts['0.0.0.0']
         else:
             self.logger.warn('[%s:%d] Drop package from unknown source %s', self.ip, self.port, addr)
             return
@@ -81,7 +80,7 @@ class DatagramProtocolServer(asyncio.Protocol):
                                  dict=self.server.dict,
                                  packet=data)
                 if self.server.enable_pkt_verify:
-                    if req.VerifyAuthRequest():
+                    if not req.VerifyAuthRequest():
                         raise PacketError('Packet verification failed')
 
             elif self.server_type == ServerType.Coa:
@@ -91,7 +90,7 @@ class DatagramProtocolServer(asyncio.Protocol):
                                 dict=self.server.dict,
                                 packet=data)
                 if self.server.enable_pkt_verify:
-                    if req.VerifyCoARequest():
+                    if not req.VerifyCoARequest():
                         raise PacketError('Packet verification failed')
 
             elif self.server_type == ServerType.Acct:
@@ -102,7 +101,7 @@ class DatagramProtocolServer(asyncio.Protocol):
                                  dict=self.server.dict,
                                  packet=data)
                 if self.server.enable_pkt_verify:
-                    if req.VerifyAcctRequest():
+                    if not req.VerifyAcctRequest():
                         raise PacketError('Packet verification failed')
 
             # Call request callback

pyrad/tests/__init__.py

@@ -1,5 +1,5 @@
 import pyrad
-import sys
+import os
 
 pyrad  # keep pyflakes happy
-home = sys.modules["pyrad"].__path__[0]
+home = os.path.dirname(os.path.realpath(__file__))

pyrad/tests/mock.py

@@ -43,11 +43,14 @@ class MockSocket:
         self.address = None
         self.output = []
 
+        # Always initialize data so recv() never fails.
+        # If data is provided, use it; otherwise behave like "no data available".
+        self.data = data if data is not None else b""
+
         if data is not None:
             (self.read_end, self.write_end) = os.pipe()
             fcntl.fcntl(self.write_end, fcntl.F_SETFL, os.O_NONBLOCK)
             os.write(self.write_end, data)
-            self.data = data
         else:
             self.read_end = 1
             self.write_end = None
@@ -59,6 +62,7 @@ class MockSocket:
         self.address = address
 
     def recv(self, buffer):
+        # Return up to `buffer` bytes; if empty, return b"" (no data).
         return self.data[:buffer]
 
     def sendto(self, data, target):

pyrad/tests/{testBidict.py → test_bidict.py}

@@ -52,5 +52,5 @@ class BiDictTests(unittest.TestCase):
         self.bidict.Add("shake", "vanilla")
         self.bidict.Add("pie", "custard")
         self.assertRaises(KeyError, operator.getitem, self.bidict, "missing")
-        self.assertEquals(self.bidict["shake"], "vanilla")
-        self.assertEquals(self.bidict["pie"], "custard")
+        self.assertEqual(self.bidict["shake"], "vanilla")
+        self.assertEqual(self.bidict["pie"], "custard")

pyrad/tests/{testClient.py → test_client.py}

@@ -1,16 +1,15 @@
 import select
 import socket
 import unittest
-import six
+from .mock import MockPacket
+from .mock import MockPoll
+from .mock import MockSocket
 from pyrad.client import Client
 from pyrad.client import Timeout
 from pyrad.packet import AuthPacket
 from pyrad.packet import AcctPacket
 from pyrad.packet import AccessRequest
 from pyrad.packet import AccountingRequest
-from pyrad.tests.mock import MockPacket
-from pyrad.tests.mock import MockPoll
-from pyrad.tests.mock import MockSocket
 
 BIND_IP = "127.0.0.1"
 BIND_PORT = 53535
@@ -22,33 +21,33 @@ class ConstructionTests(unittest.TestCase):
 
     def testSimpleConstruction(self):
         client = Client(self.server)
-        self.failUnless(client.server is self.server)
+        self.assertTrue(client.server is self.server)
         self.assertEqual(client.authport, 1812)
         self.assertEqual(client.acctport, 1813)
-        self.assertEqual(client.secret, six.b(''))
+        self.assertEqual(client.secret, b'')
         self.assertEqual(client.retries, 3)
         self.assertEqual(client.timeout, 5)
-        self.failUnless(client.dict is None)
+        self.assertTrue(client.dict is None)
 
     def testParameterOrder(self):
         marker = object()
         client = Client(self.server, 123, 456, 789, "secret", marker)
-        self.failUnless(client.server is self.server)
+        self.assertTrue(client.server is self.server)
         self.assertEqual(client.authport, 123)
         self.assertEqual(client.acctport, 456)
         self.assertEqual(client.coaport, 789)
         self.assertEqual(client.secret, "secret")
-        self.failUnless(client.dict is marker)
+        self.assertTrue(client.dict is marker)
 
     def testNamedParameters(self):
         marker = object()
         client = Client(server=self.server, authport=123, acctport=456,
-                      secret="secret", dict=marker)
-        self.failUnless(client.server is self.server)
+                        secret="secret", dict=marker)
+        self.assertTrue(client.server is self.server)
         self.assertEqual(client.authport, 123)
         self.assertEqual(client.acctport, 456)
         self.assertEqual(client.secret, "secret")
-        self.failUnless(client.dict is marker)
+        self.assertTrue(client.dict is marker)
 
 
 class SocketTests(unittest.TestCase):
@@ -58,7 +57,6 @@ class SocketTests(unittest.TestCase):
         self.orgsocket = socket.socket
         socket.socket = MockSocket
 
-
     def tearDown(self):
         socket.socket = self.orgsocket
 
@@ -66,13 +64,13 @@ class SocketTests(unittest.TestCase):
         self.client._SocketOpen()
         sock = self.client._socket
         self.client._SocketOpen()
-        self.failUnless(sock is self.client._socket)
+        self.assertTrue(sock is self.client._socket)
 
     def testBind(self):
         self.client.bind((BIND_IP, BIND_PORT))
         self.assertEqual(self.client._socket.address, (BIND_IP, BIND_PORT))
         self.assertEqual(self.client._socket.options,
-                [(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)])
+                         [(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)])
 
     def testBindClosesSocket(self):
         s = MockSocket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -107,7 +105,7 @@ class SocketTests(unittest.TestCase):
         packet = MockPacket(AccessRequest)
         self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
         self.assertEqual(self.client._socket.output,
-                [("request packet", (self.server, 432))])
+                         [("request packet", (self.server, 432))])
 
     def testDoubleRetry(self):
         self.client.retries = 2
@@ -115,15 +113,15 @@ class SocketTests(unittest.TestCase):
         packet = MockPacket(AccessRequest)
         self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
         self.assertEqual(self.client._socket.output,
-                [("request packet", (self.server, 432)),
-                 ("request packet", (self.server, 432))])
+                         [("request packet", (self.server, 432)),
+                          ("request packet", (self.server, 432))])
 
     def testAuthDelay(self):
         self.client.retries = 2
         self.client.timeout = 1
         packet = MockPacket(AccessRequest)
         self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
-        self.failIf("Acct-Delay-Time" in packet)
+        self.assertFalse("Acct-Delay-Time" in packet)
 
     def testSingleAccountDelay(self):
         self.client.retries = 2
@@ -142,24 +140,24 @@ class SocketTests(unittest.TestCase):
     def testIgnorePacketError(self):
         self.client.retries = 1
         self.client.timeout = 1
-        self.client._socket = MockSocket(1, 2, six.b("valid reply"))
+        self.client._socket = MockSocket(1, 2, b'valid reply')
         packet = MockPacket(AccountingRequest, verify=True, error=True)
         self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
 
     def testValidReply(self):
         self.client.retries = 1
         self.client.timeout = 1
-        self.client._socket = MockSocket(1, 2, six.b("valid reply"))
+        self.client._socket = MockSocket(1, 2, b'valid reply')
         self.client._poll = MockPoll()
         MockPoll.results = [(1, select.POLLIN)]
         packet = MockPacket(AccountingRequest, verify=True)
         reply = self.client._SendPacket(packet, 432)
-        self.failUnless(reply is packet.reply)
+        self.assertTrue(reply is packet.reply)
 
     def testInvalidReply(self):
         self.client.retries = 1
         self.client.timeout = 1
-        self.client._socket = MockSocket(1, 2, six.b("invalid reply"))
+        self.client._socket = MockSocket(1, 2, b'invalid reply')
         MockPoll.results = [(1, select.POLLIN)]
         packet = MockPacket(AccountingRequest, verify=False)
         self.assertRaises(Timeout, self.client._SendPacket, packet, 432)
@@ -168,18 +166,18 @@ class SocketTests(unittest.TestCase):
 class OtherTests(unittest.TestCase):
     def setUp(self):
         self.server = object()
-        self.client = Client(self.server, secret=six.b('zeer geheim'))
+        self.client = Client(self.server, secret=b'zeer geheim')
 
     def testCreateAuthPacket(self):
         packet = self.client.CreateAuthPacket(id=15)
-        self.failUnless(isinstance(packet, AuthPacket))
-        self.failUnless(packet.dict is self.client.dict)
+        self.assertTrue(isinstance(packet, AuthPacket))
+        self.assertTrue(packet.dict is self.client.dict)
         self.assertEqual(packet.id, 15)
-        self.assertEqual(packet.secret, six.b('zeer geheim'))
+        self.assertEqual(packet.secret, b'zeer geheim')
 
     def testCreateAcctPacket(self):
         packet = self.client.CreateAcctPacket(id=15)
-        self.failUnless(isinstance(packet, AcctPacket))
-        self.failUnless(packet.dict is self.client.dict)
+        self.assertTrue(isinstance(packet, AcctPacket))
+        self.assertTrue(packet.dict is self.client.dict)
         self.assertEqual(packet.id, 15)
-        self.assertEqual(packet.secret, six.b('zeer geheim'))
+        self.assertEqual(packet.secret, b'zeer geheim')

pyrad/tests/{testDictionary.py → test_dictionary.py}

@@ -1,8 +1,9 @@
 import unittest
 import operator
 import os
-from six import StringIO
-from pyrad.tests import home
+from io import StringIO
+
+from . import home
 from pyrad.dictionary import Attribute
 from pyrad.dictionary import Dictionary
 from pyrad.dictionary import ParseError
@@ -26,7 +27,7 @@ class AttributeTests(unittest.TestCase):
 
     def testNamedConstructionParameters(self):
         attr = Attribute(name='name', code='code', datatype='integer',
-                vendor='vendor')
+                         vendor='vendor')
         self.assertEqual(attr.name, 'name')
         self.assertEqual(attr.code, 'code')
         self.assertEqual(attr.type, 'integer')
@@ -35,7 +36,7 @@ class AttributeTests(unittest.TestCase):
 
     def testValues(self):
         attr = Attribute('name', 'code', 'integer', False, 'vendor',
-                dict(pie='custard', shake='vanilla'))
+                         dict(pie='custard', shake='vanilla'))
         self.assertEqual(len(attr.values), 2)
         self.assertEqual(attr.values['shake'], 'vanilla')
 
@@ -54,14 +55,13 @@ class DictionaryInterfaceTests(unittest.TestCase):
         self.assertEqual(dict.has_key('test'), True)
 
     def testReadonlyContainer(self):
-        import six
         dict = Dictionary()
         self.assertRaises(TypeError,
-                operator.setitem, dict, 'test', 'dummy')
+                          operator.setitem, dict, 'test', 'dummy')
         self.assertRaises(AttributeError,
-                operator.attrgetter('clear'), dict)
+                          operator.attrgetter('clear'), dict)
         self.assertRaises(AttributeError,
-                operator.attrgetter('update'), dict)
+                          operator.attrgetter('update'), dict)
 
 
 class DictionaryParsingTests(unittest.TestCase):
@@ -69,7 +69,7 @@ class DictionaryParsingTests(unittest.TestCase):
     simple_dict_values = [
         ('Test-String', 1, 'string'),
         ('Test-Octets', 2, 'octets'),
-        ('Test-Integer', 3, 'integer'),
+        ('Test-Integer', 0x03, 'integer'),
         ('Test-Ip-Address', 4, 'ipaddr'),
         ('Test-Ipv6-Address', 5, 'ipv6addr'),
         ('Test-If-Id', 6, 'ifid'),
@@ -78,11 +78,13 @@ class DictionaryParsingTests(unittest.TestCase):
         ('Test-Tlv', 9, 'tlv'),
         ('Test-Tlv-Str', 1, 'string'),
         ('Test-Tlv-Int', 2, 'integer'),
-        ('Test-Integer64', 10, 'integer64')
+        ('Test-Integer64', 10, 'integer64'),
+        ('Test-Integer64-Hex', 10, 'integer64'),
+        ('Test-Integer64-Oct', 10, 'integer64'),
     ]
 
     def setUp(self):
-        self.path = os.path.join(home, 'tests', 'data')
+        self.path = os.path.join(home, 'data')
         self.dict = Dictionary(os.path.join(self.path, 'simple'))
 
     def testParseEmptyDictionary(self):
@@ -98,7 +100,7 @@ class DictionaryParsingTests(unittest.TestCase):
         self.assertEqual(len(dict), 2)
 
     def testParseSimpleDictionary(self):
-        self.assertEqual(len(self.dict),len(self.simple_dict_values))
+        self.assertEqual(len(self.dict), len(self.simple_dict_values))
         for (attr, code, type) in self.simple_dict_values:
             attr = self.dict[attr]
             self.assertEqual(attr.code, code)
@@ -167,7 +169,7 @@ class DictionaryParsingTests(unittest.TestCase):
         self.assertEqual(len(self.dict['Test-Integer'].values), 1)
         self.assertEqual(
                 DecodeAttr('integer',
-                    self.dict['Test-Integer'].values['Value-Six']),
+                           self.dict['Test-Integer'].values['Value-Six']),
                 5)
 
     def testInteger64ValueParsing(self):
@@ -176,7 +178,7 @@ class DictionaryParsingTests(unittest.TestCase):
         self.assertEqual(len(self.dict['Test-Integer64'].values), 1)
         self.assertEqual(
                 DecodeAttr('integer64',
-                    self.dict['Test-Integer64'].values['Value-Six']),
+                           self.dict['Test-Integer64'].values['Value-Six']),
                 5)
 
     def testStringValueParsing(self):
@@ -186,12 +188,28 @@ class DictionaryParsingTests(unittest.TestCase):
         self.assertEqual(len(self.dict['Test-String'].values), 1)
         self.assertEqual(
                 DecodeAttr('string',
-                    self.dict['Test-String'].values['Value-Custard']),
+                           self.dict['Test-String'].values['Value-Custard']),
                 'custardpie')
 
+    def testOctetValueParsing(self):
+        self.assertEqual(len(self.dict['Test-Octets'].values), 0)
+        self.dict.ReadDictionary(StringIO(
+                        'ATTRIBUTE Test-Octets 1 octets\n'
+                        'VALUE Test-Octets Value-A 65\n'      # "A"
+                        'VALUE Test-Octets Value-B 0x42\n'))  # "B"
+        self.assertEqual(len(self.dict['Test-Octets'].values), 2)
+        self.assertEqual(
+                DecodeAttr('octets',
+                           self.dict['Test-Octets'].values['Value-A']),
+                b'A')
+        self.assertEqual(
+                DecodeAttr('octets',
+                           self.dict['Test-Octets'].values['Value-B']),
+                b'B')
+
     def testTlvParsing(self):
         self.assertEqual(len(self.dict['Test-Tlv'].sub_attributes), 2)
-        self.assertEqual(self.dict['Test-Tlv'].sub_attributes, {1:'Test-Tlv-Str', 2: 'Test-Tlv-Int'})
+        self.assertEqual(self.dict['Test-Tlv'].sub_attributes, {1: 'Test-Tlv-Str', 2: 'Test-Tlv-Int'})
 
     def testSubTlvParsing(self):
         for (attr, _, _) in self.simple_dict_values:
@@ -209,7 +227,6 @@ class DictionaryParsingTests(unittest.TestCase):
         self.assertEqual(full_dict['Simplon-Tlv-Int'].is_sub_attribute, True)
         self.assertEqual(full_dict['Simplon-Tlv-Int'].parent, full_dict['Simplon-Tlv'])
 
-
     def testVenderTooFewColumnsError(self):
         try:
             self.dict.ReadDictionary(StringIO('VENDOR Simplon'))
@@ -220,7 +237,7 @@ class DictionaryParsingTests(unittest.TestCase):
 
     def testVendorParsing(self):
         self.assertRaises(ParseError, self.dict.ReadDictionary,
-                StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
+                          StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
         self.dict.ReadDictionary(StringIO('VENDOR Simplon 42'))
         self.assertEqual(self.dict.vendors['Simplon'], 42)
         self.dict.ReadDictionary(StringIO(
@@ -229,7 +246,7 @@ class DictionaryParsingTests(unittest.TestCase):
 
     def testVendorOptionError(self):
         self.assertRaises(ParseError, self.dict.ReadDictionary,
-                StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
+                          StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
         try:
             self.dict.ReadDictionary(StringIO('VENDOR Simplon 42 badoption'))
         except ParseError as e:
@@ -239,7 +256,7 @@ class DictionaryParsingTests(unittest.TestCase):
 
     def testVendorFormatError(self):
         self.assertRaises(ParseError, self.dict.ReadDictionary,
-                StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
+                          StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
         try:
             self.dict.ReadDictionary(StringIO(
                 'VENDOR Simplon 42 format=5,4'))
@@ -250,7 +267,7 @@ class DictionaryParsingTests(unittest.TestCase):
 
     def testVendorFormatSyntaxError(self):
         self.assertRaises(ParseError, self.dict.ReadDictionary,
-                StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
+                          StringIO('ATTRIBUTE Test-Type 1 integer Simplon'))
         try:
             self.dict.ReadDictionary(StringIO(
                 'VENDOR Simplon 42 format=a,1'))

pyrad/tests/{testHost.py → test_host.py}

@@ -32,20 +32,20 @@ class PacketCreationTests(unittest.TestCase):
 
     def testCreatePacket(self):
         packet = self.host.CreatePacket(id=15)
-        self.failUnless(isinstance(packet, Packet))
-        self.failUnless(packet.dict is self.host.dict)
+        self.assertTrue(isinstance(packet, Packet))
+        self.assertTrue(packet.dict is self.host.dict)
         self.assertEqual(packet.id, 15)
 
     def testCreateAuthPacket(self):
         packet = self.host.CreateAuthPacket(id=15)
-        self.failUnless(isinstance(packet, AuthPacket))
-        self.failUnless(packet.dict is self.host.dict)
+        self.assertTrue(isinstance(packet, AuthPacket))
+        self.assertTrue(packet.dict is self.host.dict)
         self.assertEqual(packet.id, 15)
 
     def testCreateAcctPacket(self):
         packet = self.host.CreateAcctPacket(id=15)
-        self.failUnless(isinstance(packet, AcctPacket))
-        self.failUnless(packet.dict is self.host.dict)
+        self.assertTrue(isinstance(packet, AcctPacket))
+        self.assertTrue(packet.dict is self.host.dict)
         self.assertEqual(packet.id, 15)
 
 
@@ -78,10 +78,10 @@ class PacketSendTest(unittest.TestCase):
 
     def testSendPacket(self):
         self.host.SendPacket(self.fd, self.packet)
-        self.failUnless(self.fd.data is self.packet.packet)
-        self.failUnless(self.fd.target is self.packet.source)
+        self.assertTrue(self.fd.data is self.packet.packet)
+        self.assertTrue(self.fd.target is self.packet.source)
 
     def testSendReplyPacket(self):
         self.host.SendReplyPacket(self.fd, self.packet)
-        self.failUnless(self.fd.data is self.packet.replypacket)
-        self.failUnless(self.fd.target is self.packet.source)
+        self.assertTrue(self.fd.data is self.packet.replypacket)
+        self.assertTrue(self.fd.target is self.packet.source)