slightly modified

This commit is contained in:
printfuck 2023-04-09 22:09:35 +02:00
commit 69d1545089
9 changed files with 578 additions and 0 deletions

52
arp.py Normal file
View file

@ -0,0 +1,52 @@
from scapy.all import *
import logging as log
import sqlite3
import signal
import sys
def signal_handler(sig, frame):
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
def arp_display(pkt):
if pkt[ARP].op == 1: #who-has (request)
return f"Request from: {pkt[ARP].hwsrc} ({pkt[ARP].psrc}) requesting MAC for {pkt[ARP].pdst}"
#if pkt[ARP].op == 2: #is-at (response)
lookup("mac.db", str(pkt[ARP].hwsrc))
add("mac.db",str(pkt[ARP].hwsrc),round(time.time()))
return f"Code: {pkt[ARP].op} - Source {pkt[ARP].hwsrc} with address {pkt[ARP].psrc}"
def init(database):
s = sqlite3.connect(database)
c = s.cursor()
c.execute('''
CREATE TABLE if not exists mac_table(
id INTEGER PRIMARY KEY AUTOINCREMENT,
mac text NOT NULL,
ts integer NOT NULL
);''')
s.commit()
def lookup(database, mac):
s = sqlite3.connect(database)
c = s.cursor()
print ("lookup")
c.execute("SELECT ts FROM mac_table where mac = ? ORDER BY ts DESC LIMIT 1;", mac)
r = c.fetchone()
print (r)
if r is not None:
print ("last seen: ", round(time.time()) - r, " ms ago")
def add(database,mac,time):
s = sqlite3.connect(database)
c = s.cursor()
c.execute("INSERT INTO mac_table (mac, ts) VALUES (?,?)", (mac, time))
s.commit()
init("mac.db")
while True:
sniff(prn=arp_display, filter="arp", store=0, iface='wlan0', count=1)

92
axmpp.py Normal file
View file

@ -0,0 +1,92 @@
import logging
import slixmpp
from slixmpp.exceptions import IqError, IqTimeout
import os
from dotenv import load_dotenv
import RPi.GPIO as GPIO
import time
from threading import Thread
import asyncio
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)
init = 0
class EchoBot(slixmpp.ClientXMPP):
def __init__(self, jid, password):
slixmpp.ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
loop = asyncio.get_event_loop()
asyncio.run_coroutine_threadsafe(asyncio.to_thread(self.ringLoop), loop)
def session_start(self, event):
self.send_presence()
self.get_roster()
# Most get_*/set_* methods from plugins use Iq stanzas, which
# can generate IqError and IqTimeout exceptions
#
# try:
# self.get_roster()
# except IqError as err:
# logging.error('There was an error getting the roster')
# logging.error(err.iq['error']['condition'])
# self.disconnect()
# except IqTimeout:
# logging.error('Server is taking too long to respond')
# self.disconnect()
def message(self, msg):
global init
if msg['type'] in ('chat', 'normal'):
print (msg['body'])
if msg['body'] == "open":
msg.reply("Buzzing").send()
if init == 0:
GPIO.setup(17, GPIO.OUT)
init = 1
GPIO.output(17, GPIO.LOW)
time.sleep(2)
GPIO.output(17, GPIO.HIGH)
else:
msg.reply("Not Understood").send()
def ringLoop(self):
print("foo1")
#GPIO.setmode(GPIO.BCM) # GPIO Numbers instead of board numbers
recipient = os.getenv("NOTIFY")
#GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)
while True:
print ("GPIO OUTPUT: ", GPIO.input(23))
time.sleep(0.1)
if (GPIO.input(23) == 0):
self.send_message(mto=recipient, mbody="Klingelt!", mtype='chat')
#self._loop.call_soon_threadsafe(self.send_message(mto=recipient, mbody="Klingelt!", mtype='chat'))
print ("ringing")
print ("ringing")
print ("ringing")
print ("ringing")
print ("ringing")
if __name__ == '__main__':
# Ideally use optparse or argparse to get JID,
# password, and log level.
load_dotenv()
password = os.getenv("PASS")
jid = os.getenv("JID")
#GPIO.setup(17, GPIO.OUT)
#GPIO.output(17, GPIO.LOW)
logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s %(message)s')
xmpp = EchoBot(jid, password)
#Thread(name="GPIO_INPUT", target=xmpp.ringLoop).start()
#asyncio.run_coroutine_threadsafe(self.waiting_queue.put((data, use_filters)), self.loop)
xmpp.connect()
xmpp.process(forever=True)

