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 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()
