def main(): """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description = 'XMPP echo bot', parents = [XMPPSettings.get_arg_parser()]) parser.add_argument('jid', metavar = 'JID', help = 'The bot JID') parser.add_argument('tunnel_conf', metavar = 'TUNNEL_CONF') parser.add_argument('--debug', action = 'store_const', dest = 'log_level', const = logging.DEBUG, default = logging.INFO, help = 'Print debug messages') parser.add_argument('--quiet', const = logging.ERROR, action = 'store_const', dest = 'log_level', help = 'Print only error messages') parser.add_argument('--trace', action = 'store_true', help = 'Print XML data sent and received') args = parser.parse_args() settings = XMPPSettings({ "software_name": "TCP Tunneler Bot" }) settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.jid = args.jid.decode("utf-8") logging.basicConfig(level = args.log_level) if args.trace: print "enabling trace" handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.propagate = False im_tcp_tunneler.setup_tunnels(args.tunnel_conf) global bot bot = Bot(JID(args.jid), settings) try: bot.run() except KeyboardInterrupt: bot.disconnect()
def test_auth_fail(self): handler = EventRecorder() settings = XMPPSettings({ u"username": u"user", u"password": u"bad", }) self.stream = StreamBase(u"jabber:client", None, [StreamSASLHandler(settings), handler], settings) self.start_transport([handler]) self.stream.initiate(self.transport) self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.server.write(AUTH_FEATURES) xml = self.wait(expect=re.compile(br".*(<auth.*</auth>)")) self.assertIsNotNone(xml) element = ElementTree.XML(xml) self.assertEqual(element.tag, "{urn:ietf:params:xml:ns:xmpp-sasl}auth") mech = element.get("mechanism") self.assertEqual(mech, "PLAIN") data = binascii.a2b_base64(element.text.encode("utf-8")) self.assertNotEqual(data, b"\000user\000secret") self.server.write( b"""<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'> <not-authorized/></failure>""") with self.assertRaises(SASLAuthenticationFailed): self.wait() self.assertFalse(self.stream.authenticated) self.server.disconnect() self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, GotFeaturesEvent, DisconnectedEvent ])
def test_required_missing(self): """Test TLS required in settings, and missing on the server.""" self.start_server() settings = XMPPSettings({ u"starttls": True, u"tls_require": True, u"tls_cacert_file": os.path.join(DATA_DIR, "ca.pem"), }) handler = EventRecorder() handlers = [StreamTLSHandler(settings), handler] self.stream = StreamBase(u"jabber:client", None, handlers, settings) self.start_transport(handlers) self.stream.initiate(self.transport, to="server.example.org") self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.server.write(EMPTY_FEATURES) self.server.write(b"</stream:stream>") with self.assertRaises(TLSNegotiationFailed): self.wait() self.server.disconnect() self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, GotFeaturesEvent, DisconnectedEvent ])
def test_bind(self): handler = AuthorizedEventHandler() handlers = [ResourceBindingHandler(), handler] processor = StanzaProcessor() processor.setup_stanza_handlers(handlers, "post-auth") self.stream = StreamBase(u"jabber:client", processor, handlers, XMPPSettings({"resource": "Provided"})) processor.uplink = self.stream self.stream.me = JID("[email protected]") self.start_transport([handler]) self.stream.initiate(self.transport) self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.wait_short(1) self.server.write(BIND_FEATURES) req_id = self.wait(1, expect=re.compile( br".*<iq[^>]*id=[\"']([^\"']*)[\"'].*" br"<resource>Provided</resource>")) self.assertIsNotNone(req_id) req_id = req_id.decode("utf-8") self.server.write( BIND_PROVIDED_RESPONSE.format(req_id).encode("utf-8")) self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, GotFeaturesEvent, BindingResourceEvent, AuthorizedEvent, DisconnectedEvent ])
def __init__(self): my_jid = JID(USER + '/Bot') self.my_jid = my_jid settings = XMPPSettings({ "software_name": "qxbot", "software_version": __version__, "software_os": "Linux", "tls_verify_peer": False, "starttls": True, "ipv6": False, "poll_interval": 10, }) settings["password"] = PASSWORD version_provider = VersionProvider(settings) event_queue = settings["event_queue"] self.webqq = WebQQ(QQ, event_queue) self.connected = False #self.mainloop = TornadoMainLoop(settings) self.mainloop = EpollMainLoop(settings) self.client = Client(my_jid, [self, version_provider], settings, self.mainloop) self.logger = get_logger() self.msg_dispatch = MessageDispatch(self, self.webqq, BRIDGES) self.xmpp_msg_queue = Queue.Queue()
def main(): """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description="XMPP echo bot", parents=[XMPPSettings.get_arg_parser()]) parser.add_argument("jid", metavar="JID", help="The bot JID") parser.add_argument( "--debug", action="store_const", dest="log_level", const=logging.DEBUG, default=logging.INFO, help="Print debug messages", ) parser.add_argument( "--quiet", const=logging.ERROR, action="store_const", dest="log_level", help="Print only error messages" ) parser.add_argument("--trace", action="store_true", help="Print XML data sent and received") args = parser.parse_args() settings = XMPPSettings({"software_name": "Echo Bot"}) settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.jid = args.jid.decode("utf-8") logging.basicConfig(level=args.log_level) if args.trace: print "enabling trace" handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.propagate = False bot = EchoBot(JID(args.jid), settings) try: bot.run() except KeyboardInterrupt: bot.disconnect()
def main(): """Parse the command-line arguments and run the tool.""" parser = argparse.ArgumentParser(description = 'XMPP version checker', parents = [XMPPSettings.get_arg_parser()]) parser.add_argument('source', metavar = 'SOURCE', help = 'Source JID') parser.add_argument('target', metavar = 'TARGET', nargs = '?', help = 'Target JID (default: domain of SOURCE)') parser.add_argument('--debug', action = 'store_const', dest = 'log_level', const = logging.DEBUG, default = logging.INFO, help = 'Print debug messages') parser.add_argument('--quiet', const = logging.ERROR, action = 'store_const', dest = 'log_level', help = 'Print only error messages') args = parser.parse_args() settings = XMPPSettings() settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.source = args.source.decode("utf-8") source = JID(args.source) if args.target: if sys.version_info.major < 3: args.target = args.target.decode("utf-8") target = JID(args.target) else: target = JID(source.domain) logging.basicConfig(level = args.log_level) checker = VersionChecker(source, target, settings) try: checker.run() except KeyboardInterrupt: checker.disconnect()
def default_string(setting): if setting.default_d: return setting.default_d if setting.default is not None: default = setting.default elif setting.factory: default = setting.factory(XMPPSettings()) else: return u"``None``" return u"``{0!r}``".format(default)
def __init__(self): self.droid = android.Android() settings = XMPPSettings({"software_name": "Say Chat"}) settings["jid"] = self.droid.dialogGetInput("Google Talk Username").result settings["password"] = self.droid.dialogGetInput("Google Talk Password").result settings["server"] = "talk.google.com" settings["starttls"] = True self.client = Client( JID(settings["jid"]), [self, VersionProvider(settings)], settings)
def test_resolve_address_prefer_ipv4(self): settings = XMPPSettings({"prefer_ipv6": False}) resolver = self.make_resolver(settings) self.loop.add_handler(resolver) resolver.resolve_address("lo-host.test.pyxmpp.jajcus.net", self.address_callback) self.wait(1) if is_ipv6_available(): self.assertEqual(self.address_result, [(AF_INET, "127.0.0.1"), (AF_INET6, "::1")]) else: self.assertEqual(self.address_result, [(AF_INET, "127.0.0.1")])
def init(self, jid, password): """ 初始化 :param jid: jid :param password: 密码 :return: """ self.JID = jid if isinstance(jid, JID) else JID(jid) self.jid_bare_str = self.JID.bare().as_string() self.password = password self.settings = XMPPSettings({u"password": password, u"starttls": True, u"tls_verify_peer": False})
def push(self): settings = XMPPSettings({ u"password": self.from_pwd, u"starttls": True, u"tls_verify_peer": False, u'server': self.xmpp_server, u'c2s_port': int(self.xmpp_port), }) xml = self.msg client = Client(JID(self.from_jid), [MyHandler(xml.encode('utf-8'))], settings) client.connect() client.run()
def __init__(self, jid, handlers, settings=None, main_loop=None): self._ml_handlers = [] self._base_handlers = [] self.jid = jid self.handlers = handlers self.settings = settings if settings else XMPPSettings() StanzaProcessor.__init__(self, self.settings[u"default_stanza_timeout"]) self.roster_client = self.roster_client_factory() self.main_loop = main_loop self.stream = None
def __init__(self, your_jid, your_pass, target_jid, messages): self.target_jid = target_jid self.messages = messages self.connected = False self.established = False settings = XMPPSettings({ u"password": your_pass, u"starttls": True, u"tls_verify_peer": False, }) self.client = Client(JID(your_jid), [self], settings) self.client.connect()
def main(): """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description='XMPP echo bot', parents=[XMPPSettings.get_arg_parser()]) parser.add_argument('jid', metavar='JID', help='The bot JID') parser.add_argument('tunnel_conf', metavar='TUNNEL_CONF') parser.add_argument('--debug', action='store_const', dest='log_level', const=logging.DEBUG, default=logging.INFO, help='Print debug messages') parser.add_argument('--quiet', const=logging.ERROR, action='store_const', dest='log_level', help='Print only error messages') parser.add_argument('--trace', action='store_true', help='Print XML data sent and received') args = parser.parse_args() settings = XMPPSettings({"software_name": "TCP Tunneler Bot"}) settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.jid = args.jid.decode("utf-8") logging.basicConfig(level=args.log_level) if args.trace: print "enabling trace" handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.propagate = False im_tcp_tunneler.setup_tunnels(args.tunnel_conf) global bot bot = Bot(JID(args.jid), settings) try: bot.run() except KeyboardInterrupt: bot.disconnect()
def __init__(self): RosterMixin.__init__(self) self.presence = defaultdict(dict) signals.raise_excepted.connect(self.on_received_raise_exception) db_signals.db_init_finished.connect(self.on_db_init_finished) self.settings = XMPPSettings({ "tls_verify_peer": False, "starttls": True, "poll_interval": 10, }) self.main_loop = QThreadPool(self.settings) self.client = QClient(None, [ self, ], self.settings, main_loop=self.main_loop) self.is_authored = False
def test_resolve_address_ipv6_only(self): settings = XMPPSettings({"ipv4": False}) resolver = self.make_resolver(settings) self.loop.add_handler(resolver) resolver.resolve_address("lo-host.test.pyxmpp.jajcus.net", self.address_callback) self.wait(1) self.assertEqual(self.address_result, [(AF_INET6, "::1")]) self.address_result = NO_RESULT resolver.resolve_address("lo4-host.test.pyxmpp.jajcus.net", self.address_callback) self.wait(1) self.assertEqual(self.address_result, []) self.address_result = NO_RESULT resolver.resolve_address("lo6-host.test.pyxmpp.jajcus.net", self.address_callback) self.wait(1) self.assertEqual(self.address_result, [(AF_INET6, "::1")])
def init(self, jid, password, c2s_port=5222): """ 初始化 :param jid: jid :param password: 密码 :return: """ self.JID = jid if isinstance(jid, JID) else JID(jid) self.jid_bare_str = self.JID.bare().as_string() self.password = password self.settings = XMPPSettings({ u"password": password, u"starttls": True, u"tls_verify_peer": False, u"c2s_port": c2s_port }) if c2s_port != 5222: logger.warn("XMPPClient::init c2s_port is :%s!!!!!" % c2s_port)
def test_enabled_required(self): """Test TLS enabled in settings, and required on the server.""" self.start_server() settings = XMPPSettings({ u"starttls": True, u"tls_cacert_file": os.path.join(DATA_DIR, "ca.pem"), }) handler = EventRecorder() handlers = [StreamTLSHandler(settings), handler] self.stream = StreamBase(u"jabber:client", None, handlers, settings) self.start_transport(handlers) self.stream.initiate(self.transport, to="server.example.org") self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.server.write(TLS_REQUIRED_FEATURES) xml = self.wait(expect=re.compile(br".*(<starttls.*/>)")) self.assertIsNotNone(xml) element = XML(xml) self.assertEqual(element.tag, "{urn:ietf:params:xml:ns:xmpp-tls}starttls") self.server.write(PROCEED) self.server.starttls( self.server.sock, keyfile=os.path.join(DATA_DIR, "server-key.pem"), certfile=os.path.join(DATA_DIR, "server.pem"), server_side=True, ca_certs=os.path.join(DATA_DIR, "ca.pem"), ) stream_start = self.wait(expect=re.compile(br"(<stream:stream[^>]*>)")) self.assertIsNotNone(stream_start) self.assertTrue(self.stream.tls_established) self.stream.disconnect() self.server.write(C2S_SERVER_STREAM_HEAD) self.server.write(EMPTY_FEATURES) self.server.write(b"</stream:stream>") self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, GotFeaturesEvent, TLSConnectingEvent, TLSConnectedEvent, StreamRestartedEvent, GotFeaturesEvent, DisconnectedEvent ])
def test_custom(self): settings = XMPPSettings({ "software_name": "NAME", "software_version": "VERSION", "software_os": "OS", }) provider = VersionProvider(settings) processor = Processor([provider]) stanza = Iq(ElementTree.XML(IQ1)) processor.uplink_receive(stanza) self.assertEqual(len(processor.stanzas_sent), 1) response = processor.stanzas_sent[0] self.assertIsInstance(response, Iq) self.assertEqual(response.stanza_type, "result") payload = response.get_payload(VersionPayload) self.assertIsInstance(payload, VersionPayload) self.assertEqual(payload.name, "NAME") self.assertEqual(payload.version, "VERSION") self.assertEqual(payload.os_name, "OS")
def test_auth(self): handler = EventRecorder() self.start_transport([handler]) settings = XMPPSettings({ u"user_passwords": { u"user": u"secret", }, u"sasl_mechanisms": ["SCRAM-SHA-1", "PLAIN"], }) self.stream = StreamBase(u"jabber:client", None, [StreamSASLHandler(settings), handler], settings) self.stream.receive(self.transport, self.addr[0]) self.client.write(C2S_CLIENT_STREAM_HEAD) xml = self.wait( expect=re.compile(br".*<stream:features>(.*)</stream:features>")) self.assertIsNotNone(xml) element = ElementTree.XML(xml) self.assertEqual(element.tag, "{urn:ietf:params:xml:ns:xmpp-sasl}mechanisms") self.assertEqual(element[0].tag, "{urn:ietf:params:xml:ns:xmpp-sasl}mechanism") self.assertEqual(element[0].text, "SCRAM-SHA-1") self.assertEqual(element[1].tag, "{urn:ietf:params:xml:ns:xmpp-sasl}mechanism") self.assertEqual(element[1].text, "PLAIN") response = base64.standard_b64encode(b"\000user\000secret") self.client.write( PLAIN_AUTH.format(response.decode("utf-8")).encode("utf-8")) xml = self.wait(expect=re.compile(br".*(<success.*>)")) self.assertIsNotNone(xml) self.client.write(C2S_CLIENT_STREAM_HEAD) xml = self.wait(expect=re.compile(br".*(<stream:stream.*>)")) self.assertIsNotNone(xml) self.assertTrue(self.stream.peer_authenticated) self.client.write(b"</stream:stream>") self.client.disconnect() self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ StreamConnectedEvent, AuthenticatedEvent, StreamRestartedEvent, DisconnectedEvent ])
def main(): """Parse the command-line arguments and run the tool.""" parser = argparse.ArgumentParser(description='XMPP version checker', parents=[XMPPSettings.get_arg_parser()]) parser.add_argument('source', metavar='SOURCE', help='Source JID') parser.add_argument('target', metavar='TARGET', nargs='?', help='Target JID (default: domain of SOURCE)') parser.add_argument('--debug', action='store_const', dest='log_level', const=logging.DEBUG, default=logging.INFO, help='Print debug messages') parser.add_argument('--quiet', const=logging.ERROR, action='store_const', dest='log_level', help='Print only error messages') args = parser.parse_args() settings = XMPPSettings() settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.source = args.source.decode("utf-8") source = JID(args.source) if args.target: if sys.version_info.major < 3: args.target = args.target.decode("utf-8") target = JID(args.target) else: target = JID(source.domain) logging.basicConfig(level=args.log_level) checker = VersionChecker(source, target, settings) try: checker.run() except KeyboardInterrupt: checker.disconnect()
def test_auth(self): handler = EventRecorder() settings = XMPPSettings({ u"username": u"user", u"password": u"secret", }) self.stream = StreamBase(u"jabber:client", None, [StreamSASLHandler(settings), handler], settings) self.start_transport([handler]) self.stream.initiate(self.transport) self.connect_transport() self.server.write(C2S_SERVER_STREAM_HEAD) self.server.write(AUTH_FEATURES) xml = self.wait(expect=re.compile(br".*(<auth.*</auth>)")) self.assertIsNotNone(xml) element = ElementTree.XML(xml) self.assertEqual(element.tag, "{urn:ietf:params:xml:ns:xmpp-sasl}auth") mech = element.get("mechanism") self.assertEqual(mech, "PLAIN") data = binascii.a2b_base64(element.text.encode("utf-8")) self.assertEqual(data, b"\000user\000secret") self.server.rdata = b"" self.server.write( b"<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>") stream_start = self.wait(expect=re.compile(br"(<stream:stream[^>]*>)")) self.assertIsNotNone(stream_start) self.assertTrue(self.stream.authenticated) self.server.write(C2S_SERVER_STREAM_HEAD) self.server.write(BIND_FEATURES) self.server.write(b"</stream:stream>") self.server.disconnect() self.wait() event_classes = [e.__class__ for e in handler.events_received] self.assertEqual(event_classes, [ ConnectingEvent, ConnectedEvent, StreamConnectedEvent, GotFeaturesEvent, AuthenticatedEvent, StreamRestartedEvent, GotFeaturesEvent, DisconnectedEvent ])
def main(): gp = models.connection.Group.one() if gp and gp.status: st = gp.status else: st = None settings = dict( # deliver here even if the admin logs in initial_presence=Presence(priority=30, status=st), poll_interval=3, ) botsettings = { 'presence': settings['initial_presence'], } settings.update(config.settings) settings = XMPPSettings(settings) if config.trace: logging.info('enabling trace') for logger in ('pyxmpp2.IN', 'pyxmpp2.OUT'): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) for logger in ( 'pyxmpp2.mainloop.base', 'pyxmpp2.expdict', 'pyxmpp2.mainloop.poll', 'pyxmpp2.mainloop.events', 'pyxmpp2.transport', 'pyxmpp2.mainloop.events', ): logger = logging.getLogger(logger) logger.setLevel(max((logging.INFO, config.logging_level))) if config.logging_level > logging.DEBUG: restart_if_failed(runit, 3, args=(settings, botsettings)) else: runit(settings, botsettings)
def send(self, req_id, stanzas): self.req_id = req_id self.stanzas = stanzas logging.debug(u"XmppClient start sending messages for request #%s", self.req_id) try: settings = XMPPSettings({ u"password": self.password, u"starttls": self.use_tls, u"tls_verify_peer": self.tls_verify_peer, u"server": self.host, u"port": self.port, u"default_stanza_timeout": self.timeout, }) self.client = Client(self.from_jid, [self], settings) self.client.connect() self.client.run(timeout=self.timeout) except Exception, e: logging.error( "Error sending XMPP notification for request #%s: %s", req_id, e, exc_info=1)
def __init__(self): my_jid = JID(USER + '/Bot') self.my_jid = my_jid settings = XMPPSettings({ "software_name": "Clubot", "software_version": __version__, "software_os": "Linux", "tls_verify_peer": False, "starttls": True, "ipv6": False, "poll_interval": 10, }) settings["password"] = PASSWORD version_provider = VersionProvider(settings) self.connected = False mainloop = TornadoMainLoop(settings) self.client = Client(my_jid, [self, version_provider], settings, mainloop) #self.client = Client(my_jid, [self, version_provider], settings) self.logger = get_logger() self.trytimes = 0 self.sended = [] Logics.empty_status()
# (4) XMPPのメッセージを受信したときの処理を記述 @message_stanza_handler() def handle_message(self, stanza): # (4-1)メッセージのタイトルを設定 if stanza.subject: subject = "Re: " + stanza.subject else: subject = None if stanza.body: # (4-2)メッセージの本文の作成 body = 'You said "' + stanza.body + '".' # (5) メッセージオブジェクトの作成 msg = Message(stanza_type=stanza.stanza_type, from_jid=stanza.to_jid, to_jid=stanza.from_jid, subject=subject, body=body, thread=stanza.thread) return msg # (6) XMPPの初期化とイベントループ jid = sys.argv[1] password = sys.argv[2] settings = XMPPSettings({"password": password}) client = Client(JID(jid), [EchoBotHandler()], settings) client.connect() client.run()
def main(): """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description = 'XMPP echo bot', parents = [XMPPSettings.get_arg_parser()]) parser.add_argument('--debug', action = 'store_const', dest = 'log_level', const = logging.DEBUG, default = logging.INFO, help = 'Print debug messages') parser.add_argument('--quiet', const = logging.ERROR, action = 'store_const', dest = 'log_level', help = 'Print only error messages') parser.add_argument('--trace', action = 'store_true', help = 'Print XML data sent and received') parser.add_argument('--roster-cache', help = 'Store roster in this file') parser.add_argument('jid', metavar = 'JID', help = 'The bot JID') subparsers = parser.add_subparsers(help = 'Action', dest = "action") show_p = subparsers.add_parser('show', help = 'Show roster and exit') show_p.add_argument('--presence', action = 'store_true', help = 'Wait 5 s for contact presence information' ' and display it with the roster') mon_p = subparsers.add_parser('monitor', help = 'Show roster and subsequent changes') mon_p.add_argument('--presence', action = 'store_true', help = 'Show contact presence changes too') add_p = subparsers.add_parser('add', help = 'Add an item to the roster') add_p.add_argument('--subscribe', action = 'store_true', dest = 'subscribe', help = 'Request a presence subscription too') add_p.add_argument('--approve', action = 'store_true', dest = 'approve', help = 'Pre-approve subscription from the contact' ' (requires server support)') add_p.add_argument('contact', metavar = 'CONTACT', help = 'The JID to add') add_p.add_argument('name', metavar = 'NAME', nargs = '?', help = 'Contact name') add_p.add_argument('groups', metavar = 'GROUP', nargs = '*', help = 'Group names') rm_p = subparsers.add_parser('remove', help = 'Remove an item from the roster') rm_p.add_argument('contact', metavar = 'CONTACT', help = 'The JID to remove') upd_p = subparsers.add_parser('update', help = 'Update an item in the roster') upd_p.add_argument('contact', metavar = 'CONTACT', help = 'The JID to update') upd_p.add_argument('name', metavar = 'NAME', nargs = '?', help = 'Contact name') upd_p.add_argument('groups', metavar = 'GROUP', nargs = '*', help = 'Group names') args = parser.parse_args() settings = XMPPSettings() settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.jid = args.jid.decode("utf-8") if getattr(args, "contact", None): args.contact = args.contact.decode("utf-8") if getattr(args, "name", None): args.name = args.name.decode("utf-8") if getattr(args, "groups", None): args.groups = [g.decode("utf-8") for g in args.groups] logging.basicConfig(level = args.log_level) if args.trace: print "enabling trace" handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.propagate = False if args.action == "monitor" or args.action == "show" and args.presence: # According to RFC6121 it could be None for 'monitor' (no need to send # initial presence to request roster), but Google seems to require that # to send roster pushes settings["initial_presence"] = Presence(priority = -1) else: settings["initial_presence"] = None tool = RosterTool(JID(args.jid), args, settings) try: tool.run() except KeyboardInterrupt: tool.disconnect()
def main(): import os from getpass import getpass import argparse from nicelogger import enable_pretty_logging from cli import repl """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description='XMPP dev bot', parents=[XMPPSettings.get_arg_parser()]) parser.add_argument('jid', metavar='JID', help='The bot JID') parser.add_argument('--debug', action='store_const', dest='log_level', const=logging.DEBUG, default=logging.INFO, help='Print debug messages') parser.add_argument('--quiet', const=logging.ERROR, action='store_const', dest='log_level', help='Print only error messages') parser.add_argument('--trace', action='store_true', help='Print XML data sent and received') args = parser.parse_args() settings = XMPPSettings({"software_name": "pyxmpp2 Bot"}) settings.load_arguments(args) if args.jid.endswith('@gmail.com'): settings['starttls'] = True settings['tls_verify_peer'] = False if settings.get("password") is None: password = getpass("{0!r} password: "******"password"] = password if args.trace: logging.info('enabling trace') for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) enable_pretty_logging(level=args.log_level) bot = AutoAcceptBot(JID(args.jid), settings) class Q: def __call__(self): sys.exit() __repr__ = __call__ q = Q() self = bot try: bot.connect() while True: try: bot.run() except KeyboardInterrupt: v = vars() v.update(globals()) repl(v, os.path.expanduser('~/.xmppbot_history')) except SystemExit: bot.disconnect() except: bot.disconnect() import traceback traceback.print_exc()
) self.send(message) def send(self, stanza): self.client.stream.send(stanza) def do_unsubscribe(self, jid, type='unsubscribe'): jid = JID(jid) presence = Presence(to_jid=jid, stanza_type=type) self.send(presence) def delete_from_roster(self, jid): self.client.roster.delItem(jid) your_jid = r'*****@*****.**' logging.basicConfig(level=logging.INFO) settings = XMPPSettings({ "software_name": "Talkbot", u"starttls": True, u"password": r'1', u"tls_verify_peer": False, }) bot = Talkbot(your_jid, settings) try: DB_oper.db_init() bot.run_bot() except KeyboardInterrupt: bot.stop_bot()
#!/usr/bin/python from pyxmpp2.simple import send_message from pyxmpp2.settings import XMPPSettings argparser = XMPPSettings.get_arg_parser(add_help=True) settings = XMPPSettings() settings.load_arguments(argparser.parse_args()) from pyxmpp2.simple import send_message # send_message("*****@*****.**", "bob's password", "*****@*****.**", "Hello Alice") send_message(r'xyz\[email protected]', 'pwd', '*****@*****.**', 'fuckoff')
def main(): """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description="XMPP echo bot", parents=[XMPPSettings.get_arg_parser()]) parser.add_argument( "--debug", action="store_const", dest="log_level", const=logging.DEBUG, default=logging.INFO, help="Print debug messages", ) parser.add_argument( "--quiet", const=logging.ERROR, action="store_const", dest="log_level", help="Print only error messages" ) parser.add_argument("--trace", action="store_true", help="Print XML data sent and received") parser.add_argument("--roster-cache", help="Store roster in this file") parser.add_argument("jid", metavar="JID", help="The bot JID") subparsers = parser.add_subparsers(help="Action", dest="action") show_p = subparsers.add_parser("show", help="Show roster and exit") show_p.add_argument( "--presence", action="store_true", help="Wait 5 s for contact presence information" " and display it with the roster", ) mon_p = subparsers.add_parser("monitor", help="Show roster and subsequent changes") mon_p.add_argument("--presence", action="store_true", help="Show contact presence changes too") add_p = subparsers.add_parser("add", help="Add an item to the roster") add_p.add_argument("--subscribe", action="store_true", dest="subscribe", help="Request a presence subscription too") add_p.add_argument( "--approve", action="store_true", dest="approve", help="Pre-approve subscription from the contact" " (requires server support)", ) add_p.add_argument("contact", metavar="CONTACT", help="The JID to add") add_p.add_argument("name", metavar="NAME", nargs="?", help="Contact name") add_p.add_argument("groups", metavar="GROUP", nargs="*", help="Group names") rm_p = subparsers.add_parser("remove", help="Remove an item from the roster") rm_p.add_argument("contact", metavar="CONTACT", help="The JID to remove") upd_p = subparsers.add_parser("update", help="Update an item in the roster") upd_p.add_argument("contact", metavar="CONTACT", help="The JID to update") upd_p.add_argument("name", metavar="NAME", nargs="?", help="Contact name") upd_p.add_argument("groups", metavar="GROUP", nargs="*", help="Group names") args = parser.parse_args() settings = XMPPSettings() settings.load_arguments(args) if settings.get("password") is None: password = getpass("{0!r} password: "******"utf-8") settings["password"] = password if sys.version_info.major < 3: args.jid = args.jid.decode("utf-8") if getattr(args, "contact", None): args.contact = args.contact.decode("utf-8") if getattr(args, "name", None): args.name = args.name.decode("utf-8") if getattr(args, "groups", None): args.groups = [g.decode("utf-8") for g in args.groups] logging.basicConfig(level=args.log_level) if args.trace: print "enabling trace" handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.propagate = False if args.action == "monitor" or args.action == "show" and args.presence: # According to RFC6121 it could be None for 'monitor' (no need to send # initial presence to request roster), but Google seems to require that # to send roster pushes settings["initial_presence"] = Presence(priority=-1) else: settings["initial_presence"] = None tool = RosterTool(JID(args.jid), args, settings) try: tool.run() except KeyboardInterrupt: tool.disconnect()
def handle_disconnected(self, event): return QUIT @event_handler() def handle_all(self, event): logging.info(u"-- {0}".format(event)) logging.basicConfig(level=logging.INFO) # change to 'DEBUG' to see more your_jid = raw_input("Your jid: ") your_password = getpass("Your password: "******"Target jid: ") message = raw_input("Message: ") if sys.version_info.major < 3: your_jid = your_jid.decode("utf-8") your_password = your_password.decode("utf-8") target_jid = target_jid.decode("utf-8") message = message.decode("utf-8") handler = MyHandler(JID(target_jid), message) settings = XMPPSettings({ u"password": your_password, u"starttls": True, u"tls_verify_peer": False, }) client = Client(JID(your_jid), [handler], settings) client.connect() client.run()
#!/usr/bin/python from pyxmpp2.simple import send_message from pyxmpp2.settings import XMPPSettings argparser = XMPPSettings.get_arg_parser(add_help = True) settings = XMPPSettings() settings.load_arguments(argparser.parse_args()) from pyxmpp2.simple import send_message # send_message("*****@*****.**", "bob's password", "*****@*****.**", "Hello Alice") send_message(r'xyz\[email protected]', 'pwd', '*****@*****.**', 'fuckoff')
def main(): import os from getpass import getpass import argparse from nicelogger import enable_pretty_logging from cli import repl """Parse the command-line arguments and run the bot.""" parser = argparse.ArgumentParser(description = 'XMPP dev bot', parents = [XMPPSettings.get_arg_parser()]) parser.add_argument('jid', metavar = 'JID', help = 'The bot JID') parser.add_argument('--debug', action = 'store_const', dest = 'log_level', const = logging.DEBUG, default = logging.INFO, help = 'Print debug messages') parser.add_argument('--quiet', const = logging.ERROR, action = 'store_const', dest = 'log_level', help = 'Print only error messages') parser.add_argument('--trace', action = 'store_true', help = 'Print XML data sent and received') args = parser.parse_args() settings = XMPPSettings({ "software_name": "pyxmpp2 Bot" }) settings.load_arguments(args) if args.jid.endswith('@gmail.com'): settings['starttls'] = True settings['tls_verify_peer'] = False if settings.get("password") is None: password = getpass("{0!r} password: "******"password"] = password if args.trace: logging.info('enabling trace') for logger in ("pyxmpp2.IN", "pyxmpp2.OUT"): logger = logging.getLogger(logger) logger.setLevel(logging.DEBUG) enable_pretty_logging(level=args.log_level) bot = AutoAcceptBot(JID(args.jid), settings) class Q: def __call__(self): sys.exit() __repr__ = __call__ q = Q() self = bot try: bot.connect() while True: try: bot.run() except KeyboardInterrupt: v = vars() v.update(globals()) repl(v, os.path.expanduser('~/.xmppbot_history')) except SystemExit: bot.disconnect() except: bot.disconnect() import traceback traceback.print_exc()