10
bar.py Normal file
View file

@ -0,0 +1,10 @@
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM) # GPIO Numbers instead of board numbers
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)
while True:
#print (GPIO.input(23))
time.sleep(0.1)
if (GPIO.input(23) == 0)
print ("ringing")

25
foo.py Normal file
View file

@ -0,0 +1,25 @@
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM) # GPIO Numbers instead of board numbers
RELAIS_1_GPIO = 17
GPIO.setup(RELAIS_1_GPIO, GPIO.OUT) # GPIO Assign mode
#GPIO.output(RELAIS_1_GPIO, GPIO.LOW) # out
GPIO.output(RELAIS_1_GPIO, GPIO.LOW) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.HIGH) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.LOW) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.HIGH) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.LOW) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.HIGH) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.LOW) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.HIGH) # on
time.sleep(10)
GPIO.output(RELAIS_1_GPIO, GPIO.LOW) # on
time.sleep(10)

61
fooserver.py Normal file
View file

@ -0,0 +1,61 @@
#!/usr/bin/python3.8
#
from enum import Enum
from flask import Flask as f
from flask import Response
import RPi.GPIO as GPIO
import os
import time
from threading import Thread
#import re
#import json
#import req as r
class TreeState(Enum):
OFF = 1
BUZZ = 2
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
#GPIO.setup(17, GPIO.OUT)
#GPIO.output(17, GPIO.LOW)
#time.sleep(1)
#GPIO.output(17, GPIO.HIGH)
app = f(__name__)
state = TreeState.OFF
def loop():
global state
while True:
time.sleep(1)
print ("loop")
if (state == TreeState.BUZZ):
print ("buzz")
GPIO.output(17, GPIO.LOW)
time.sleep(2)
GPIO.output(17, GPIO.HIGH)
state = TreeState.OFF
@app.route('/buzz', methods = ['GET'])
def rbuzz():
#global state
#state = TreeState.BUZZ
#GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17, GPIO.LOW)
time.sleep(2)
GPIO.output(17, GPIO.HIGH)
return "{\"status\":0}"
@app.route('/')
def index():
return open("index.html", "r").read()
if __name__ == '__main__':
# Run Server
#Thread(name="backgroundLoop", target=loop).start()
app.run(host='0.0.0.0', port=80, debug=True)

8
index.html Normal file
View file

@ -0,0 +1,8 @@
<html>
<body>
<h1>Door</h1>
<a href="/buzz">open</a>
</body>
</html>

107
waxmpp.py Normal file
View file

