async def register(jid, password):
metadata = aioxmpp.make_security_layer(None)
_, stream, features = await aioxmpp.node.connect_xmlstream(jid, metadata)
query = ibr.Query(jid.localpart, password)
await ibr.register(stream, query)
print("Registered")
def __init__(self, bot, jabber_server, logger):
config = jabber_server['jabber_id'].split(':')
jabber_id = aioxmpp.JID.fromstr(config[0])
override_peer = []
if len(config) > 1:
port = config[1]
override_peer = [(jabber_id.domain, port,
aioxmpp.connector.STARTTLSConnector())]
super(JabberRelay, self).__init__(
aioxmpp.JID.fromstr(jabber_server['jabber_id']),
aioxmpp.make_security_layer(jabber_server['password'],
no_verify=True),
override_peer=override_peer,
logger=logger)
self.bot = bot
self.relay_from = jabber_server['relay_from']
self.jabber_server = jabber_server
self.embed_colour = get_embed_colour(jabber_server['logo_url'])
self.languages = [LanguageRange(tag='en'), LanguageRange.WILDCARD]
self.summon(aioxmpp.DiscoServer)
self.summon(aioxmpp.RosterClient)
message_dispatcher = self.summon(
aioxmpp.dispatcher.SimpleMessageDispatcher)
message_dispatcher.register_callback(None, None,
self.message_receieved)
self.presence = aioxmpp.PresenceState(True, aioxmpp.PresenceShow.AWAY)
def __init__(self, xmpp_config, client_logger=None):
super().__init__()
self.__config = xmpp_config
override_peer = []
if xmpp_config.get("host"):
override_peer.append(
(xmpp_config["host"], xmpp_config.get("port", 5222),
aioxmpp.connector.STARTTLSConnector()))
security_args = {}
if xmpp_config.get("public_key_pin"):
security_args["pin_store"] = xmpp_config["public_key_pin"]
security_args[
"pin_type"] = aioxmpp.security_layer.PinType.PUBLIC_KEY
self.client = aioxmpp.Client(
aioxmpp.JID.fromstr(xmpp_config["jid"]),
aioxmpp.make_security_layer(
xmpp_config["password"],
**security_args,
),
override_peer=override_peer,
logger=client_logger,
)
self.__nested_cm = None
self.buddies = self.client.summon(Buddies)
self.buddies.load_buddies(xmpp_config.get("buddies", []))
def start(self, user):
Log.info('开始登陆', user)
self.jid = aioxmpp.JID.fromstr(user['JID'])
self.password = user['PWD']
try:
# no_verify=True大坑！，注意关闭认证；参考：https://docs.zombofant.net/aioxmpp/devel/api/public/security_layer.html
# 可能要自己定义security_layer以达到通信安全
self.client = aioxmpp.PresenceManagedClient(
self.jid,
aioxmpp.make_security_layer(self.password, no_verify=True),
loop=self._loop)
self.client.set_presence(
aioxmpp.PresenceState(available=True,
show=aioxmpp.PresenceShow.FREE_FOR_CHAT),
{aioxmpp.structs.LanguageTag.fromstr('en'): '在线'})
self.client.on_failure.connect(self.on_failure) #启动失败时操作
self.client.on_stream_established.connect(
self.on_login_success) #在链接服务器时操作
self.client.on_stream_suspended.connect(
self.on_internet_disconnect) #服务器链接中断时操作
self.client.on_stream_destroyed.connect(
self.on_internet_disconnect) #服务器链接失败时操作
except ConnectionRefusedError:
self._sign_login.emit(3)
return
except Exception:
return
async def run(self) -> None:
resource_id = (uuid.uuid4().hex).upper()
resource = 'V2:Fortnite:{0.client.platform.value}::{1}'.format(
self, resource_id)
self.xmpp_client = aioxmpp.PresenceManagedClient(
aioxmpp.JID(self.client.user.id, self.client.service_host,
resource),
aioxmpp.make_security_layer(self.client.auth.access_token,
no_verify=True),
override_peer=[(self.client.service_domain,
self.client.service_port,
XMPPOverWebsocketConnector())],
loop=self.client.loop)
self.muc_service = self.xmpp_client.summon(aioxmpp.MUCClient)
self.setup_callbacks()
future = self.client.loop.create_future()
self._task = asyncio.ensure_future(self._run(future),
loop=self.client.loop)
await future
self._ping_task = asyncio.ensure_future(self.loop_ping(),
loop=self.client.loop)
asyncio.ensure_future(self.send_presence_on_start(),
loop=self.client.loop)
self.client.dispatch_event('xmpp_session_establish')
async def run(self):
resource_id = (uuid.uuid4().hex).upper()
self.xmpp_client = aioxmpp.PresenceManagedClient(
aioxmpp.JID(
self.client.user.id,
self.client.service_host,
'V2:Fortnite:{0.client.platform.value}::{1}'.format(self, resource_id)
),
aioxmpp.make_security_layer(
self.client.auth.access_token,
no_verify=True
),
override_peer=[(
self.client.service_domain,
self.client.service_port,
aioxmpp.connector.STARTTLSConnector()
)],
loop=self.client.loop
)
self.muc_service = self.xmpp_client.summon(aioxmpp.MUCClient)
self.setup_callbacks()
future = self.client.loop.create_future()
self._task = asyncio.ensure_future(self._run(future), loop=self.client.loop)
await future
self._ping_task = asyncio.ensure_future(self.loop_ping(), loop=self.client.loop)
def __init__(self, host, loop, access_key, encryption):
"""
:param host: aka serial number
:param access_key:
:param password:
:param host:
:param sasl_mech:
"""
self.serial_number = host
self.loop = loop
self._encryption = encryption
self._request_timeout = 10
self._lock = asyncio.Lock()
self.msg_event = None
identifier = self.serial_number + "@" + self.xmpp_host
self._from = self._rrc_contact_prefix + identifier
self._to = self.jid(self._rrc_gateway_prefix + identifier)
self._jid = self.jid(self._from)
self.xmppclient = aioxmpp.PresenceManagedClient(
self._jid,
aioxmpp.make_security_layer(self._accesskey_prefix + access_key)
)
self.message_dispatcher = self.xmppclient.summon(
aioxmpp.dispatcher.SimpleMessageDispatcher
)
async def main(local_jid, password):
client = aioxmpp.PresenceManagedClient(
local_jid, aioxmpp.make_security_layer(password))
def message_received(msg):
if not msg.body:
# do not reflect anything without a body
return
# we could also use reply = msg.make_reply() instead
reply = aioxmpp.Message(
type_=msg.type_,
to=msg.from_,
)
# make_reply() would not set the body though
reply.body.update(msg.body)
client.enqueue(reply)
message_dispatcher = client.summon(
aioxmpp.dispatcher.SimpleMessageDispatcher)
message_dispatcher.register_callback(
aioxmpp.MessageType.CHAT,
None,
message_received,
)
async with client.connected():
while True:
await asyncio.sleep(1)
async def _executor(my_jid, my_passwd, master_jid):
masters = [aioxmpp.JID.fromstr(i) for i in master_jid.split(',')]
client = aioxmpp.PresenceManagedClient(
aioxmpp.JID.fromstr(my_jid),
aioxmpp.make_security_layer(my_passwd),
)
# auto re-connect every 10s after conn down
client.backoff_factor = 1
client.backoff_cap = timedelta(seconds=10)
G['client'] = client
message_dispatcher = client.summon(
aioxmpp.dispatcher.SimpleMessageDispatcher)
for m in masters:
message_dispatcher.register_callback(
aioxmpp.MessageType.CHAT,
m,
message_received,
)
roster_client = client.summon(aioxmpp.RosterClient)
while True:
try:
async with client.connected():
for m in masters:
roster_client.approve(m)
roster_client.subscribe(m)
logger.info('Connected')
await asyncio.sleep(time.time())
except asyncio.CancelledError:
# asyncio.sleep
# KeyboardInterrupt
raise
except Exception as e:
logger.warning(repr(e))
async def main(local_jid, password):
client = aioxmpp.PresenceManagedClient(
local_jid,
aioxmpp.make_security_layer(password)
)
def message_received(msg):
if msg.type_ != aioxmpp.MessageType.CHAT:
return
if not msg.body:
# do not reflect anything without a body
return
# we could also use reply = msg.make_reply() instead
reply = aioxmpp.Message(
type_=msg.type_,
to=msg.from_,
)
# make_reply() would not set the body though
reply.body.update(msg.body)
client.stream.enqueue_stanza(reply)
client.stream.register_message_callback(
aioxmpp.MessageType.CHAT,
None,
message_received,
)
async with client.connected():
while True:
await asyncio.sleep(1)
def _create_client(self, sender_id, api_key, loop=None) -> aioxmpp.Client:
xmpp_client = aioxmpp.Client(
local_jid=aioxmpp.JID.fromstr('*****@*****.**' % sender_id),
security_layer=aioxmpp.make_security_layer(api_key),
override_peer=[
(self.FCM_HOST, self.FCM_PORT,
aioxmpp.connector.XMPPOverTLSConnector())
],
loop=loop
)
xmpp_client.on_stream_established.connect(
lambda: self._wait_connection.set_result(True)
)
xmpp_client.on_stream_destroyed.connect(
self._on_stream_destroyed
)
xmpp_client.on_failure.connect(
lambda exc: self._wait_connection.set_exception(exc)
)
xmpp_client.stream.register_message_callback(
type_=aioxmpp.MessageType.NORMAL,
from_=None,
cb=self.on_response
)
return xmpp_client
async def run(self):
jid = aioxmpp.JID.fromstr(self.wizard().field("jid"))
self.client = aioxmpp.Client(
jid,
aioxmpp.make_security_layer(self.wizard().field("password"), ),
logger=self.logger,
)
self.client.summon(aioxmpp.DiscoClient)
self.user_logger.info("Trying to connect as %s", jid)
async with self.client.connected():
self.user_logger.info("Successfully connected!")
self.ui.progress.setRange(0, len(self.optional_steps) * 100)
self.ui.progress.setValue(0)
for i, step in enumerate(self.optional_steps):
await step(i)
self.ui.progress.setValue((i + 1) * 100)
self.user_logger.info("Settings checked, done!")
self._complete = True
self.completeChanged.emit()
async def async_register(self): # pragma: no cover
""" Register the agent in the XMPP server from a coroutine. """
metadata = aioxmpp.make_security_layer(
None, no_verify=not self.verify_security)
query = ibr.Query(self.jid.localpart, self.password)
_, stream, features = await aioxmpp.node.connect_xmlstream(
self.jid, metadata)
await ibr.register(stream, query)
def configure(self, section):
super().configure(section)
self.__host = section.get("host")
self._domain = aioxmpp.JID.fromstr(section.get("domain", self.__host))
self.__port = section.getint("port")
self.__security_layer = aioxmpp.make_security_layer(
None, anonymous="", **configure_tls_config(section))
self._quirks = configure_quirks(section)
def _load_accounts(self, cfg):
result = []
for username, password in ast.literal_eval(cfg):
result.append((aioxmpp.JID(localpart=username,
domain=self._domain.domain,
resource=None),
aioxmpp.make_security_layer(password,
**self.__tls_config)))
return result
async def cancel(jid, password):
client = aioxmpp.PresenceManagedClient(
jid,
aioxmpp.make_security_layer(password)
)
async with client.connected() as stream:
service = ibr.RegistrationService(stream)
await service.cancel_registration()
def register(self): # pragma: no cover
""" Register the agent in the XMPP server. """
metadata = aioxmpp.make_security_layer(
None, no_verify=not self.verify_security)
query = ibr.Query(self.jid.localpart, self.password)
_, stream, features = self.loop.run_until_complete(
aioxmpp.node.connect_xmlstream(self.jid, metadata))
self.loop.run_until_complete(ibr.register(stream, query))
def __init__(self, jid: str, password: str, *, config):
self.config = config
self.client = aioxmpp.PresenceManagedClient(
aioxmpp.JID.fromstr(jid),
aioxmpp.make_security_layer(password, no_verify=True),
)
self.muc = self.client.summon(aioxmpp.MUCClient)
self.on_message_handlers = []
async def _async_start(self, auto_register=True):
"""
Starts the agent from a coroutine. This fires some actions:
* if auto_register: register the agent in the server
* runs the event loop
* connects the agent to the server
* runs the registered behaviours
Args:
auto_register (bool, optional): register the agent in the server (Default value = True)
"""
await self._hook_plugin_before_connection()
if auto_register:
await self._async_register()
self.client = aioxmpp.PresenceManagedClient(
self.jid,
aioxmpp.make_security_layer(self.password,
no_verify=not self.verify_security),
loop=self.loop,
logger=logging.getLogger(self.jid.localpart),
)
# obtain an instance of the service
self.message_dispatcher = self.client.summon(SimpleMessageDispatcher)
# Presence service
self.presence = PresenceManager(self)
await self._async_connect()
# register a message callback here
self.message_dispatcher.register_callback(
aioxmpp.MessageType.CHAT,
None,
self._message_received,
)
await self._hook_plugin_after_connection()
# pubsub initialization
try:
self._node = str(self.jid.bare())
await self.pubsub.create(self.pubsub_server, f"{self._node}")
except XMPPCancelError as e:
logger.info(f"Node {self._node} already registered")
except XMPPAuthError as e:
logger.error(
f"Artifact {self._node} is not allowed to publish properties.")
raise e
await self.setup()
self._alive.set()
asyncio.run_coroutine_threadsafe(self.run(), loop=self.loop)
async def jabber(self, jid, password):
await self.bot.wait_until_ready()
print('Waiting for pings from Jabber.')
client = aioxmpp.PresenceManagedClient(
jid, aioxmpp.make_security_layer(password, no_verify=True))
icon_url = self.icon_url
bot = self.bot
def message_recieved(msg):
if not msg.body:
# We dont want to do anything with an empty message.
return
if msg.from_.bare() == aioxmpp.JID.fromstr(self.target).bare():
# Take the message and pass it to an async task so we can post it.
return asyncio.Task(post(msg))
return
# noinspection PyUnresolvedReferences
message_dispatcher = client.summon(
aioxmpp.dispatcher.SimpleMessageDispatcher)
message_dispatcher.register_callback(aioxmpp.MessageType.CHAT, None,
message_recieved)
async def post(msg):
body = msg.body[list(msg.body.keys())[0]]
bot.logger.info('Ping Received.')
urls = re.findall(
'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+',
body)
if len(urls) == 0:
urlstr = ''
else:
urlstr = "**PING CONTAINS THE FOLLOWING URLS** \n> " + ' \n> '.join(
urls) + "\n\n"
time = datetime.datetime.utcnow()
embed = discord.Embed(
description=f'```\n{body}```\n '
f'{urlstr}'
f'***THIS IS PING HAS BEEN AUTOMATICALLY FORWARDED FROM JABBER***',
color=discord.Color.red(),
timestamp=time)
embed.set_author(name=f'{self.target}', icon_url=f'{icon_url}')
embed.set_thumbnail(url=f'{icon_url}')
embed.set_footer(icon_url=bot.user.avatar_url_as(format='png'),
text=f"Service provided by {bot.user.name}")
return await self.channel.send(embed=embed)
# noinspection PyUnresolvedReferences
@aioxmpp.service.iq_handler()
async def iq_handle():
pass
async with client.connected():
while 'JabberPings' in self.bot.cogs:
await asyncio.sleep(1)
def __init__(self, jid: str, password: str, nick_name=None):
self._jid = jid
self._nick_name = nick_name
if self._nick_name is None:
self._nick_name = jid.split('@')[0] if '@' in jid else 'tcgl_bot'
self._client = aioxmpp.PresenceManagedClient(
aioxmpp.JID.fromstr(jid),
aioxmpp.make_security_layer(password, no_verify=True))
self._muc = self._client.summon(aioxmpp.muc.MUCClient)
self._stream = None
async def get_info(jid, password):
client = aioxmpp.PresenceManagedClient(
jid,
aioxmpp.make_security_layer(password)
)
async with client.connected() as stream:
service = ibr.RegistrationService(stream)
reply = await service.get_client_info()
print("Username: " + reply.username)
def __init__(self, jid, password, recipient):
self.g_jid = aioxmpp.JID.fromstr(jid)
self.g_security_layer = aioxmpp.make_security_layer(password)._replace(
ssl_context_factory=self.my_ssl_factory, )
self.to_jid = aioxmpp.JID.fromstr(recipient)
if os.name == 'nt':
asyncio.set_event_loop_policy(
asyncio.WindowsSelectorEventLoopPolicy())
async def amain(loop, args, cfg):
try:
statefile = pathlib.Path(cfg["muchopping"]["statefile"])
except KeyError:
engine = muchopper.common.model.get_generic_engine(
cfg["muchopping"]["db_uri"])
else:
engine = muchopper.common.model.get_sqlite_engine(statefile)
limits = cfg["muchopping"].get("limits", {})
state = muchopper.bot.state.State(
engine,
pathlib.Path(cfg["muchopping"]["logfile"]),
int(limits.get("max_name_length", 1024)),
int(limits.get("max_description_length", 1024)),
int(limits.get("max_subject_length", 1024)),
int(limits.get("max_language_length", 126)),
)
components = list(
map(muchopper.bot.daemon.Component,
cfg["muchopping"].get("components", ["watcher", "scanner"])))
daemon = muchopper.bot.daemon.MUCHopper(
loop,
aioxmpp.JID.fromstr(cfg["xmpp"]["jid"]),
aioxmpp.make_security_layer(cfg["xmpp"]["password"], ),
cfg["muchopping"]["nickname"],
state,
list(
map(aioxmpp.JID.fromstr,
cfg["muchopping"].get("privileged_entities", []))),
components,
mirror_config=cfg["muchopping"].get("mirror", {}),
spokesman_config=cfg["muchopping"].get("spokesman", {}),
avatar_whitelist=frozenset(
map(aioxmpp.JID.fromstr,
cfg["muchopping"].get("avatar_whitelist", []))),
address_blocklist=frozenset(
map(aioxmpp.JID.fromstr,
cfg["muchopping"].get("address_blocklist", [])), ),
prometheus_config=cfg.get("prometheus"),
)
for addr in cfg["muchopping"].get("seed", []):
state.require_domain(
addr,
seen=False,
)
try:
await daemon.run()
finally:
pass
async def amain() -> int:
config: Config = environ.to_config(Config)
logging.basicConfig(level={
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
}.get(config.lib_log_level, logging.DEBUG), )
logging.getLogger("authbot").setLevel({
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
}.get(config.log_level, logging.DEBUG))
client = aioxmpp.PresenceManagedClient(
config.address,
aioxmpp.make_security_layer(config.password, ),
)
client.summon(aioxmpp.MUCClient)
client.summon(aioxmpp.DiscoClient)
stop_event = asyncio.Event()
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGINT, stop_event.set)
loop.add_signal_handler(signal.SIGTERM, stop_event.set)
stop_future = asyncio.create_task(stop_event.wait())
async with client.connected() as stream:
logger.info("connected as %s", stream.local_jid)
bot_task = asyncio.create_task(
bot.run_in_room(
client,
config.room_address,
config.room_nickname,
))
done, pending = await asyncio.wait(
[bot_task, stop_future],
return_when=asyncio.FIRST_COMPLETED,
)
for fut in pending:
fut.cancel()
for fut in done:
fut.result()
for fut in pending:
try:
await fut
except asyncio.CancelledError:
pass
async def change_password(jid, old_password, new_password):
client = aioxmpp.PresenceManagedClient(
jid,
aioxmpp.make_security_layer(old_password)
)
async with client.connected() as stream:
service = ibr.RegistrationService(stream)
await service.change_pass(new_password)
print("Password changed")
def configure(self, section):
super().configure(section)
self.__host = section.get("host")
self._domain = aioxmpp.JID.fromstr(section.get("domain", self.__host))
self.__port = section.getint("port")
self.__security_layer = aioxmpp.make_security_layer(
"foobar2342", # password is irrelevant, but must be given.
**configure_tls_config(section))
self._quirks = configure_quirks(section)
self.__username_rng = random.Random()
self.__username_rng.seed(_rng.getrandbits(256))
def client(client_username, password):
jid = aioxmpp.JID.fromstr(client_username)
client = aioxmpp.PresenceManagedClient(
jid,
aioxmpp.make_security_layer(
password,
no_verify=True
),
)
return client
async def main(local_jid, password):
client = aioxmpp.PresenceManagedClient(
local_jid, aioxmpp.make_security_layer(password))
client.stream.register_iq_request_coro(
"get",
Query,
handler,
)
async with client.connected():
await asyncio.sleep(30)
async def _send_message(from_jid, from_passwd, to_jid, message):
client = aioxmpp.PresenceManagedClient(
aioxmpp.JID.fromstr(from_jid),
aioxmpp.make_security_layer(from_passwd),
)
msg = aioxmpp.Message(
to=aioxmpp.JID.fromstr(to_jid),
type_=aioxmpp.MessageType.CHAT,
)
msg.body[None] = message
async with client.connected():
await client.send(msg)
async def _async_start(self, auto_register=True):
"""
Starts the agent from a coroutine. This fires some actions:
* if auto_register: register the agent in the server
* runs the event loop
* connects the agent to the server
* runs the registered behaviours
Args:
auto_register (bool, optional): register the agent in the server (Default value = True)
"""
await self._hook_plugin_before_connection()
if auto_register:
await self._async_register()
self.client = aioxmpp.PresenceManagedClient(
self.jid,
aioxmpp.make_security_layer(self.password,
no_verify=not self.verify_security),
loop=self.loop,
logger=logging.getLogger(self.jid.localpart),
)
# obtain an instance of the service
self.message_dispatcher = self.client.summon(SimpleMessageDispatcher)
# Presence service
self.presence = PresenceManager(self)
await self._async_connect()
# register a message callback here
self.message_dispatcher.register_callback(
aioxmpp.MessageType.CHAT,
None,
self._message_received,
)
await self._hook_plugin_after_connection()
await self.setup()
self._alive.set()
for behaviour in self.behaviours:
if not behaviour.is_running:
behaviour.set_agent(self)
if issubclass(type(behaviour), FSMBehaviour):
for _, state in behaviour.get_states().items():
state.set_agent(self)
behaviour.start()
async def main(local_jid, password):
client = aioxmpp.PresenceManagedClient(
local_jid,
aioxmpp.make_security_layer(password)
)
client.stream.register_iq_request_coro(
"get",
Query,
handler,
)
async with client.connected():
await asyncio.sleep(30)
def configure(self):
self.args = self.argparse.parse_args()
logging.basicConfig(
level={
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
}.get(self.args.verbosity, logging.DEBUG)
)
self.config = configparser.ConfigParser()
if self.args.config is not None:
with self.args.config:
self.config.read_file(self.args.config)
self.g_jid = self.args.local_jid
if self.g_jid is None:
try:
self.g_jid = aioxmpp.JID.fromstr(
self.config.get("global", "local_jid"),
)
except (configparser.NoSectionError,
configparser.NoOptionError):
self.g_jid = aioxmpp.JID.fromstr(
input("Account JID> ")
)
if self.config.has_option("global", "pin_store"):
with open(self.config.get("global", "pin_store")) as f:
pin_store = json.load(f)
pin_type = aioxmpp.security_layer.PinType(
self.config.getint("global", "pin_type", fallback=0)
)
else:
pin_store = None
pin_type = None
if self.args.ask_password:
password = getpass.getpass()
else:
password = self.config.get("global", "password")
self.g_security_layer = aioxmpp.make_security_layer(
password,
pin_store=pin_store,
pin_type=pin_type,
)
def configure(self, section):
super().configure(section)
self.__host = section.get("host")
self.__domain = aioxmpp.JID.fromstr(section.get(
"domain",
self.__host
))
self.__port = section.getint("port")
self.__security_layer = aioxmpp.make_security_layer(
None,
anonymous="",
**configure_tls_config(
section
)
)
self.__blockmap = configure_blockmap(section)
self._quirks = configure_quirks(section)
async def _async_start(self, auto_register=True):
"""
Starts the agent from a coroutine. This fires some actions:
* if auto_register: register the agent in the server
* runs the event loop
* connects the agent to the server
* runs the registered behaviours
Args:
auto_register (bool, optional): register the agent in the server (Default value = True)
"""
if auto_register:
await self._async_register()
self.client = aioxmpp.PresenceManagedClient(self.jid,
aioxmpp.make_security_layer(self.password,
no_verify=not self.verify_security),
loop=self.loop,
logger=logging.getLogger(self.jid.localpart))
# obtain an instance of the service
self.message_dispatcher = self.client.summon(SimpleMessageDispatcher)
# Presence service
self.presence = PresenceManager(self)
await self._async_connect()
# register a message callback here
self.message_dispatcher.register_callback(
aioxmpp.MessageType.CHAT,
None,
self._message_received,
)
await self.setup()
self._alive.set()
for behaviour in self.behaviours:
if not behaviour.is_running:
behaviour.start()
async def main(local_jid, password):
client = aioxmpp.PresenceManagedClient(
local_jid,
aioxmpp.make_security_layer(password)
)
peer_jid = local_jid.bare().replace(localpart=None)
async with client.connected() as stream:
iq = aioxmpp.IQ(
type_="get",
payload=Query(),
to=peer_jid,
)
print("sending query to {}".format(peer_jid))
reply = await stream.send_iq_and_wait_for_reply(iq)
print("got response! logging off...")
print(" name: {!r}".format(reply.name))
print(" version: {!r}".format(reply.version))
print(" os: {!r}".format(reply.os))
async def main(local, password, peer,
strip_newlines, add_newlines):
loop = asyncio.get_event_loop()
swrite = await stdout_writer()
sread = asyncio.StreamReader()
tread, pread = await loop.connect_read_pipe(
lambda: asyncio.StreamReaderProtocol(sread),
sys.stdin,
)
client = aioxmpp.PresenceManagedClient(
local,
aioxmpp.make_security_layer(
password,
)
)
sigint = asyncio.Event()
loop.add_signal_handler(signal.SIGINT, sigint.set)
loop.add_signal_handler(signal.SIGTERM, sigint.set)
def recv(message):
body = message.body.lookup(
[aioxmpp.structs.LanguageRange.fromstr("*")]
)
if add_newlines:
body += "\n"
swrite.write(body.encode("utf-8"))
client.stream.register_message_callback(
"chat",
peer,
recv
)
sigint_future = asyncio.ensure_future(sigint.wait())
read_future = asyncio.ensure_future(sread.readline())
try:
async with client.connected() as stream:
while True:
done, pending = await asyncio.wait(
[
sigint_future,
read_future,
],
return_when=asyncio.FIRST_COMPLETED,
)
if sigint_future in done:
break
if read_future in done:
line = read_future.result().decode()
if not line:
break
if strip_newlines:
line = line.rstrip()
msg = aioxmpp.Message(
type_="chat",
to=peer,
)
msg.body[None] = line
await stream.send_and_wait_for_sent(msg)
read_future = asyncio.ensure_future(
sread.readline()
)
finally:
sigint_future.cancel()
read_future.cancel()
async def xmpp_client():
try:
with open(os.path.join(os.getenv("HOME"), ".xc.conf"), "r") as config_file:
config = json.load(config_file)
if "jid" not in config:
raise Exception("No JID")
except Exception as e:
print("Error reading configuration file.\n" + str(e) + "Please create ~/.xc.conf with content like:\n{\"jid\": \"[email protected]\"}")
sys.exit(1)
async def get_secret(jid, attempt):
if attempt > 2:
return None
try:
return await prompt_async("Secret (will not be stored): ", is_password=True)
except:
return None
async def tls_handshake_callback(verifier):
print("Warning: blindly accepting TLS certificate from %s" % verifier.transport.get_extra_info("server_hostname"))
return True
pin_store = PublicKeyPinStore()
pin_store.import_from_json(config.get("pkps", {}))
my_jid = aioxmpp.JID.fromstr(config["jid"])
security = aioxmpp.make_security_layer(get_secret, pin_store=pin_store, pin_type=PinType.PUBLIC_KEY, post_handshake_deferred_failure=tls_handshake_callback)
client = aioxmpp.PresenceManagedClient(my_jid, security)
presence = client.summon(aioxmpp.presence.Service)
roster = client.summon(aioxmpp.roster.Service)
class RosterItemAndCommandCompleter(Completer):
def get_completions(self, document, complete_event):
text = document.text
if not text or " " in text or ":" in text:
return
if text[0] == "/":
part = text[1:]
for command in ("roster", "name", "add", "del", "help", "quit"):
if command.startswith(part):
yield Completion(command + " ", start_position=-len(part), display=command)
elif roster is not None:
for item in roster.items.values():
if item.name.startswith(text):
yield Completion(item.name + ": ", start_position=-len(text), display=item.name)
completer = RosterItemAndCommandCompleter()
history = InMemoryHistory()
next_recipient = None
def get_prompt_tokens(_):
return ((Token.Prompt, "%s> " % (next_recipient or "")),)
cli_app = create_prompt_application(get_prompt_tokens=get_prompt_tokens,
completer=completer,
reserve_space_for_menu=0,
history=history,
get_title=lambda: "xc")
cli_loop = create_asyncio_eventloop()
cli = CommandLineInterface(application=cli_app, eventloop=cli_loop)
above_prompt = cli.stdout_proxy()
def name_for_jid(jid):
try:
return roster.items[jid].name
except:
return str(jid)
def peer_available(jid, presence):
above_prompt.write("%s is now online\n" % name_for_jid(jid.bare()))
presence.on_available.connect(peer_available)
def peer_unavailable(jid, presence):
above_prompt.write("%s is now offline\n" % name_for_jid(jid.bare()))
presence.on_unavailable.connect(peer_unavailable)
def message_received(msg):
content = " ".join(msg.body.values())
if content:
above_prompt.write("%s: %s\n" % (name_for_jid(msg.from_.bare()), content))
client.stream.register_message_callback("chat", None, message_received)
try:
async with client.connected() as stream:
while True:
try:
document = await cli.run_async()
except (KeyboardInterrupt, EOFError):
break
line = document.text
if line.startswith("/"):
try:
command, *args = line[1:].split(" ")
if command == "roster":
rows = [(item.name, str(jid), item.subscription) for jid, item in roster.items.items() if jid != my_jid]
widths = [max(len(row[i] or "") for row in rows) for i in range(len(rows[0] or ""))]
for row in rows:
above_prompt.write(" ".join((cell or "").ljust(widths[i]) for i, cell in enumerate(row)) + "\n")
elif command == "name":
try:
jid = args[0]
name = args[1]
except IndexError:
above_prompt.write("usage: /name JID NAME\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.set_entry(jid, name=name)
elif command == "add":
try:
jid = args[0]
except IndexError:
above_prompt.write("usage: /add JID\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.set_entry(jid)
roster.subscribe(jid)
roster.approve(jid)
elif command == "del":
try:
jid = args[0]
except IndexError:
above_prompt.write("usage: /del JID\n")
else:
jid = aioxmpp.JID.fromstr(jid)
await roster.remove_entry(jid)
elif command == "quit":
break
elif command == "help":
above_prompt.write("NAME: MESSAGE send MESSAGE to NAME\n"
"MESSAGE send MESSAGE to the last correspondent\n"
"/roster print the roster\n"
"/add JID add JID to the roster\n"
"/del JID remove JID from the roster\n"
"/name JID NAME set the name of JID to NAME\n"
"/quit disconnect and then quit (also ctrl-d, ctrl-c)\n"
"/help this help\n")
else:
above_prompt.write("unrecognised command\n")
except Exception as e:
above_prompt.write("exception handling command: %s\n" % e)
else:
try:
try:
recipient, message = line.split(": ", 1)
except ValueError:
if next_recipient is not None:
recipient = next_recipient
message = line
else:
above_prompt.write("recipient: message\n")
continue
jid_for_name = lambda r: next((jid for jid, item in roster.items.items() if item.name == r), None)
jid = jid_for_name(recipient)
if jid is None:
if next_recipient is not None and recipient != next_recipient:
recipient = next_recipient
jid = jid_for_name(recipient)
message = line
if jid is None:
above_prompt.write("unknown recipient: %s\n" % recipient)
continue
msg = aioxmpp.Message(to=jid, type_="chat")
msg.body[None] = message
await stream.send_and_wait_for_sent(msg)
next_recipient = recipient
except Exception as e:
above_prompt.write("exception sending message: %s\n" % e)
print("Disconnecting…")
client.stop()
except Exception as e:
print("Failed to connect: %s" % e)
async def get_fields(jid):
metadata = aioxmpp.make_security_layer(None)
_, stream, features = await aioxmpp.node.connect_xmlstream(jid, metadata)
reply = await ibr.get_registration_fields(stream)
print(ibr.get_used_fields(reply))
async def _async_register(self): # pragma: no cover
""" Register the agent in the XMPP server from a coroutine. """
metadata = aioxmpp.make_security_layer(None, no_verify=not self.verify_security)
query = ibr.Query(self.jid.localpart, self.password)
_, stream, features = await aioxmpp.node.connect_xmlstream(self.jid, metadata, loop=self.loop)
await ibr.register(stream, query)
