def keys_set(self):
if ModuleTools.INSTALLED_AXOLOTL():
from yowsup.layers.axolotl import YowAxolotlLayer
if self.assertConnected():
self.broadcastEvent(YowLayerEvent(YowAxolotlLayer.EVENT_PREKEYS_SET))
else:
logger.error("Axolotl is not installed")
def __init__(self): env.CURRENT_ENV = env.S40YowsupEnv() layers = (YowsupAppLayer, YowParallelLayer((YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIbProtocolLayer, YowIqProtocolLayer, YowNotificationsProtocolLayer, YowContactsIqProtocolLayer, YowChatstateProtocolLayer, YowCallsProtocolLayer, YowMediaProtocolLayer, YowPrivacyProtocolLayer, YowProfilesProtocolLayer, YowGroupsProtocolLayer, YowPresenceProtocolLayer)), YowAxolotlLayer, YowCoderLayer, YowCryptLayer, YowStanzaRegulator, YowNetworkLayer ) self.stack = YowStack(layers) self.stack.broadcastEvent( YowLayerEvent(YowsupAppLayer.EVENT_START, caller = self) )
def handle_close(self, reason = "Connection Closed"):
self.connected = False
logger.debug("Disconnected, reason: %s" % reason)
ev = YowLayerEvent(self.__class__.EVENT_STATE_DISCONNECTED, reason = reason, detached=True)
self.emitEvent(ev)
self.getStack().broadcastEvent(ev)
self.close()
def handle_connect(self):
self.connected = True
if self.proxyHandler != None:
logger.debug("HttpProxy handle connect")
self.proxyHandler.send(self)
else:
self.emitEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECTED))
def onEvent(self, layerEvent):
if layerEvent.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECTED:
self.output("Disconnected: %s" % layerEvent.getArg("reason"))
self.connected = False
connectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)
self.getStack().broadcastEvent(connectEvent)
if self.assertConnected():
if layerEvent.getName() == self.__class__.EVENT_SEND_MESSAGE:
msg = layerEvent.getArg("msg")
number = layerEvent.getArg("number")
self.output("Send Message to %s : %s" % (number, msg))
jid = self.aliasToJid(number)
outgoingMessageProtocolEntity = TextMessageProtocolEntity(
msg, to=jid)
self.toLower(outgoingMessageProtocolEntity)
if layerEvent.getName() == self.__class__.EVENT_SEND_IMAGE:
path = layerEvent.getArg("path")
number = layerEvent.getArg("number")
jid = self.aliasToJid(number)
entity = RequestUploadIqProtocolEntity(
RequestUploadIqProtocolEntity.MEDIA_TYPE_IMAGE,
filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(
jid, path, successEntity, originalEntity)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(
jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def login(self, username, password):
"""Login to yowsup
Should result in onAuthSuccess or onAuthFailure to be called.
Args:
- username: (str) username in the form of 1239482382 (country code
and cellphone number)
- password: (str) base64 encoded password
"""
self.stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
(username, password))
self.stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0])
self.stack.setProp(YowCoderLayer.PROP_DOMAIN,
YowConstants.DOMAIN)
self.stack.setProp(YowCoderLayer.PROP_RESOURCE,
env.CURRENT_ENV.getResource())
# self.stack.setProp(YowIqProtocolLayer.PROP_PING_INTERVAL, 5)
try:
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
except TypeError as e: # Occurs when password is not correctly formated
self.onAuthFailure('password not base64 encoded')
def handleFailure(self, node):
nodeEntity = FailureProtocolEntity.fromProtocolTreeNode(node)
self.toUpper(nodeEntity)
self.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT,
reason="Authentication Failure"))
raise AuthError(nodeEntity.getReason())
def run(message_queue, config):
keypair = KeyPair.from_bytes(base64.b64decode(config["password"]))
credentials = (config["phone"], keypair)
layers = (
WhatsappLayer(message_queue=message_queue),
YowParallelLayer([
YowAuthenticationProtocolLayer, YowMessagesProtocolLayer,
YowReceiptProtocolLayer, YowAckProtocolLayer, YowIqProtocolLayer,
YowGroupsProtocolLayer
]),
AxolotlControlLayer,
YowParallelLayer((AxolotlSendLayer, AxolotlReceivelayer)),
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS,
credentials) # setting credentials
stack.setProp(YowNetworkLayer.PROP_ENDPOINT,
YowConstants.ENDPOINTS[0]) # whatsapp server address
# stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
# stack.setProp(YowCoderLayer.PROP_RESOURCE, YowsupEnv.getCurrent().getResource()) #info about us as WhatsApp client
stack.broadcastEvent(YowLayerEvent(
YowNetworkLayer.EVENT_STATE_CONNECT)) # sending the connect signal
stack.loop()
def send_message(destination, message):
''' destination is <phone number> without '+'
and with country code of type string,
message is string
e.g send_message('11133434343','hello')
'''
messages = [(destination, message)]
layers = (EchoLayer,
(YowAuthenticationProtocolLayer,
YowMessagesProtocolLayer,
YowReceiptProtocolLayer,
YowAckProtocolLayer,
YowPresenceProtocolLayer)
) + YOWSUP_CORE_LAYERS
stack = YowStack(layers)
stack.setProp(EchoLayer.PROP_MESSAGES, messages)
stack.setProp(YowAuthenticationProtocolLayer.PROP_PASSIVE, True)
# Setting credentials
stack.setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, CREDENTIALS)
# WhatsApp server address
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE, env.CURRENT_ENV.getResource())
# Sending connecting signal
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
# Program main loop
stack.loop()
except AuthError as e:
print('Authentication error %s' % e.message)
sys.exit(1)
def persistKeys(self, registrationId, identityKeyPair, preKeys,
signedPreKey, fresh):
total = len(preKeys)
curr = 0
prevPercentage = 0
if fresh:
self.store.storeLocalData(registrationId, identityKeyPair)
self.store.storeSignedPreKey(signedPreKey.getId(), signedPreKey)
for preKey in preKeys:
self.store.storePreKey(preKey.getId(), preKey)
curr += 1
currPercentage = int((curr * 100) / total)
if currPercentage == prevPercentage:
continue
prevPercentage = currPercentage
#logger.debug("%s" % currPercentage + "%")
sys.stdout.write("Storing prekeys %d%% \r" % (currPercentage))
sys.stdout.flush()
if fresh:
self.state = self.__class__._STATE_GENKEYS
self.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT))
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def onEvent(self, layerEvent):
alive_thread = Thread(target=self.aliver, args=(layerEvent, ))
logging.info("WhatsApp-Plugin : EVENT " + layerEvent.getName())
if layerEvent.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECTED:
logging.info("WhatsApp-Plugin : Disconnected reason: %s" %
layerEvent.getArg("reason"))
os._exit(os.EX_OK)
if layerEvent.getArg("reason") == 'Connection Closed':
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
elif layerEvent.getArg("reason") == 'Ping Timeout':
time.sleep(2)
logging.info(
"WhatsApp-Plugin : Issueing EVENT_STATE_DISCONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT))
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
elif layerEvent.getArg("reason") == 'Authentication Failure':
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
else:
time.sleep(2)
logging.info("WhatsApp-Plugin : Issueing EVENT_STATE_CONNECT")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
os._exit(os.EX_OK)
elif layerEvent.getName() == YowNetworkLayer.EVENT_STATE_CONNECTED:
logging.info("WhatsApp-Plugin : Connected")
alive_thread.start()
def start(self):
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
print("Starting")
try:
self.stack.loop(timeout = 0.5, discrete = 0.5)
print("bye")
except AuthError as e:
print("Authentication Error: %s" % e.message)
def start(self):
"""Starts the connection with Whatsapp servers,"""
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("Starting....")
self.stack.loop()
except AuthError as e:
print("Authentication Error: %s" % e.message)
def start(self):
self._stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self._stack.loop()
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
def onEvent(self, layerEvent):
# In case of constant disconnects. https://github.com/tgalal/yowsup/iss
print 'event:', layerEvent.getName()
if layerEvent.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECTED:
print "Disconnected- %s" % layerEvent.getArg("reason")
self.getStack().broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
print 'reconnected'
def sendIq(self, iq, onSuccess=None, onError=None):
self.stack.broadcastEvent(
YowLayerEvent(
YowsupAppLayer.SEND_IQ,
iq=iq,
success=onSuccess,
failure=onError,
))
def onDisconnected(self):
if self.state != self.__class__.STATE_DISCONNECTED:
self.state = self.__class__.STATE_DISCONNECTED
self.connected = False
logger.debug("Disconnected")
self.emitEvent(
YowLayerEvent(self.__class__.EVENT_STATE_DISCONNECTED,
reason=self._disconnect_reason or ""))
def handle_close(self, reason="Connection Closed"):
logger.debug("Disconnected, reason: %s" % reason)
self.emitEvent(
YowLayerEvent(self.__class__.EVENT_STATE_DISCONNECTED,
reason=reason,
detached=True))
self.close()
return False
def waitPong(self, id):
self._pingQueueLock.acquire()
self._pingQueue[id] = None
pingQueueSize = len(self._pingQueue)
self._pingQueueLock.release()
self.__logger.debug("ping queue size: %d" % pingQueueSize)
if pingQueueSize >= 2:
self.getStack().broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_DISCONNECT, reason = "Ping Timeout"))
def sendTextMessage(self, address, message):
self.output('Trying to send Message to %s:%s' % (address, message))
self.stack.broadcastEvent(
YowLayerEvent(name=SendReciveLayer.EVENT_SEND_MESSAGE,
msg=message,
number=address))
return True
def on_connected(self, event):
self.broadcastEvent(
YowLayerEvent(
self.EVENT_AUTH,
credentials=self.getProp(self.PROP_CREDENTIALS),
passive=self.getProp(self.PROP_PASSIVE, False)
)
)
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop(timeout=120)
except AuthError as e:
print("Authentication Error: %s" % e.message)
except Exception as e:
print("Another Error: %s" % str(e))
def handleSuccess(self, node):
if (node.data != None):
StorageTools.writeNonce(self.credentials[0], node.data)
successEvent = YowLayerEvent(self.__class__.EVENT_AUTHED,
passive=self.getProp(
self.__class__.PROP_PASSIVE))
self.broadcastEvent(successEvent)
nodeEntity = SuccessProtocolEntity.fromProtocolTreeNode(node)
self.toUpper(nodeEntity)
def on_handshake_finished(self, e=None):
# type: (Exception) -> None
if e is not None:
self.emitEvent(YowLayerEvent(self.EVENT_HANDSHAKE_FAILED, reason=e))
data=WriteEncoder(TokenDictionary()).protocolTreeNodeToBytes(
ProtocolTreeNode("failure", {"reason": str(e)})
)
self.toUpper(data)
logger.error("An error occurred during handshake, try login again.")
def login(self, username, b64password):
if self.connected:
return self.output("Already connected, disconnect first")
self.getStack().setProp(YowAuthenticationProtocolLayer.PROP_CREDENTIALS, (username, b64password))
connectEvent = YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT)
self.broadcastEvent(connectEvent)
return True #prompt will wait until notified
def start(self):
self.stack.broadcastEvent(
YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
logging.info("Whatsapp IS STARTING : ReceiveStack")
self.stack.loop(timeout=1, count=100)
logging.info("Stopping ... ")
except AuthError as e:
logging.info("Authentication Error: %s" % e.message)
def workerwhatsapp():
stackBuilder = YowStackBuilder()
stack = stackBuilder.pushDefaultLayers(True).push(laye).build()
stack.setCredentials(CREDENTIALS)
stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
stack.setProp(YowNetworkLayer.PROP_ENDPOINT, YowConstants.ENDPOINTS[0])
stack.setProp(YowCoderLayer.PROP_DOMAIN, YowConstants.DOMAIN)
stack.setProp(YowCoderLayer.PROP_RESOURCE,
YowsupEnv.getCurrent().getResource())
stack.loop(timeout=0.5, discrete=0.5)
def start(self):
while True:
try:
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
self.stack.loop()
except AuthError as e:
break
except Exception as e:
print(e)
time.sleep(20)
def start(self):
print("[Whatsapp] Mac started\n")
print("[Whatsapp] Current State:", YowNetworkLayer.EVENT_STATE_CONNECT)
self.stack.broadcastEvent(YowLayerEvent(YowNetworkLayer.EVENT_STATE_CONNECT))
try:
self.stack.loop(timeout=0.5, discrete=0.5)
except KeyboardInterrupt:
print("\nYowsdown")
sys.exit(0)