@ -0,0 +1,107 @@
import logging
# xmpp
import slixmpp
from slixmpp.exceptions import IqError, IqTimeout
# files
import os
# config
from dotenv import load_dotenv
# gpio
import RPi.GPIO as GPIO
# sleep
import time
# hacking my godamn threads into slixmpp non threadable library
import asyncio
# webserver
from flask import Flask as f
from flask import Response
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)
init = 0
app = f("web_thread")
class EchoBot(slixmpp.ClientXMPP):
def __init__(self, jid, password):
slixmpp.ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.add_event_handler("disconnected", self.my_reconnect)
#self.add_event_handler("connection_failed", self._reconnect)
loop = asyncio.get_event_loop()
asyncio.run_coroutine_threadsafe(asyncio.to_thread(app.run,host='0.0.0.0', port=80, debug=False), loop)
asyncio.run_coroutine_threadsafe(asyncio.to_thread(self.ringLoop), loop)
def session_start(self, event):
self.send_presence()
self.get_roster()
def message(self, msg):
global init
if msg['type'] in ('chat', 'normal'):
print (msg['body'])
if msg['body'] == "open":
msg.reply("Buzzing").send()
if init == 0:
GPIO.setup(17, GPIO.OUT)
init = 1
GPIO.output(17, GPIO.LOW)
time.sleep(2)
GPIO.output(17, GPIO.HIGH)
else:
msg.reply("Not Understood").send()
async def my_reconnect(self, ev):
await asyncio.sleep(5)
while not self.is_connected():
self.connect()
await asyncio.sleep(20)
self.send_message(mto=recipient, mbody="reconnected!", mtype='chat')
def ringLoop(self):
channel = 0
nya = 0
while True:
channel = GPIO.wait_for_edge(23, GPIO.FALLING, timeout=5000)
nya = time.time_ns()
if channel is None:
print (time.strftime("%d-%m|%H:%M",time.localtime()),"> GPIO OUTPUT: 1")
else:
channel = GPIO.wait_for_edge(23, GPIO.BOTH, timeout=5000)
msg = "Ringing for " + str((time.time_ns() - nya)/1000000) + " ms"
xmpp.send_message(mto=recipient, mbody=msg, mtype='chat')
print (time.strftime("%d-%m|%H:%M",time.localtime()),"> Ringing!")
@app.route('/buzz', methods = ['GET'])
def rbuzz():
global init
if init == 0:
GPIO.setup(17, GPIO.OUT)
init = 1
GPIO.output(17, GPIO.LOW)
time.sleep(2) # dumb - I know - go on
GPIO.output(17, GPIO.HIGH)
xmpp.send_message(mto=recipient, mbody="opened via web interface", mtype='chat')
return "{\"status\":0}"
@app.route('/')
def index():
return open("index.html", "r").read()
if __name__ == '__main__':
load_dotenv()
password = os.getenv("PASS")
jid = os.getenv("JID")
recipient = os.getenv("NOTIFY")
logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s %(message)s')
xmpp = EchoBot(jid, password)
xmpp.connect()
xmpp.process(forever=True)

125
waxmpp_old.py Normal file
View file

@ -0,0 +1,125 @@
import logging
# xmpp
import slixmpp
from slixmpp.exceptions import IqError, IqTimeout
# files
import os
# config
from dotenv import load_dotenv
# gpio
import RPi.GPIO as GPIO
# sleep
import time
# hacking my godamn threads into slixmpp non threadable library
import asyncio
# webserver
from flask import Flask as f
from flask import Response
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)
init = 0
app = f("web_thread")
class EchoBot(slixmpp.ClientXMPP):
def __init__(self, jid, password):
slixmpp.ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.add_event_handler("disconnect", self.reconnect)
self.add_event_handler("connection_failed", self.reconnect)
loop = asyncio.get_event_loop()
asyncio.run_coroutine_threadsafe(asyncio.to_thread(app.run,host='0.0.0.0', port=80, debug=False), loop)
asyncio.run_coroutine_threadsafe(asyncio.to_thread(self.ringLoop), loop)
def session_start(self, event):
self.send_presence()
self.get_roster()
# Most get_*/set_* methods from plugins use Iq stanzas, which
# can generate IqError and IqTimeout exceptions
#
# try:
# self.get_roster()
# except IqError as err:
# logging.error('There was an error getting the roster')
# logging.error(err.iq['error']['condition'])
# self.disconnect()
# except IqTimeout:
# logging.error('Server is taking too long to respond')
# self.disconnect()
def message(self, msg):
global init
if msg['type'] in ('chat', 'normal'):
print (msg['body'])
if msg['body'] == "open":
msg.reply("Buzzing").send()
if init == 0:
GPIO.setup(17, GPIO.OUT)
init = 1
GPIO.output(17, GPIO.LOW)
time.sleep(2)
GPIO.output(17, GPIO.HIGH)
else:
msg.reply("Not Understood").send()
def reconnect(self):
while not self.is_connected():
self.connect()
time.sleep(5)
def ringLoop(self):
recipient = os.getenv("NOTIFY")
debug = 0
while True:
#debug = debug + 1
#if debug == 50:
# print (time.strftime("%d-%m|%H:%M",time.localtime()),"> GPIO OUTPUT: ", GPIO.input(23))
# debug = 0
#time.sleep(0.1)
channel = GPIO.wait_for_edge(23, GPIO.FALLING, timeout=5000)
if channel is None:
print (time.strftime("%d-%m|%H:%M",time.localtime()),"> GPIO OUTPUT: 1")
else:
#if GPIO.input(23) == 0:
self.send_message(mto=recipient, mbody="Klingelt!", mtype='chat')
time.sleep(0.5)
# self._loop.call_soon_threadsafe(self.send_message(mto=recipient, mbody="Klingelt!", mtype='chat'))
# works too without modifying the library but throws errors everytime it's called
print ("ringing")
print ("ringing")
print ("ringing")
print ("ringing")
print ("ringing")
@app.route('/buzz', methods = ['GET'])
def rbuzz():
global init
if init == 0:
GPIO.setup(17, GPIO.OUT)
init = 1
GPIO.output(17, GPIO.LOW)
time.sleep(2) # dumb - I know - go on
GPIO.output(17, GPIO.HIGH)
return "{\"status\":0}"
@app.route('/')
def index():
return open("index.html", "r").read()
if __name__ == '__main__':
load_dotenv()
password = os.getenv("PASS")
jid = os.getenv("JID")
logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s %(message)s')
xmpp = EchoBot(jid, password)
xmpp.connect()
xmpp.process(forever=True)

