def temp_authorize_guest(track_id):
'''Function for giving temporary internet access for a client
This function send API commands to controller, return ok
'''
guest_track = Guesttrack.query.filter_by(track_id=track_id).first()
if not guest_track:
current_app.logger.error("Called temp_authorize_guest with wrong track ID:%s"%track_id)
abort(404)
#validate session associated with this track ID
guest_session = Guestsession.query.filter_by(id=guest_track.session_id).first()
if not guest_session:
current_app.logger.error("Called temp_authorize_guest with wrong Session from track ID:%s"%track_id)
abort(404)
guest_track.state =GUESTRACK_TEMP_AUTH
db.session.commit()
#get details from track ID and authorize
if not current_app.config['NO_UNIFI'] :
try:
c = Controller(current_app.config['LANDINGSITE']['unifihost'], current_app.config['LANDINGSITE']['unifiadmin'], current_app.config['LANDINGSITE']['unifipass'],current_app.config['LANDINGSITE']['unifiport'],current_app.config['LANDINGSITE']['unifiversion'],current_app.config['LANDINGSITE']['unifisiteid'])
c.authorize_guest(guest_track.device_mac,5,ap_mac=guest_track.ap_mac)
except:
current_app.logger.exception('Exception occured while trying to authorize User')
return jsonify({'status':0,'msg': "Error!!"})
return jsonify({'status':1,'msg': "DONE"})
else:
return jsonify({'status':1,'msg': "DEBUG enabled"})
def run(self):
hosts = defaultdict()
ipl_begin = ip2long(self.ip_begin)
ipl_end = ip2long(self.ip_end)
try:
c = Controller(self.controller, self.username, self.password)
for client in c.get_clients():
ip = client.get('ip', False)
if not ip:
continue
ipl_cur = ip2long(ip)
if ipl_cur >= ipl_begin and ipl_cur <= ipl_end:
hosts[ip] = client['mac'].lower()
self.hosts = hosts
except:
# somethimes a weird SSL Handshake errors appears in combination
# with the ubiquiti tomcat server.
#
# see: http://stackoverflow.com/questions/14167508/intermittent-sslv3-alert-handshake-failure-under-python
return False
def get_scanner(hass, config):
"""Setup Unifi device_tracker."""
from unifi.controller import Controller
if not validate_config(config, {DOMAIN: [CONF_USERNAME, CONF_PASSWORD]},
_LOGGER):
_LOGGER.error('Invalid configuration')
return False
this_config = config[DOMAIN]
host = this_config.get(CONF_HOST, 'localhost')
username = this_config.get(CONF_USERNAME)
password = this_config.get(CONF_PASSWORD)
try:
port = int(this_config.get(CONF_PORT, 8443))
except ValueError:
_LOGGER.error('Invalid port (must be numeric like 8443)')
return False
try:
ctrl = Controller(host, username, password, port, 'v4')
except urllib.error.HTTPError as ex:
_LOGGER.error('Failed to connect to unifi: %s', ex)
return False
return UnifiScanner(ctrl)
def authorize_guest(track_id):
'''Function called after respective auth mechanisms are completed
This function send API commands to controller, redirect user to correct URL
'''
#
#Validate track id and get all the needed variables
guest_track = Guesttrack.query.filter_by(track_id=track_id).first()
if not guest_track:
current_app.logger.error("Called authorize_guest with wrong track ID:%s"%track_id)
abort(404)
#validate session associated with this track ID
guest_session = Guestsession.query.filter_by(id=guest_track.session_id).first()
if not guest_session:
current_app.logger.error("Called authorize_guest with wrong Session from track ID:%s"%track_id)
abort(404)
#Check if the session is authorized
if not guest_session.state == SESSION_AUTHORIZED:
current_app.logger.error("Called authorize_guest with wrong Non Authorized session with track ID:%s"%track_id)
abort(404)
#Send unifi API commands if the user has completed login
if not current_app.config['NO_UNIFI'] :
#code to send auth command to controller
try:
c = Controller(current_app.config['LANDINGSITE']['unifihost'], current_app.config['LANDINGSITE']['unifiadmin'], current_app.config['LANDINGSITE']['unifipass'],current_app.config['LANDINGSITE']['unifiport'],current_app.config['LANDINGSITE']['unifiversion'],current_app.config['LANDINGSITE']['unifisiteid'])
c.authorize_guest(guest_track.device_mac,guest_session.duration,ap_mac=guest_track.ap_mac)
except:
current_app.logger.exception('Exception occured while trying to authorize User')
return "Error Occured!"
#Code to handle guest after successful login
if current_app.config['LANDINGSITE']['redirecturl']:
return redirect(format_url(current_app.config['LANDINGSITE']['redirecturl']))
elif guest_track.orig_url is not None:
#redirect User's URL
return redirect(format_url(guest_track.orig_url))
else:
#redirect user to google.com
return redirect(format_url("www.google.com"),code=302)
def __init__(self, host, user, pwd, port="8443", ver="v4"):
"""
Initialize the Unifi API, binding to the controller on the specified
host/port with the passed password and setting up the appropriate
internal connection.
@param host Host to connect to.
@param user User to connect as, needs to be at least a R/O admin.
@param pwd Password of the user to connect as.
@param port Port that the Unifi API is listening on.
@param ver Version of the Unifi API to use, default to v4.
"""
# Create controller instance.
self._controller = Controller(host, user, pwd, port, ver)
self._owner = user
self._stats = []
def get_scanner(hass, config):
"""Setup Unifi device_tracker."""
from unifi.controller import Controller
host = config[DOMAIN].get(CONF_HOST)
username = config[DOMAIN].get(CONF_USERNAME)
password = config[DOMAIN].get(CONF_PASSWORD)
site_id = config[DOMAIN].get(CONF_SITE_ID)
port = config[DOMAIN].get(CONF_PORT)
try:
ctrl = Controller(host, username, password, port, 'v4', site_id)
except urllib.error.HTTPError as ex:
_LOGGER.error('Failed to connect to unifi: %s', ex)
return False
return UnifiScanner(ctrl)
required=True)
parser.add_argument('-a',
'--apiversion',
help='Base version of the AP (v2 or v3)',
required=False,
default='v2')
parser.add_argument('-s',
'--site',
help='For --apiversion v3 only, chosee site name',
required=False,
default='default')
args = parser.parse_args()
site_ctrl_version = args.targetversion
c = Controller(args.controller, args.user, args.password, args.apiversion,
args.site)
command_list = open('command_list.sh', 'w+')
updated = 0
needs_update = 0
for ap in c.get_aps():
if ap['version'] == site_ctrl_version:
updated = updated + 1
else:
needs_update = needs_update + 1
command_list.write('sshpass -p ' + args.password +
def handle(msg):
chat_id = '******USERID-CHAT-TELEGRAM********'
command = msg['text']
c = Controller('IP-UBIQUITI-CONTROLLER', 'USER-UBIQUITI-CONTROLLER', 'PASS-UBIQUITI-CONTROLLER', 'PORT-UBIQUITI', 'VERSION-UBIQUITI-CONTROLLER')
if command == '/news':
d = feedparser.parse(host_feed)
for i in range(5):
teste = d.entries[i].title +" : " +d.entries[i].link
bot.sendMessage(chat_id, teste)
elif command == '/speedtest':
servers = []
st = speedtest.Speedtest()
st.get_servers(servers)
st.get_best_server()
download = st.download()/1000000
upload = st.upload()/1000000
bot.sendMessage(chat_id, "Download: " + str(download) + " Mbit/s \n" + "Upload: " + str(upload) + " Mbit/s")
elif command == '/aps':
for ap in c.get_aps():
bot.sendMessage(chat_id, 'AP named %s with MAC %s' % (ap.get('name'), ap['mac']))
elif command == '/clients':
count = 0
for client in c.get_clients():
count = count + 1
bot.sendMessage(chat_id, "We have " + str(count) + " users online!")
elif command == '/list':
for client in c.get_clients():
name = client.get('hostname') or client.get('ip', 'Unknown')
mac = client['mac']
bot.sendMessage(chat_id, name + " " + mac)
elif "/block" in command:
mac_block = command[7:]
c.block_client(mac_block)
bot.sendMessage(chat_id, "User successfully blocked!")
elif "/unblock" in command:
mac_unblock = command[9:]
c.unblock_client(mac_unblock)
bot.sendMessage(chat_id, "User successfully unblocked!")
elif command == "/alerts":
count_alerts = 0
for event in c.get_events():
count_alerts = count_alerts + 1
if count_alerts == 11:
break
else:
bot.sendMessage(chat_id, event.get('msg'))
import argparse
import json
from unifi.controller import Controller
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--controller', default='unifi', help='the controller address (default "unifi")')
parser.add_argument('-u', '--username', default='admin', help='the controller username (default("admin")')
parser.add_argument('-p', '--password', default='', help='the controller password')
parser.add_argument('-b', '--port', default='8443', help='the controller port (default "8443")')
parser.add_argument('-v', '--version', default='v2', help='the controller base version (default "v2")')
parser.add_argument('-s', '--siteid', default='default', help='the site ID, UniFi >=3.x only (default "default")')
args = parser.parse_args()
c = Controller(args.controller, args.username, args.password, args.version, args.siteid)
aps = c.get_aps()
total = guests = users = rx = tx = 0
data = dict(all=1)
for ap in aps:
data[ap['name']] = dict(uptime=ap['uptime'], total=ap['num_sta'], guests=ap['guest-num_sta'], users=ap['user-num_sta'],
tx=ap['stat']['tx_bytes'], rx=ap['stat']['rx_bytes'])
total += ap['num_sta']
guests += ap['guest-num_sta']
users += ap['user-num_sta']
rx += ap['stat']['rx_bytes']
tx += ap['stat']['tx_bytes']
data["all"] = dict( total=total, guests=guests, users=users, rx=rx, tx=tx )
except:
return 0
def set_timestamp(timestamp):
with open (args.timestamp, 'w') as file:
file.write('%s\n' % str(timestamp))
def unixtimestamp_to_datetime(timestamp):
mytime = datetime.datetime.fromtimestamp(timestamp/1000)
mytime.replace(microsecond = (timestamp % 1000) * 1000)
return mytime
try:
chost = args.controller
c = Controller(chost, args.user, args.password)
except Exception:
logdata = "%s %s Connection error to host = %s, error = %s" % (time.strftime("%b %d %H:%M:%S"), chost, chost, sys.exc_info()[1])
write_to_logfile(logdata)
sys.exit()
try:
aps = c.get_aps()
except Exception:
logdata = "%s %s Connection error to host = %s, error = %s" % (time.strftime("%b %d %H:%M:%S"), chost, chost, sys.exc_info()[1])
write_to_logfile(logdata)
sys.exit()
users = c.get_users()
clients = c.get_clients()
storedtimestamp = unixtimestamp_to_datetime(get_last_timestamp())
userName = args.user
else:
userName = os.getenv("UNIFI_USER")
if userName is None:
userName = raw_input('Username: '******'Password: '******'ip', 'Unknown')
hostname = client.get('hostname')
name = client.get('name', hostname)
if not args.mixedcase:
name = name.lower()
mac = client['mac']
import argparse
from unifi.controller import Controller
parser = argparse.ArgumentParser(description='Create SSH update script for syswrapper.sh based firmware mass-upgrade, requires OpenSSH and sshpass to work.')
parser.add_argument('-c', '--controller', help='Controller DNS name or IP, this cannot be localhost here.', required=True)
parser.add_argument('-u', '--user', help='Site admin username.', required=True)
parser.add_argument('-p', '--password', help='Site admin password.', required=True)
parser.add_argument('-t', '--targetversion', help='Target firmware version. Look up precise versioning in the Ubiquiti KB, also see /usr/lib/unifi/dl/firmware/', required=True)
parser.add_argument('-a', '--apiversion', help='Base version of the AP (v2 or v3)', required=False, default='v2')
parser.add_argument('-s', '--site', help='For --apiversion v3 only, chosee site name', required=False, default='default')
args = parser.parse_args()
site_ctrl_version = args.targetversion
c = Controller(args.controller, args.user, args.password, args.apiversion, args.site)
command_list = open('command_list.sh', 'w+')
updated = 0
needs_update = 0
for ap in c.get_aps():
if ap['version'] == site_ctrl_version:
updated = updated + 1
else:
needs_update = needs_update+1
command_list.write('sshpass -p '
def ctlr_login(self):
self.c = Controller(self.ctlr_ip,self.ctlr_username,self.ctlr_password,self.ctrl_web_port,self.ctrl_web_version)
return self.c
class MyCtlr:
###############################################################
## CONTROLLER PARAMETERS ##
###############################################################
ctlr_ip = ""
ctlr_username = ""
ctlr_password = ""
ctlr_url = ""
debug = 0
###############################################################
## Initialization ##
###############################################################
def __init__(self, ip, ctlr_web_id, ctlr_web_pw, ctrl_web_port, ctrl_web_version):
self.ctlr_ip = ip
self.ctlr_username = ctlr_web_id
self.ctlr_password = ctlr_web_pw
self.ctrl_web_port = ctrl_web_port
self.ctrl_web_version = ctrl_web_version
###############################################################
## CONTROLLER FUNCTIONS ##
###############################################################
def make_datastr(self, ll):
dstr = ""
for couple in ll:
dstr = dstr + str(couple[0]) + "=" + str(couple[1]) + "&"
return dstr[:-1]
def make_jsonstr(self, ll):
jstr = ""
for couple in ll:
jstr = jstr + "\"" + str(couple[0]) + "\":" + couple[1] + ","
return "{" + jstr[:-1] + "}"
def decode_json(self, jstr):
decoded = json.loads(jstr)
return json.loads(json.dumps(decoded["data"]))
def ctlr_login(self):
self.c = Controller(self.ctlr_ip,self.ctlr_username,self.ctlr_password,self.ctrl_web_port,self.ctrl_web_version)
return self.c
def ctrl_stat_user_blocked(self):
users = self.c.get_users()
blocked = []
for user in users:
if user.has_key('blocked'):
if str(user['blocked']) == 'True':
blocked.append(user)
return blocked
def ctrl_list_group_members(self,group_id):
users = self.c.get_users()
group_users = []
for user in users:
if user.has_key('usergroup_id'):
if str(user['usergroup_id']) == group_id:
group_users.append(user)
return group_users
def ctrl_list_essid_members(self,essid_id):
users = self.c.get_clients()
group_users = []
for user in users:
if user.has_key('essid'):
if str(user['essid']) == essid_id:
group_users.append(user)
return group_users
def ctrl_list_group(self):
grouplist={}
grouplist = self.c.get_user_groups()
return grouplist
def ctlr_stat_device(self):
aps = self.c.get_aps()
return aps
def ctlr_stat_sta(self):
clients = self.c.get_clients()
return clients
def ctlr_wlan_conf(self):
wlan_conf = self.c.get_wlan_conf()
return wlan_conf
def ctlr_reboot_ap(self, apnamefilter=""):
aplist = self.ctlr_stat_device()
try:
for ap in aplist:
if not ap.has_key('state') or ap['state'] != 1:
continue
if (ap.has_key('name') and ap['name'].startswith(apnamefilter)) or not ap.has_key('name'):
if ap.has_key('name'): print "Rebooting AP:", ap['name']
if not ap.has_key('name'): print "Rebooting AP:", ap['mac']
self.c.restart_ap(ap['mac'])
except ValueError:
pass
def ctlr_enabled_wlans_on_all_ap(self, apnamefilter="", target_wlan=[], en=True, wlans_forced_off=[]):
aplist = self.ctlr_stat_device()
wlanlist = self.ctlr_wlan_conf()
if self.debug>0: print "Configure all Wireless LANs status to", en
try:
for ap in self.aplist:
if not ap.has_key('state') or ap['state'] != 1:
continue
if ap.has_key('name') and ap['name'].startswith(apnamefilter):
self.ctlr_enabled_wlans(ap['name'], target_wlan, en, aplist, wlanlist, wlans_forced_off)
elif not ap.has_key('name'):
self.ctlr_enabled_wlans(ap['mac'], target_wlan, en, aplist, wlanlist, wlans_forced_off)
except ValueError:
pass
def ctlr_mac_cmd(self, target_mac, command):
if command == "block":
self.c.block_client(target_mac)
elif command == "unblock":
self.c.unblock_client(target_mac)
elif command == "reconnect":
self.c.disconnect_client(target_mac)
elif command == "restart":
self.c.restart_ap(target_mac)
return True
def ctlr_get_ap_stat_field(self, apname, tag, aplist=""):
if aplist=="":
aplist = self.ctlr_stat_device()
try:
for ap in self.aplist:
if ap.has_key('name') and apname == ap['name']:
return ap[tag]
except ValueError:
pass
# pass a list of tags
def ctlr_get_sta_stat_fields_by_mac(self, stamac, tag, stalist=""):
if stalist=="":
stalist = self.ctlr_stat_sta()
try:
for sta in stalist:
if sta.has_key('mac') and stamac == sta['mac']:
rtag = []
for t in tag:
rtag.append(sta[t])
return rtag
except ValueError:
pass
def ctlr_get_all_sta_mac(self, stalist=""):
sta_mac_list = []
if stalist=="":
stalist = self.ctlr_stat_sta()
try:
for sta in stalist:
if sta.has_key('mac'):
sta_mac_list.append(sta['mac'])
except ValueError:
pass
return sta_mac_list
def ctlr_get_sta_stat_fields_by_name(self, name, tag, stalist=""):
if stalist=="":
stalist = self.ctlr_stat_sta()
try:
for sta in self.stalist:
if sta.has_key('hostname') and name == sta['hostname']:
rtag = []
for t in tag:
rtag.append(sta[t])
return rtag
except ValueError:
pass
#!/usr/bin/python
from unifi.controller import Controller
import subprocess
###############################
#Change me here for where to send email and what controller to connect to
recipient = '*****@*****.**'
subject = 'Address blocked on Unifi Controller'
c = Controller('127.0.0.1', '<username>', '<password>', '<port>', '<version>')
###############################
################################
#Define the empty variable
body="The following addresses were blocked because they were not on the allowed list:"
def send_message(recipient, subject, body):
try:
process = subprocess.Popen(['mail', '-s', subject, recipient],
stdin=subprocess.PIPE)
except Exception, error:
print error
process.communicate(body)
#Create the empty list that will be used for our connected clients
connectedlist = list()
allowed = list()
#Create a list of the current mac addresses.
putval(identifier('tx_performance'), values('tx_dropped', 'tx_retries', 'tx_packets') )
# Clients associated with ESSID on this AP
putval(identifier('ath_nodes'), values('num_sta'))
# Miscellaneous statistics
prefixes = ['ath_stat-', '']
bases = ['ccq', 'rx_frags', 'rx_nwids', 'rx_crypts']
for type, key in [ [p + b for p in prefixes] for b in bases]:
putval(identifier(type), values(key) )
if __name__ == '__main__':
from urllib2 import URLError, HTTPError
while True:
now = datetime.datetime.utcnow()
try:
if not controller:
controller = Controller(args.controller, args.username, args.password, args.port, args.version, args.site_id)
# controller = Controller(**args)
for ap in controller.get_aps():
print_controller_stats(controller)
print_ap_stats(ap)
print_essid_stats(ap)
time.sleep(args.interval)
except (URLError, HTTPError) as err:
controller = None
time.sleep(10)
continue
import argparse
from unifi.controller import Controller
c = Controller('X.X.X.X', 'admin', 'PASSWORD', '8443', 'v3', 'emartinez')
aps = c.get_aps()
ap_names = dict([(ap['mac'], ap['name']) for ap in aps])
clients = c.get_clients()
clients.sort(key=lambda x: -x['rssi'])
print(clients)
c = Controller('Y.Y.Y.Y', 'admin', 'PASSWORD', '8443', 'v3',
'em-oficinas-centrales')
aps = c.get_aps()
ap_names = dict([(ap['mac'], ap['name']) for ap in aps])
clients = c.get_clients()
clients.sort(key=lambda x: -x['rssi'])
print(clients)
class Unifi:
"""
Helper class which collects node information from a Unifi controller instance
that delivers networks. This polls the complete AP info using get_aps() with
the Python bindings for the Unifi JSON API, and reformats the output to fit
in the standard Alfred format.
"""
# Initialization
# --------------
def __init__(self, host, user, pwd, port="8443", ver="v4"):
"""
Initialize the Unifi API, binding to the controller on the specified
host/port with the passed password and setting up the appropriate
internal connection.
@param host Host to connect to.
@param user User to connect as, needs to be at least a R/O admin.
@param pwd Password of the user to connect as.
@param port Port that the Unifi API is listening on.
@param ver Version of the Unifi API to use, default to v4.
"""
# Create controller instance.
self._controller = Controller(host, user, pwd, port, ver)
self._owner = user
self._stats = []
def nodeinfo(self, gw):
"""
Collect node information of the nodes connected to the Unifi
controller, returning the information in a format suitable to
later processing in a decoded form.
@param gw Gateway to use for Unifi controller.
@return nodeinfo structure as returned by Batman.
"""
# Walk the nodes.
nodes = []
for node in self._controller.get_aps():
if "uptime" not in node:
continue
# Create nodes.
nodeid = sub("[^a-fA-F0-9]+", "", node["mac"])
nodes.append(
{
"hardware": {"model": "Unifi {0}".format(MODELS.get(node["model"], "unknown")), "nproc": 1},
"hostname": "freifunk-celle-unifi-{0}".format(nodeid),
"location": {"latitude": node["x"], "longitude": node["y"]},
"network": {"addresses": [node["ip"]], "mac": node["mac"]},
"node_id": nodeid,
"owner": {"contact": "*****@*****.**"},
"software": {
"autoupdater": {"branch": "stable", "enabled": True},
"firmware": {"base": "Unifi", "release": node["version"]},
},
"system": {"site_code": "ffce"},
}
)
# Create stats.
self._stats.append(
{
"clients": {"total": -1, "wifi": -1},
"node_id": nodeid,
"gateway": gw,
"uptime": node["uptime"],
"traffic": {
"rx": {"bytes": node["stat"].get("rx_bytes", 0), "packets": node["stat"].get("rx_packets", 0)},
"tx": {"bytes": node["stat"].get("tx_bytes", 0), "packets": node["stat"].get("tx_bytes", 0)},
},
}
)
# Return node list.
return nodes
def statistics(self):
"""
Fetch the precollected statistics that were derived from the
Unifi API statistics data. This must be called after the node
info has already been retrieved.
@return Statistics data.
"""
# Return stats.
return self._stats
