def __init__(self):
Plugin.__init__(self, 'unix')
self._set_summary(_('Plugin to access some popular UNIX applications'))
self._add_command(
'fortune', '[<type>]',
_('displays a random \
fortune. See "help fortune types".'))
self._add_command(
'ddate', None,
_('displays the current date in the \
the discordian calendar.'))
self._add_help_topic(
'fortune_types',
_('Available fortune types: \
fortunes, literature, riddles; default: all.'))
self.wtf_path = '/usr/share/games/bsdgames/'
self.wtf_parseable = True
wtf_enabled = True
if not os.path.isfile(os.path.join(self.wtf_path, 'acronyms')):
self.wtf_parseable = False
if self._get_output('wtf', False, False):
log('i', 'Falling back to system\'s wtf.')
else:
wtf_enabled = False
log('w', 'Couldn\'t find wtf installation; command disabled.')
if wtf_enabled:
self._add_command('wtf', '<acronym> [<type>]', 'tells you what \
<acronym> means.')
def __init__(self):
Plugin.__init__(self, 'insult')
self._set_summary(_('Plugin to insult somebody in the channel'))
self._add_command('insult', '<nick>', _('Insults nick.'))
self._add_command('add_insult', '<phrase>',
_('Adds phrase to the \
insults file.'))
self._add_command('delete_insult', '<phrase>',
_('Deletes phrase \
from the insults file.'))
self.insults = self._load_resource('insults')
if not self.insults:
import urllib2
log('w', 'No insults found in your insults file. Fetching them...')
self.insults['ins'] = []
try:
insults = urllib2.urlopen('http://server.austriangeekforce.' + \
'net/insults.txt')
insult = True
while insult:
insult = insults.readline()[:-1]
if insult:
self._add(insult)
except urllib2.URLError:
log('e', 'Could not fetch insults.')
self._add('You are dumber than someone who knows just one ' + \
'insult!')
raise
def _maintain_cache(self) -> None:
"""Method responsible for maintaining ND cache entries"""
for ip6_address in list(self.nd_cache):
# Skip permanent entries
if self.nd_cache[ip6_address].permanent:
continue
# If entry age is over maximum age then discard the entry
if time.time() - self.nd_cache[
ip6_address].creation_time > config.ND_CACHE_ENTRY_MAX_AGE:
mac_address = self.nd_cache.pop(ip6_address).mac_address
if __debug__:
log(
"nd-c",
f"Discarded expir ICMPv6 ND cache entry - {ip6_address} -> {mac_address}"
)
# If entry age is close to maximum age but the entry has been used since last refresh then send out request in attempt to refresh it
elif (time.time() - self.nd_cache[ip6_address].creation_time >
config.ND_CACHE_ENTRY_MAX_AGE -
config.ND_CACHE_ENTRY_REFRESH_TIME
) and self.nd_cache[ip6_address].hit_count:
self.nd_cache[ip6_address].hit_count = 0
self._send_icmp6_neighbor_solicitation(ip6_address)
if __debug__:
log(
"nd-c",
f"Trying to refresh expiring ICMPv6 ND cache entry for {ip6_address} -> {self.nd_cache[ip6_address].mac_address}"
)
def __init__(self):
Plugin.__init__(self, 'unix')
self._set_summary(_('Plugin to access some popular UNIX applications'))
self._add_command('fortune', '[<type>]', _('displays a random \
fortune. See "help fortune types".'))
self._add_command('ddate', None, _('displays the current date in the \
the discordian calendar.'))
self._add_help_topic('fortune_types', _('Available fortune types: \
fortunes, literature, riddles; default: all.'))
self.wtf_path = '/usr/share/games/bsdgames/'
self.wtf_parseable = True
wtf_enabled = True
if not os.path.isfile(os.path.join(self.wtf_path, 'acronyms')):
self.wtf_parseable = False
if self._get_output('wtf', False, False):
log('i', 'Falling back to system\'s wtf.')
else:
wtf_enabled = False
log('w', 'Couldn\'t find wtf installation; command disabled.')
if wtf_enabled:
self._add_command('wtf', '<acronym> [<type>]', 'tells you what \
<acronym> means.')
def load(filename):
try:
data = pickle.load(open("{}".format(filename), "rb"))
return data
except:
log("FAILED load file {}".format(filename))
return None
def main(cfg):
global api_path
api_path = cfg.api_base + "/executes"
logger.log("Testing Executes API, api path: %s", api_path)
conn = db.connect(cfg)
test_asset_name = "script-test-sp-echo"
_delete(conn, test_asset_name)
try:
asset_id = create_asset(cfg, test_asset_name)
add_role(cfg, asset_id, "script", json.dumps(script_role_value))
add_role(cfg, asset_id, "script-executor-amc", {"os": "linux"})
rsp_msg = execute(cfg, asset_id)
rsp_msg_json = json.loads(rsp_msg)
if rsp_msg_json["code"] != 200:
return logger.failed("unexpected error: " + rsp_msg)
actual_output = str(rsp_msg_json["message"]).rstrip()
if actual_output != expected_output:
return logger.failed("expected: '" + expected_output +
"', actual: '" + actual_output + "'")
except Exception, x:
#traceback.print_exc()
return logger.failed(x.message)
def close(self) -> None:
"""Close socket"""
stack.sockets.pop(str(self), None)
if __debug__:
log("socket", f"<g>[{self}]</> - Closed socket")
def parse_args(arg_list):
"""
I put command line args and their proper values together in a
dictionaryionary and check, if the value is valid.
"""
dictionary = {}
for item in arg_list:
common_pattern = re.compile(r'^(-pn|-s|-po|-pw|-n|-npw|-ho)$')
common_pattern = common_pattern.search(item)
if common_pattern:
try:
value = arg_list[arg_list.index(item) + 1]
dictionary[common_pattern.groups()[0]] = value
except (KeyError, IndexError):
log('e', 'Invalid command line argument.')
help_pattern = re.compile(r'^(-h)$').search(item)
if help_pattern:
dictionary['-h'] = True
else:
dictionary['-h'] = False
conf_pattern = re.compile(r'^(-cnf)$').search(item)
if conf_pattern:
try:
value = arg_list[arg_list.index(item) + 1]
dictionary[common_pattern.groups()[0]] = value
except (KeyError, IndexError):
log('e', 'Invalid command line argument.')
else:
dictionary['-cnf'] = False
return dictionary
def send(self, data: bytes) -> int:
"""Send the data to connected remote host"""
# 'send' call requires 'connect' call to be run prior to it
if self._remote_ip_address.is_unspecified or self._remote_port == 0:
raise OSError("[Errno 89] Destination address requir - [Socket has no destination address set]")
if self._unreachable:
self._unreachable = False
raise ConnectionRefusedError("[Errno 111] Connection refused - [Remote host sent ICMP Unreachable]")
tx_status = stack.packet_handler.send_udp_packet(
local_ip_address=self._local_ip_address,
remote_ip_address=self._remote_ip_address,
local_port=self._local_port,
remote_port=self._remote_port,
data=data,
)
sent_data_len = len(data) if tx_status is TxStatus.PASSED_TO_TX_RING else 0
if __debug__:
log("socket", f"<g>[{self}]</> - <lr>Sent</> {sent_data_len} bytes of data")
return sent_data_len
def run(self,
duration,
view,
request,
ip,
log_time,
entry='mobile',
request_user_id=None,
appendix=None):
_version = request.get('version', 'unkown')
_device = request.get('device', None)
_duid = request.get('duid', None)
_os = request.get('os', None)
_channel = request.get('channel', None)
_prev_str = request.get('prev', None)
mobile_logger.log(
entry=entry,
duration=duration,
ip=ip,
log_time=log_time,
view=view,
request_user_id=request_user_id,
version=_version,
device=_device,
duid=_duid,
os=_os,
channel=_channel,
prev_str=_prev_str,
appendix=appendix,
)
def _phtx_icmp4(
self,
ip4_src: Ip4Address,
ip4_dst: Ip4Address,
icmp4_type: int,
icmp4_code: int = 0,
icmp4_ec_id: Optional[int] = None,
icmp4_ec_seq: Optional[int] = None,
icmp4_ec_data: Optional[bytes] = None,
icmp4_un_data: Optional[bytes] = None,
echo_tracker: Optional[Tracker] = None,
) -> TxStatus:
"""Handle outbound ICMPv4 packets"""
icmp4_packet_tx = Icmp4Assembler(
type=icmp4_type,
code=icmp4_code,
ec_id=icmp4_ec_id,
ec_seq=icmp4_ec_seq,
ec_data=icmp4_ec_data,
un_data=icmp4_un_data,
echo_tracker=echo_tracker,
)
if __debug__:
log("icmp4", f"{icmp4_packet_tx.tracker} - {icmp4_packet_tx}")
return self._phtx_ip4(ip4_src=ip4_src,
ip4_dst=ip4_dst,
carried_packet=icmp4_packet_tx)
def join(self, msg):
level = 29
if self.require_level(msg.user, level):
log('i', '%s ordered to join %s.' % (msg.user.name, msg.params))
msg.bot.join(msg.params)
else:
return _('Unauthorized. Level %s required.' % level)
def service(self, s: Socket) -> None:
"""Inbound connection handler"""
while True:
message, remote_address = s.recvfrom()
if __debug__:
log(
"service",
f"Service UDP Echo: Received {len(message)} bytes from {remote_address[0]}, port {remote_address[1]}"
)
if b"malpka" in message.strip().lower():
message = malpka
elif b"malpa" in message.strip().lower():
message = malpa
elif b"malpi" in message.strip().lower():
message = malpi
s.sendto(message, remote_address)
if __debug__:
log(
"service",
f"Service UDP Echo: Echo'ed {len(message)} bytes back to {remote_address[0]}, port {remote_address[1]}"
)
def join(self, msg):
level = 29
if self.require_level(msg.user, level):
log('i', '%s ordered to join %s.' % (msg.user.name, msg.params))
msg.bot.join(msg.params)
else:
return _('Unauthorized. Level %s required.' % level)
def __init__(self):
"""
Initializing method
"""
self.client = Client()
# Check if config file exists
if not os.path.exists(os.getcwd() + '/config.json'):
print("Для начала нужно ввести данные для авторизации")
self.login = input("Введите ваш логин: ")
self.password = input("Введите ваш пароль: ")
with open(os.getcwd() + '/config.json', 'w',
encoding='UTF-8') as config_file:
config_file.write(
json.dumps({
'login': self.login,
'password': self.password
}))
config_file.close()
log("Файл конфигурации успешно создан")
else:
with open(os.getcwd() + '/config.json') as config_file:
data = json.loads(config_file.read())
config_file.close()
self.login = data['login']
self.password = data['password']
def close_recording(self):
log("Stopped Recording", self.recording_time)
self.current_state = 'POST_RECORDING'
if self.recording_file is not None:
# This basically makes sure we're not truncating
# the recording at the end due to the buffering
# appending the defined number of frames to our
# recording. It basically loops backwards through
# the rolling buffer.
for x in reversed(self.rolling_buffer):
self.recording_file.write_frame(x)
self.recording_file.close()
Popen(["python", "post_recording.py", "-f", self.recording_filename, "-i", str(self.recording_time) ])
self.recording_time = None
self.recording_file = None
self.recording_filename = None
self.current_state = 'IDLE'
def get_cycles_minimum(input_file):
# it seems I can get all the chordless cycles with this approach
# whoever, it is extremely slow, took about 11 minutes to get cycles
# from residential/unclassified streets of "smaller_tsukuba.osm"
G = ox.graph.graph_from_xml(input_file, simplify=False, retain_all=True)
H = nx.Graph(G) # make a simple undirected graph from G
cycles = nx.cycles.minimum_cycle_basis(H) # I think a cycle basis should get all the neighborhoods, except
# we'll need to filter the cycles that are too small.
def order_cycles(H, cycle):
for i in range(len(cycle)-1):
for j in range(i+1, len(cycle)):
if H.has_edge(cycle[i], cycle[j]):
temp = cycle[i+1]
cycle[i+1] = cycle[j]
cycle[j] = temp
break
for c in cycles:
log("Ordering cycle...")
order_cycles(H, c)
log("Ordering finished.")
return cycles
def register(self, msg):
"""
Enables a user to authenticate and therefore reach higher levels by
assigning a password of his choice to his user object.
"""
if self._private_only(msg):
return False
log('i', 'User tries to register: ' + str(msg.user))
if msg.user.password is not None:
return msg.prefix + _('Sorry! Your nick is already registered.')
elif not msg.params:
return msg.prefix + _('You have to specify a password.')
else:
msg.user.password = msg.params
log(
'i', 'User %s registered with password %s.' %
(msg.user.name, msg.user.password))
if msg.user.name.lower() == configuration.superadmin:
msg.user.level = 30
else:
msg.user.level = 0
msg.user.trusted = True
User.users.sync()
return msg.prefix + _(
'Your nick has been successfully registered!')
def parse_args(arg_list):
"""
I put command line args and their proper values together in a
dictionaryionary and check, if the value is valid.
"""
dictionary = {}
for item in arg_list:
common_pattern = re.compile(r'^(-pn|-s|-po|-pw|-n|-npw|-ho)$')
common_pattern = common_pattern.search(item)
if common_pattern:
try:
value = arg_list[arg_list.index(item)+1]
dictionary[common_pattern.groups()[0]] = value
except (KeyError, IndexError):
log('e', 'Invalid command line argument.')
help_pattern = re.compile(r'^(-h)$').search(item)
if help_pattern:
dictionary['-h'] = True
else:
dictionary['-h'] = False
conf_pattern = re.compile(r'^(-cnf)$').search(item)
if conf_pattern:
try:
value = arg_list[arg_list.index(item)+1]
dictionary[common_pattern.groups()[0]] = value
except (KeyError, IndexError):
log('e', 'Invalid command line argument.')
else:
dictionary['-cnf'] = False
return dictionary
def _remove_ip6_multicast(self, ip6_multicast: Ip6Address) -> None:
"""Remove IPv6 multicast address from the list stack listens on"""
self.ip6_multicast.remove(ip6_multicast)
if __debug__:
log("stack", f"Removed IPv6 multicast {ip6_multicast}")
self._remove_mac_multicast(ip6_multicast.multicast_mac)
def compute_neighbors_MST(cycles, input):
import lib.trigonometry as trig
_output = "{}_neighbor_data".format(input)
neighbor_values = helper.load(_output)
if neighbor_values == None:
log("Computing neighbors with MST...", "DEBUG")
neighbor_values = {}
for i in cycles:
neighbor_values[i] = []
added = [0]
while len(added) != len(cycles):
distances = []
for i in range(len(cycles)):
for j in range(len(cycles)):
if i in added and j not in added:
dist = trig.dist(*cycles[i]["centroid"],
*cycles[j]["centroid"])
distances.append((dist, i, j))
distances = sorted(distances)
dist, i, j = distances.pop(0)
neighbor_values[i].append(j)
neighbor_values[j].append(i)
added.append(j)
helper.save(neighbor_values, _output)
else:
log("Loaded MST data from file {}".format(_output), "DEBUG")
for i in neighbor_values:
cycles[i]["neighbors"] = neighbor_values[i]
def set(self, msg):
"""Sets level of a user to a certain value."""
token = msg.params.split()
if len(token) == 2:
level = int(token[1])
allowed = self.require_level(msg.user, level + 1)
if allowed:
if token[0] in User.users:
old_level = User.users[token[0]].level or 0
User.users[token[0]].level = level
User.users.sync()
log(
'i', '%s changed the level of user %s from %d to %d.' %
(msg.user.name, token[0], old_level, level))
return msg.prefix + \
_('Changed the level of user %s from %d to %d.') % (
token[0], old_level, level)
else:
return msg.prefix + \
_('User %s is not registered.' % token[0])
else:
return msg.prefix + \
_('Unauthorized. Level %d required.' % (level + 1))
else:
return msg.prefix + \
_('You need to specify the username and the level.')
def _phtx_arp(
self,
ether_src: MacAddress,
ether_dst: MacAddress,
arp_oper: int,
arp_sha: MacAddress,
arp_spa: Ip4Address,
arp_tha: MacAddress,
arp_tpa: Ip4Address,
echo_tracker: Optional[Tracker] = None,
) -> None:
"""Handle outbound ARP packets"""
# Check if IPv4 protocol support is enabled, if not then silently drop the packet
if not config.IP4_SUPPORT:
return
arp_packet_tx = ArpAssembler(
oper=arp_oper,
sha=arp_sha,
spa=arp_spa,
tha=arp_tha,
tpa=arp_tpa,
echo_tracker=echo_tracker,
)
if __debug__:
log("arp", f"{arp_packet_tx.tracker} - {arp_packet_tx}")
self._phtx_ether(ether_src=ether_src,
ether_dst=ether_dst,
carried_packet=arp_packet_tx)
def _phtx_udp(
self,
ip_src: IpAddress,
ip_dst: IpAddress,
udp_sport: int,
udp_dport: int,
udp_data: Optional[bytes] = None,
echo_tracker: Optional[Tracker] = None,
) -> TxStatus:
"""Handle outbound UDP packets"""
assert 0 < udp_sport < 65536, f"{udp_sport=}"
assert 0 < udp_dport < 65536, f"{udp_dport=}"
udp_packet_tx = UdpAssembler(sport=udp_sport,
dport=udp_dport,
data=udp_data,
echo_tracker=echo_tracker)
if __debug__:
log("udp", f"{udp_packet_tx.tracker} - {udp_packet_tx}")
if isinstance(ip_src, Ip6Address) and isinstance(ip_dst, Ip6Address):
return self._phtx_ip6(ip6_src=ip_src,
ip6_dst=ip_dst,
carried_packet=udp_packet_tx)
if isinstance(ip_src, Ip4Address) and isinstance(ip_dst, Ip4Address):
return self._phtx_ip4(ip4_src=ip_src,
ip4_dst=ip_dst,
carried_packet=udp_packet_tx)
return TxStatus.DROPED_UDP_UNKNOWN
def set(self, msg):
"""Sets level of a user to a certain value."""
token = msg.params.split()
if len(token) == 2:
level = int(token[1])
allowed = self.require_level(msg.user, level + 1)
if allowed:
if token[0] in User.users:
old_level = User.users[token[0]].level or 0
User.users[token[0]].level = level
User.users.sync()
log('i',
'%s changed the level of user %s from %d to %d.' % (
msg.user.name, token[0], old_level, level))
return msg.prefix + \
_('Changed the level of user %s from %d to %d.') % (
token[0], old_level, level)
else:
return msg.prefix + \
_('User %s is not registered.' % token[0])
else:
return msg.prefix + \
_('Unauthorized. Level %d required.' % (level + 1))
else:
return msg.prefix + \
_('You need to specify the username and the level.')
def __init__(self):
Plugin.__init__(self, 'insult')
self._set_summary(_('Plugin to insult somebody in the channel'))
self._add_command('insult', '<nick>', _('Insults nick.'))
self._add_command('add_insult', '<phrase>', _('Adds phrase to the \
insults file.'))
self._add_command('delete_insult', '<phrase>', _('Deletes phrase \
from the insults file.'))
self.insults = self._load_resource('insults')
if not self.insults:
import urllib2
log('w', 'No insults found in your insults file. Fetching them...')
self.insults['ins'] = []
try:
insults = urllib2.urlopen('http://server.austriangeekforce.' + \
'net/insults.txt')
insult = True
while insult:
insult = insults.readline()[:-1]
if insult:
self._add(insult)
except urllib2.URLError:
log('e', 'Could not fetch insults.')
self._add('You are dumber than someone who knows just one ' + \
'insult!')
raise
def _send_icmp6_multicast_listener_report(self) -> None:
"""Send out ICMPv6 Multicast Listener Report for given list of addresses"""
# Need to use set here to avoid re-using duplicate multicast entries from stack_ip6_multicast list,
# also All Multicast Nodes address is not being advertised as this is not necessary
if icmp6_mlr2_multicast_address_record := {
Icmp6MulticastAddressRecord(
record_type=ICMP6_MART_CHANGE_TO_EXCLUDE,
multicast_address=_)
for _ in self.ip6_multicast
if _ not in {Ip6Address("ff02::1")}
}:
self._phtx_icmp6(
ip6_src=self.ip6_unicast[0]
if self.ip6_unicast else Ip6Address(0),
ip6_dst=Ip6Address("ff02::16"),
ip6_hop=1,
icmp6_type=ICMP6_MLD2_REPORT,
icmp6_mlr2_multicast_address_record=
icmp6_mlr2_multicast_address_record,
)
if __debug__:
log(
"stack",
"Sent out ICMPv6 Multicast Listener Report message for " +
f"{[_.multicast_address for _ in icmp6_mlr2_multicast_address_record]}"
)
def _assign_ip6_host(self, ip6_host: Ip6Host) -> None:
"""Assign IPv6 host unicast address to the list stack listens on"""
self.ip6_host.append(ip6_host)
if __debug__:
log("stack", f"Assigned IPv6 unicast address {ip6_host}")
self._assign_ip6_multicast(ip6_host.address.solicited_node_multicast)
def _remove_ip6_host(self, ip6_host: Ip6Host) -> None:
"""Remove IPv6 ihost unicast address from the list stack listens on"""
self.ip6_host.remove(ip6_host)
if __debug__:
log("stack", f"Removed IPv6 unicast address {ip6_host}")
self._remove_ip6_multicast(ip6_host.address.solicited_node_multicast)
def enqueue(self, packet_tx: EtherAssembler) -> None:
"""Enqueue outbound packet into TX ring"""
self.tx_ring.append(packet_tx)
if __debug__:
log("rx-ring",
f"{packet_tx.tracker}, queue len: {len(self.tx_ring)}")
self.packet_enqueued.release()
def get_request(self):
line = self.fileobj.readline()
#print('line %s' % line)
if not line:
return
logger.log('client', 'recv %s:%s %s' % (self.address[0], self.address[1], line.strip()))
request = json.loads(line)
return request
def _testDeleteNonExisted(conn, role):
logger.log("running DeleteNonExisted")
_delete_data = {"modified_ts": str(role.modified_ts)}
rsp = requests.delete(api_path + "/" + role.name, params=_delete_data)
if not rsp.status_code == 410:
return logger.failed("DeleteNonExisted expected {410, ...}, got code:",
rsp.status_code, "response:", rsp.text)
return True
def _word_exists(self, word):
"""Checks if word exists and returns either True or False."""
try:
self.vault[word]
return True
except KeyError:
log('w', 'No vault entry for %s.' % word)
return False
def quit(self, msg):
level = 30
if self.require_level(msg.user, level):
log('i', 'Shutdown initiated by %s' % msg.user.name)
User.users.close()
reactor.stop()
else:
return _('Unauthorized. Level %s required.' % level)
def __init__(self, name, level=None, trusted=False,):
self.name = name.split("!")[0]
self.hostmask = name
self.password = None
self.trusted = False
self.level = 0
User.users[self.name] = self
log('i', 'Saved user %s into the database.' % self.name)
def quit(self, msg):
level = 30
if self.require_level(msg.user, level):
log('i', 'Shutdown initiated by %s' % msg.user.name)
User.users.close()
reactor.stop()
else:
return _('Unauthorized. Level %s required.' % level)
def main(cfg):
logger.log("requesting /publicKey")
req = requests.get(cfg.api_base + "/publicKey")
if not req.ok:
logger.log("expected {200, OK}, got code:", req.status_code,
"reponse:", req.text)
return len(req.text) > 380 and req.text.startswith("ssh-rsa ")
def _word_exists(self, word):
"""Checks if word exists and returns either True or False."""
try:
self.vault[word]
return True
except KeyError:
log('w', 'No vault entry for %s.' % word)
return False
def _assign_ip6_multicast(self, ip6_multicast: Ip6Address) -> None:
"""Assign IPv6 multicast address to the list stack listens on"""
self.ip6_multicast.append(ip6_multicast)
if __debug__:
log("stack", f"Assigned IPv6 multicast {ip6_multicast}")
self._assign_mac_multicast(ip6_multicast.multicast_mac)
for _ in range(1):
self._send_icmp6_multicast_listener_report()
def start_recording(self):
self.current_state = 'RECORDING'
epoch_time = int(time.time())
self.recording_time = epoch_time
self.recording_filename = 'output/output_' + str(epoch_time) + '.wav'
self.recording_file = self.recorder.open(self.recording_filename, 'wb')
log("Started Recording", self.recording_time)
def call(self, method, *args):
obj = {
'id': 1,
'method': method,
'params': args,
}
s = json.dumps(obj) + '\n'
logger.log('client', 'call %s:%s %s' % (self.address[0], self.address[1], s.strip()))
self.fileobj.write(s)
self.fileobj.flush()
def response(self, request_id, result):
obj = {
'id': request_id,
'result': result,
'error': None,
}
s = json.dumps(obj) + '\n'
logger.log('client', 'resp %s:%s %s' % (self.address[0], self.address[1], s.strip()))
self.fileobj.write(s)
self.fileobj.flush()
def restart(self, msg):
"""Stops and restarts the bot."""
level = 29
if self.require_level(msg.user, level):
msg.bot.msg(msg.reply_to, _('Restarting...'))
log('w', 'Restart requested by %s.' % msg.user.name)
reactor.stop()
os.execl('./bot.py', *sys.argv)
else:
return _('Unauthorized. Level %s required.' % level)
def require_level(self, user, level):
"""
Use this function inside a plugin to determine if the level of the
user who invokes a keyword is sufficient. Returns True if it is
and False otherwise.
"""
if user.level >= level and user.trusted:
log("i", "Permission granted to user " + str(user))
return True
else:
log("i", "Permission denied to user " + str(user))
return False
def Error(ex):
"""ex is an exception"""
print 'Content-type: text/html\n\n'
print '<html><body><h2>Congratulations! You found a bug in Webnote!</h2>'
print '<p>(or perhaps the database is down)</p>'
print ("<p>We'll try to have webnote up and running again as soon as "
"possible</p>")
if SHOWDEBUG:
import cgitb
cgitb.handler()
print '</body></html>'
log(str(ex))
def auth(self, msg):
"""
If a user uses auth with the correct password he can use all
possibilities of the level associated with his account.
"""
if self._private_only(msg):
return False
log('i', 'User attempting to authenticate: ' + str(msg.user))
if msg.params == msg.user.password:
msg.user.trusted = True
return msg.prefix + _("You're authenticated by now.")
else:
return msg.prefix + _("Passwords do NOT match. DO NOT TRY TO FOOL ME!")
def monitor_block():
print '\n\n\n%s scan blocks..' % time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
logger.log('scan_blocks', 'scan start')
try:
sql = 'select * from pool_block where confirmations < 120'
#sql = 'select * from pool_block'
all_blocks = db.all_dict(sql)
logger.log('scan_blocks', 'need scan for %d blocks' % len(all_blocks))
if(len(all_blocks) != 0):
for b in all_blocks:
try:
block_hash = b['hash']
block_id = int(b['id'])
rpc_block = rpc.getblock(block_hash)
confirmations = int(rpc_block['confirmations'])
db.run('update pool_block set confirmations=%d where id = %d' % (confirmations, block_id))
except Exception, e:
logger.log('scan_blocks', 'exception %s' %e)
except Exception, e:
logger.log('scan_blocks','unknown excepiton %s' %e)
def last_seen(name):
try:
user = User.users[name]
delta = SeenPlugin.now() - user.last_action.time
return _("%s was last seen: %s ago, %s" % \
(user.name, time_ago_in_words(delta), user.last_action))
#return user.last_action.time
except KeyError:
return _("Gee... I've never seen " + name)
log('i', "Information about unknown User requested")
raise
except NameError:
log('i', "User has no action defined yet")
raise
def _load_extended(self, section):
extended = Storage()
for option in [opt for opt in self.config.options(section) if
opt.startswith('x-')]:
try:
(plugin, key) = option.split('-', 2)[1:]
except ValueError:
log('w', 'Incorrect entry "%s" in config section "%s"' % (
option, section))
continue
if not hasattr(extended, plugin):
setattr(extended, plugin, Storage())
setattr(getattr(extended, plugin), key, self._get(section, option))
return extended
def worker(outbox, ses):
while True:
data = outbox.get()
try:
response = sendmail(data=data, ses=ses, callback=log)
sent.next()
except:
error.next()
msg = '-'*80
msg += '\n%s\n' % format_exc()
msg += str(data)
msg += '\n'
msg += '-'*80
log(msg)
def reload(self, msg):
"""Reloads all plugins for this connection."""
level = 29
if self.require_level(msg.user, level):
log('i', '%s initiated plugin reload...' % msg.user.name)
msg.bot.msg(msg.reply_to, _('Reloading plugins...'))
plugs = PluginLoader().load_plugins()
handler = PluginHandler(plugs)
del msg.bot.plugins
msg.bot.plugins = Set(handler.plugins.values())
del msg.bot.factory.plugin_handler
msg.bot.factory.plugin_handler = handler
return _('Done.')
else:
return _('Unauthorized. Level %s required.' % level)
def seen(self, msg):
params = msg.params.split()
log('i', "You wanted to see:" + params[0])
if len(params) != 1:
msg.bot.msg(msg.reply_to, _("Usage: seen user"))
else:
try:
if msg.user.name == params[0]:
return _(params[0] + \
_(":Huh? You dont see yourself? WTF!?"))
else:
return last_seen(params[0])
except(KeyError, NameError):
raise
return _("Gee...I've never seen " + params[0])
def mainloop(self):
"""
This is the main loop, which checks for new bugs every minute,
and reports any new ones to the IRC channel.
"""
if not self.warmup:
self.warmup = True
return
for project in self.projects:
# Fetch new bugs
try:
bugs = self.get_latest_bugs(project)
except Exception:
log('e',
'Failed to fetch bugs for %s, skipping' % project)
continue
# If this is the first run for this project
if not self.projects[project][1]:
# Mark all recent bugs as already reported
self.projects[project][1] = [x[0] for x in bugs]
# Filter out already reported bugs
new_bugs = [bug for bug in bugs if bug[0] not in \
self.projects[project][1]]
self.projects[project][1] = [x[0] for x in bugs]
# Report the bugs
for (number, desc, url, package, status, imp) in new_bugs:
if package == 'ubuntu':
# Try to find the component (main/universe) of package.
try:
location = ' (%s)' % self.get_bug_location(url)
except Exception:
location = ' (?)'
else:
location = ''
msg = 'New bug: #%s in %s%s: "%s" [%s, %s] %s' % \
(number, package, location, desc, imp, status, url)
log('i', msg)
for bot, chans in self.projects[project][0].iteritems():
for channel in chans:
bot.msg(channel, str(msg))
def getblocks():
try:
heights = range(263534, 264609)[::-1]
for i in heights:
hash = rpc.getblockhash(i)
block = rpc.getblock(hash)
# print("%d %s %s" % (block['height'],time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(block['time'])),block['hash']))
logger.log(
"block",
"%d\t%s\t%s"
% (block["height"], time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(block["time"])), block["hash"]),
)
except Exception, e:
print(e)
logger.log("error", "%s" % e)
def CreateSave():
ret = Workspace()
size = os.environ.get('CONTENT_LENGTH', 0)
data = sys.stdin.read(int(size)).replace('\0', '')
log(data)
# there should be something here for catching an incomplete send
dom = parseString(data)
wsRoot = dom.getElementsByTagName('workspace').item(0)
ret.name = wsRoot.getAttribute('name')
ret.nextNoteNum = wsRoot.getAttribute('nextNoteNum')
nlNotes = wsRoot.getElementsByTagName('note')
for i in range(nlNotes.length):
ret.notes.append(Note.Note.FromXML(nlNotes.item(i)))
return ret
def karma(self, msg):
"""
If parameters given, returns a summary of first parameter's karma. IF
not you can see some pretty stats."""
if len(msg.msg.split(' ')) > 1:
word = msg.msg.split(' ')[1].lower()
if self._word_exists(word):
pos = self.vault[word][0]
neg = self.vault[word][1]
sum = self.vault[word][2]
if sum > 99:
comment = _('%s is far too good! Practice Evil, my friend.'
% word)
elif 100 > sum > 0:
comment = _('What a nice %s, so many good deeds...') % word
elif sum == 0:
comment = _('The ultimate way to Nirvana.')
elif -50 < sum < 0:
comment = _('Such a bad boy.')
elif -49 < sum:
comment = _('%s seems to be an evil genius in training.' %
word)
return _('Karma statistics for %s: +%i -%i => %i -- %s' %
(word, pos, neg, sum, comment))
else:
return _('%s has no karma recordings yet.' % word)
else:
highest = ['None', 0]
lowest = ['None', 0]
pos = 0
neg = 0
sum = 0
for k, v in self.vault.items():
log('i', '%s#%s' % (str(k), str(v)))
if v[2] > highest[1]:
highest = [k, v[2]]
if v[2] < lowest[1]:
lowest = [k, v[2]]
pos += v[0]
neg += v[1]
sum += v[2]
return _('I keep track of %i people\'s karma. Overall I noticed \
%i positive and %i negative karma points. %s is the most well behaved I \
know. %s seems to have a Bachelor\'s degree in Darkness. The common karma of \
all people I know is %i.' % (len(self.vault), pos, neg, highest[0], lowest[0],
sum))
def _create_connection(self, conn):
# Initialize variables
channels = []
port = 0
# Server and Port
server = self._get(conn, 'server') or None
if not server:
log('e', 'No server defined for connection "%s".' % conn)
return False
if ':' in server:
server, port = server.split(':')
# Channels
if not self.config.has_option(conn, 'channels'):
log('w', 'Connection "%s" has no channel definition.' % conn)
for channel in self._get(conn, 'channels').split(' '):
if not channel.startswith('#'):
log('w', 'Channel "%s" doesn\'t start with a hash (#); \
ignoring.' % channel)
channels.append(channel)
if not len(channels):
log('e', 'No valid channel defined for connection "%s".' % conn)
return False
# Create the connection class
connection = IRCConnection(server)
connection.name = conn
connection.port = int(port) or 6667
connection.ssl = self._get(conn, 'ssl') or False
connection.password = self._get(conn, 'password') or None
connection.host = self._get(conn, 'host') or 'localhost'
connection.nick = self._get(conn, 'nick') or 'p1tr'
connection.realname = self._get(conn, 'realname') or 'P1tr IRC Bot'
connection.nickpw = self._get(conn, 'nickpw') or None
connection.channels = channels
connection.signal_char = (self._get(conn, 'signal') or '*')[0]
# Load X-* values for this connection
connection.extended = self._load_extended(conn)
# Save it
self.servers.append(connection)
log('i', 'Loaded configuration for connection "%s".' % conn)
return connection
def _load_resource(self, title):
"""
Returns a shelve if it can be opened, otherwise None.
Example usage in a plugin: self.data = self._load_resource('info')
This creates data/pluginname_info, where everything you write to
self.data is stored. After adding information to self.data it is
recommended to to self.data.sync() to write changes to the file.
In case you need the resource just for a limited time you can close
it using self._close_resource(self.data). This does the sync() for
you.
"""
try:
res = shelve.open(os.path.join("data", "%s_%s" % (self.name, title)), protocol=0, writeback=True)
return res
except anydbm.error:
log("e", "Unable to open resource file:")
raise
return None
def load_language(lcode=None):
"""
Installs language lcode; if not given the language from the configuration
file will be installed. Useful for language changes at runtime.
Returns a tuple; first item is the new language; second item is a arg_list of
all available languages.
"""
langs = {}
for language in ['ca', 'da', 'de', 'en', 'es', 'fr', 'hi', 'la',
'ru', 'sv', 'tr']:
langs[language] = gettext.translation('p1tr', './locale',
languages=[language])
if lcode:
log('i', 'Lang "%s" loaded.' % lcode)
langs[lcode].install()
else:
conf_lang = configuration.language
log('i', 'Loaded language "%s" (specified in the config file).' % \
conf_lang)
langs[conf_lang].install()
return (lcode or conf_lang, langs.keys())