98
xmpp.py Normal file
View file

@ -0,0 +1,98 @@
import logging
from slixmpp import ClientXMPP
from slixmpp.exceptions import IqError, IqTimeout
import os
from dotenv import load_dotenv
import RPi.GPIO as GPIO
import time
from threading import Thread
import asyncio
class EchoBot(ClientXMPP):
def __init__(self, jid, password):
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
# If you wanted more functionality, here's how to register plugins:
# self.register_plugin('xep_0030') # Service Discovery
# self.register_plugin('xep_0199') # XMPP Ping
# Here's how to access plugins once you've registered them:
# self['xep_0030'].add_feature('echo_demo')
# If you are working with an OpenFire server, you will
# need to use a different SSL version:
# import ssl
# self.ssl_version = ssl.PROTOCOL_SSLv3
def session_start(self, event):
self.send_presence()
self.get_roster()
# Most get_*/set_* methods from plugins use Iq stanzas, which
# can generate IqError and IqTimeout exceptions
#
# try:
# self.get_roster()
# except IqError as err:
# logging.error('There was an error getting the roster')
# logging.error(err.iq['error']['condition'])
# self.disconnect()
# except IqTimeout:
# logging.error('Server is taking too long to respond')
# self.disconnect()
def message(self, msg):
if msg['type'] in ('chat', 'normal'):
print (msg['body'])
if msg['body'] == "open":
buzz()
msg.reply("Buzzing").send()
else:
msg.reply("Not Understood").send()
def sendRing():
global xmpp
recipient = os.getenv("NOTIFY")
print ("sent message to ")
print (recipient)
#loop = asyncio.get_event_loop(xmpp)
#asyncio.run_coroutine_threadsafe(asyncio.to_thread(xmpp.send_message(mto=recipient, mbody="Klingelt!", mtype='chat')),loop)
xmpp.send_message(mto=recipient, mbody="Klingelt!", mtype='chat')
def ringLoop():
GPIO.setmode(GPIO.BCM) # GPIO Numbers instead of board numbers
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)
timer = 100
while True:
print (GPIO.input(23))
time.sleep(0.1)
timer = timer - 1
if (GPIO.input(23) == 0 or timer == 0):
sendRing()
print ("ringing")
print ("ringing")
print ("ringing")
print ("ringing")
print ("ringing")
if __name__ == '__main__':
# Ideally use optparse or argparse to get JID,
# password, and log level.
load_dotenv()
password = os.getenv("PASS")
jid = os.getenv("JID")
logging.basicConfig(level=logging.DEBUG, format='%(levelname)-8s %(message)s')
xmpp = EchoBot(jid, password)
Thread(name="GPIO_INPUT", target=ringLoop).start()
#asyncio.run_coroutine_threadsafe(self.waiting_queue.put((data, use_filters)), self.loop)
xmpp.connect()
xmpp.process(forever=True)