def run(self):
"""Thread that does the actual job of processing RADIUS packets"""
# since this method is assigned to thread we have to catch all exceptions
# by ourselves
try:
threadnum = self.getName()
hosts = self.server.hosts
packets = self.server.packets
auth_timeout = main_config["AUTHORIZATION"]["packet_timeout"]
info("--- started %s ---" % threadnum)
while self.threadMayRun:
# grab a RADIUS packet and process it
pkt = packets.remove_packet(blocking=False)
if not pkt:
continue
# check if this thread should be allowed for logging
if pkt.source[0] in hosts and hosts[
pkt.source[0]].enableLogging:
logger.addUnrestrictedThread()
info('thread "%s" grabbed a packet for processing' % threadnum)
if isinstance(pkt, packet.AuthPacket):
# check if packet is too old
if (time.time() - pkt.timestamp > auth_timeout):
continue
try:
authResult = self.ProcessAuthPacket(pkt)
except AuthFailure, err:
error("auth failure: ", err)
continue
except:
misc.printException()
continue
# create and send a reply packet
address = pkt.source[0]
client = hosts[address]
if authResult[0]:
# access accept
code = packet.AccessAccept
debug("Sending Authorization ACCEPT to %s (%s)" %
(client.name, address))
else:
# access reject
code = packet.AccessReject
debug("Sending Authorization REJECT to %s (%s)" %
(client.name, address))
reply = pkt.CreateReply(**authResult[1])
reply.source = pkt.source
reply.code = code
debug(reply)
pkt.fd.sendto(reply.ReplyPacket(), reply.source)
def run(self):
"""Thread that does the actual job of processing RADIUS packets"""
# since this method is assigned to thread we have to catch all exceptions
# by ourselves
try:
threadnum = self.getName()
hosts = self.server.hosts
packets = self.server.packets
auth_timeout = main_config["AUTHORIZATION"]["packet_timeout"]
info("--- started %s ---" % threadnum)
while self.threadMayRun:
# grab a RADIUS packet and process it
pkt = packets.remove_packet(blocking = False)
if not pkt:
continue
# check if this thread should be allowed for logging
if pkt.source[0] in hosts and hosts[pkt.source[0]].enableLogging:
logger.addUnrestrictedThread()
info('thread "%s" grabbed a packet for processing' % threadnum)
if isinstance(pkt, packet.AuthPacket):
# check if packet is too old
if (time.time() - pkt.timestamp > auth_timeout):
continue
try:
authResult = self.ProcessAuthPacket(pkt)
except AuthFailure, err:
error ("auth failure: ", err)
continue
except:
misc.printException()
continue
# create and send a reply packet
address = pkt.source[0]
client = hosts[address]
if authResult[0]:
# access accept
code = packet.AccessAccept
debug ("Sending Authorization ACCEPT to %s (%s)" % (client.name, address))
else:
# access reject
code = packet.AccessReject
debug ("Sending Authorization REJECT to %s (%s)" % (client.name, address))
reply = pkt.CreateReply(**authResult[1])
reply.source = pkt.source
reply.code = code
debug (reply)
pkt.fd.sendto(reply.ReplyPacket(), reply.source)
def applyConfig(self):
"""Apply configuration
"""
# apply options
if self['SERVER']['debug_mode']:
self['SERVER']['foreground'] = True
self['SERVER']['no_threads'] = True
self['SERVER']['log_to_screen'] = True
if self['SERVER']['log_to_screen']:
self['SERVER']['log_to_file'] = False
logger.logToScreen = True
if self['SERVER']['log_client']:
# restrict all threads from logger
info ('--- Enabling threads logging restrictions ---')
logger.restrictThreads = True
# add this (main) thread to unrestricted threads to allow print log messages
logger.addUnrestrictedThread()
def applyConfig(self):
"""Apply configuration
"""
# apply options
if self['SERVER']['debug_mode']:
self['SERVER']['foreground'] = True
self['SERVER']['no_threads'] = True
self['SERVER']['log_to_screen'] = True
if self['SERVER']['log_to_screen']:
self['SERVER']['log_to_file'] = False
logger.logToScreen = True
if self['SERVER']['log_client']:
# restrict all threads from logger
info('--- Enabling threads logging restrictions ---')
logger.restrictThreads = True
# add this (main) thread to unrestricted threads to allow print log messages
logger.addUnrestrictedThread()
def applyConfig(self):
"""Apply configuration
"""
# apply options
if self["SERVER"]["debug_mode"]:
self["SERVER"]["foreground"] = True
self["SERVER"]["no_threads"] = True
self["SERVER"]["log_to_screen"] = True
if self["SERVER"]["log_to_screen"]:
self["SERVER"]["log_to_file"] = False
logger.logToScreen = True
if self["SERVER"]["log_client"]:
# restrict all threads from logger
info("--- Enabling threads logging restrictions ---")
logger.restrictThreads = True
# add this (main) thread to unrestricted threads to allow print log messages
logger.addUnrestrictedThread()
def run(self):
"""Thread that does the actual job of processing RADIUS packets"""
# since this method is assigned to thread we have to catch all exceptions
# by ourselves
try:
threadnum = self.getName()
hosts = self.server.hosts
packets = self.server.packets
auth_timeout = main_config["AUTHORIZATION"]["packet_timeout"]
info("--- started %s ---" % threadnum)
while self.threadMayRun:
# grab a RADIUS packet and process it
pkt = packets.remove_packet(blocking=False)
if not pkt:
continue
# check if this thread should be allowed for logging
if pkt.source[0] in hosts and hosts[
pkt.source[0]].enableLogging:
logger.addUnrestrictedThread()
info('thread "%s" grabbed a packet for processing' % threadnum)
if isinstance(pkt, packet.AuthPacket):
# check if packet is too old
if (time.time() - pkt.timestamp > auth_timeout):
# Dump timed out auth packet
dumpPacket.dumpUnhandledAuthPacket(pkt)
continue
try:
authResult = self.ProcessAuthPacket(pkt)
except AuthFailure, err:
error("auth failure: ", err)
continue
except:
misc.printException()
continue
# create and send a reply packet
self.sendAuthResponse(pkt, authResult)
def run(self):
"""Thread that does the actual job of processing RADIUS packets"""
# since this method is assigned to thread we have to catch all exceptions
# by ourselves
try:
threadnum = self.getName()
hosts = self.server.hosts
packets = self.server.packets
auth_timeout = main_config["AUTHORIZATION"]["packet_timeout"]
info("--- started %s ---" % threadnum)
while self.threadMayRun:
# grab a RADIUS packet and process it
pkt = packets.remove_packet(blocking = False)
if not pkt:
continue
# check if this thread should be allowed for logging
if pkt.source[0] in hosts and hosts[pkt.source[0]].enableLogging:
logger.addUnrestrictedThread()
info('thread "%s" grabbed a packet for processing' % threadnum)
if isinstance(pkt, packet.AuthPacket):
# check if packet is too old
if (time.time() - pkt.timestamp > auth_timeout):
# Dump timed out auth packet
dumpPacket.dumpUnhandledAuthPacket(pkt)
continue
try:
authResult = self.ProcessAuthPacket(pkt)
except AuthFailure, err:
error ("auth failure: ", err)
continue
except:
misc.printException()
continue
# create and send a reply packet
self.sendAuthResponse(pkt, authResult)
def run(self):
"""Listen to sockets and put received packets in raw
data queue for later operations.
Input: none
Output: none
"""
# since this method is assigned to thread we have to catch all exceptions
# by ourselves
try:
info('--- Started Listen thread ---')
# poll packets and put them onto rawpacket sync queue
while self.threadMayRun:
for (socknum, event) in self.server.pollobj.poll(1000):
if event != select.POLLIN:
logger.addUnrestrictedThread()
error("unexpected event!")
logger.rmUnrestrictedThread()
continue
# receive packet
(sock, socktype) = self.server.fdmap[socknum]
(data, addr) = sock.recvfrom(MAXPACKETSZ)
# process the raw packet
if addr[0] in self.server.hosts and self.server.hosts[
addr[0]].enableLogging:
logger.addUnrestrictedThread()
self.ProcessPacket(data, addr, sock, socktype)
logger.rmUnrestrictedThread()
except:
logger.addUnrestrictedThread()
misc.printException()
error('Error in listen thread')
logger.rmUnrestrictedThread()
def run(self):
"""Listen to sockets and put received packets in raw
data queue for later operations.
Input: none
Output: none
"""
# since this method is assigned to thread we have to catch all exceptions
# by ourselves
try:
info ('--- Started Listen thread ---')
# poll packets and put them onto rawpacket sync queue
while self.threadMayRun:
for (socknum, event) in self.server.pollobj.poll(1000):
if event != select.POLLIN:
logger.addUnrestrictedThread()
error ("unexpected event!")
logger.rmUnrestrictedThread()
continue
# receive packet
(sock, socktype) = self.server.fdmap[socknum]
(data, addr) = sock.recvfrom(MAXPACKETSZ)
# process the raw packet
if addr[0] in self.server.hosts and self.server.hosts[addr[0]].enableLogging:
logger.addUnrestrictedThread()
self.ProcessPacket(data, addr, sock, socktype)
logger.rmUnrestrictedThread()
except:
logger.addUnrestrictedThread()
misc.printException()
error ('Error in listen thread')
logger.rmUnrestrictedThread()
# send accounting reply if processing packet was ok
# send acct response to client only after processing the packet
if acctResult is True and not main_config['SERVER'][
'fast_accounting']:
self.sendAcctResponse(pkt)
else:
error('Wrong packet received: ', pkt)
info('%s\n\n' % ('=' * 62))
# remove this thread from non-restricted thread list
logger.rmUnrestrictedThread()
except:
logger.addUnrestrictedThread()
misc.printException()
error('Error in working thread')
logger.rmUnrestrictedThread()
def ProcessAuthPacket(self, pkt):
# decrypt crypted attributes
pkt.decryptAttributes()
#debug (pkt)
received = dict(pkt) # don't use packet instance any more
check = {'Auth-Type': [None]}
reply = {}
debug(misc.authPacketToStr(received))
self.ProcessAcctPacket(pkt)
except AcctFailure, err:
error ("acct failure: ", err)
continue
except:
misc.printException()
continue
else:
error('Wrong packet received: ', pkt)
info ('%s\n\n' % ('=' * 62))
# remove this thread from non-restricted thread list
logger.rmUnrestrictedThread()
except:
logger.addUnrestrictedThread()
misc.printException()
error ('Error in working thread')
logger.rmUnrestrictedThread()
def ProcessAuthPacket(self, pkt):
# decrypt crypted attributes
pkt.decryptAttributes()
#debug (pkt)
received = dict(pkt) # don't use packet instance any more
check = {'Auth-Type': [None]}
reply = {}
