logviewer/dbview/views.py

   1 from django.shortcuts import render
   2 from django.http import HttpResponse, HttpRequest
   3 import os
   4 import sqlite3
   5 import time
   6 import json
   7 import websockets
   8
   9 import pprint
  10
  11 from django.views.decorators.csrf import csrf_exempt
  12
  13 def load_db(query):
  14     dir_list = os.listdir("logs/")
  15     connection = sqlite3.connect("logs/"+dir_list[0])
  16     cursor = connection.cursor()
  17     rows = cursor.execute(query).fetchall()
  18     return(rows)
  19
  20 @csrf_exempt
  21
  22 def index(request):
  23     #if request.method == 'POST':
  24     #    for key, value in request.POST.items():
  25     #        print(key,value)
  26     if request.path == "/devices/views/all_views.json":
  27         uuid_members="["
  28         dev_count=list(load_db("select count(device) from devices where type='Wi-Fi AP'"))
  29         (devcount,) = dev_count[0]
  30         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"IEEE802.11 Access Points\", \"kismet.devices.view.id\": \"phydot11_accesspoints\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  31         dev_count=list(load_db("select count(device) from devices where phyname='IEEE802.11'"))
  32         (devcount,) = dev_count[0]
  33         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"IEEE802.11 devices\", \"kismet.devices.view.id\": \"phy-IEEE802.11\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  34         dev_count=list(load_db("select count(device) from devices where type='RTL433'"))
  35         (devcount,) = dev_count[0]
  36         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"RTL433 devices\", \"kismet.devices.view.id\": \"phy-RTL433\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  37         dev_count=list(load_db("select count(device) from devices where type='Z-wave'"))
  38         (devcount,) = dev_count[0]
  39         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"Z-Wave devices\", \"kismet.devices.view.id\": \"phy-Z-Wave\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  40         dev_count=list(load_db("select count(device) from devices where type='BR/EDR'"))
  41         (devcount,) = dev_count[0]
  42         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"Bluetooth devices\", \"kismet.devices.view.id\": \"phy-Bluetooth\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  43         dev_count=list(load_db("select count(device) from devices where type='UAV'"))
  44         (devcount,) = dev_count[0]
  45         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"UAV devices\", \"kismet.devices.view.id\": \"phy-UAV\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  46         dev_count=list(load_db("select count(device) from devices where type='NrfMousejack'"))
  47         (devcount,) = dev_count[0]
  48         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"NrfMousejack devices\", \"kismet.devices.view.id\": \"phy-NrfMousejack\", \"kismet.devices.view.size\": "+str(devcount)+"},"
  49         dev_count=list(load_db("select count(device) from devices where type='BTLE'"))
  50         (devcount,) = dev_count[0]
  51         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"BTLE devices\", \"kismet.devices.view.id\": \"phy-BTLE\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  52         dev_count=list(load_db("select count(device) from devices where phyname='AMR'"))
  53         (devcount,) = dev_count[0]
  54         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"RTLAMR devices\", \"kismet.devices.view.id\": \"phy-RTLAMR\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  55         dev_count=list(load_db("select count(device) from devices where phyname='ADSB'"))
  56         (devcount,) = dev_count[0]
  57         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"RTLADSB devices\", \"kismet.devices.view.id\": \"phy-RTLADSB\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  58         dev_count=list(load_db("select count(device) from devices where phyname='802.15.4'"))
  59         (devcount,) = dev_count[0]
  60         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"802.15.4 devices\", \"kismet.devices.view.id\": \"phy-802.15.4\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  61         dev_count=list(load_db("select count(device) from devices where phyname='RADIATION'"))
  62         (devcount,) = dev_count[0]
  63         uuid_members = uuid_members + "{ \"kismet.devices.view.description\": \"RADIATION devices\", \"kismet.devices.view.id\": \"phy-RADIATION\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  64         total_dev=list(load_db("select count(device) from devices"))
  65         (devcount,) = total_dev[0]
  66         uuid_members=uuid_members+"{ \"kismet.devices.view.description\": \"All devices\", \"kismet.devices.view.id\": \"all\", \"kismet.devices.view.size\": "+str(devcount)+" },"
  67         uuid_list = list(load_db("select uuid from datasources"))
  68         for uuid in uuid_list:
  69             (single_uuid,) = uuid
  70             uuid_count = list(load_db("select count(*) from data where datasource='"+str(single_uuid)+"'"))
  71             (single_uuid_count,) = uuid_count[0]
  72             uuid_members = uuid_members + "{\"kismet.devices.view.description\": \"Devices seen by datasource "+single_uuid+"\","
  73             uuid_members = uuid_members + "\"kismet.devices.view.id\": \"seenby-"+single_uuid+"\","
  74             uuid_members = uuid_members + "\"kismet.devices.view.size\": "+str(single_uuid_count)+"},"
  75         uuid_members=uuid_members[:-1]
  76         uuid_members=uuid_members+"]"
  77         return HttpResponse(uuid_members, content_type='text/json')
  78     elif request.path == "/system/user_status.json":
  79         #Hardcoded for now
  80         user_status = open('dbview/user_status.json')
  81         return HttpResponse(user_status, content_type='text/json')
  82     elif request.path == "/session/check_setup_ok":
  83         return HttpResponse('Login configured in user config')
  84     elif request.path == "/session/check_login":
  85         return HttpResponse('Login valid')
  86     elif request.path == "/dynamic.js":
  87         #INCOMPLETE - read the devices and create a dynamic.js output
  88         devices = load_db("select distinct(typestring) from datasources")
  89         load_file = open('static/dynamic.js')
  90         return HttpResponse(load_file, content_type='application/javascript')
  91     elif request.path == "/gps/location.json":
  92         #hardcoded cus it doesnt matter
  93         user_status = open('dbview/gps_status.json')
  94         return HttpResponse(user_status, content_type='text/json')
  95     elif request.path == "/alerts/wrapped/last-time/0/alerts.json":
  96         alerts = list(load_db("select cast(json as text) from alerts"))
  97         alert_string="{\"kismet.alert.list\": ["
  98         for alert in alerts:
  99             (single_alert,) = alert
 100             alert_string = alert_string + single_alert + ","
 101         alert_string = alert_string[:-1]
 102         alert_string = alert_string + "] ,\"kismet.alert.timestamp\": "+str(time.time())+"}"
 103         return HttpResponse(alert_string, content_type='text/json')
 104     elif request.path == "/phy/phy80211/ssids/views/ssids.json":
 105         ssid_count = list(load_db("select count(device) from devices where type='Wi-Fi AP'"))
 106         ssid_list = "{ \"recordsTotal\": "+str(ssid_count[0][0])+", \"data\": ["
 107         ssids = list(load_db("select cast(device as text) from devices where type='Wi-Fi AP'"))
 108         for ssid in ssids:
 109             (single_ssid,) = ssid
 110             ssid_json = json.loads(single_ssid)
 111             try:
 112                 ssid_list = ssid_list + "{"
 113                 ssid_list = ssid_list + "\"dot11.ssidgroup.first_time\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.first_time']) +"\","
 114                 ssid_list = ssid_list + "\"dot11.ssidgroup.ssid_len\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.ssidlen'])+"\","
 115                 ssid_list = ssid_list + "\"dot11.ssidgroup.crypt_set\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.crypt_set'])+"\","
 116                 ssid_list = ssid_list + "\"dot11.ssidgroup.hash\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.ssid_hash'])+"\","
 117                 ssid_list = ssid_list + "\"dot11.ssidgroup.advertising_devices_len\": \"" + str(ssid_json['dot11.device']['dot11.device.num_advertised_ssids'])+"\","
 118                 ssid_list = ssid_list + "\"dot11.ssidgroup.probing_devices_len\": \"" + str(ssid_json['dot11.device']['dot11.device.num_probed_ssids'])+"\","
 119                 ssid_list = ssid_list + "\"dot11.ssidgroup.ssid\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.ssid'])+"\","
 120                 ssid_list = ssid_list + "\"dot11.ssidgroup.responding_devices_len\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.probe_response'])+"\","
 121                 ssid_list = ssid_list + "\"dot11.ssidgroup.last_time\": \"" + str(ssid_json['dot11.device']['dot11.device.last_beaconed_ssid_record']['dot11.advertisedssid.last_time'])+"\""
 122                 ssid_list = ssid_list + "},"
 123             except:
 124                 ssid_list = ssid_list[:-1]
 125                 #print("Skipping")
 126         ssid_list = ssid_list[:-2]+ "}], \"draw\": 3, \"recordsFiltered\": "+str(ssid_count[0][0])+" }"
 127         return HttpResponse(ssid_list, content_type='text/json')
 128     elif request.path == "/system/status.json":
 129         #Hardcoded - Setup for other users
 130         user_status = open('dbview/status.json')
 131         return HttpResponse(user_status, content_type='text/json')
 132     elif request.path == "/alerts/alerts_view.json":
 133         #INCOMPLETE - Check device Mappings
 134         total_alerts=list(load_db("select count(json) from alerts"))
 135         (alert_count,) = total_alerts[0]
 136         alerts = list(load_db("select cast(json as text) from alerts"))
 137         alert_string="{\"recordsTotal\": "+str(alert_count)+",\"data\": ["
 138         for alert in alerts:
 139             (single_alert,) = alert
 140             alert_string = alert_string + single_alert + ","
 141         alert_string = alert_string[:-1]
 142         alert_string = alert_string + "], \"draw\": 6,\"recordsFiltered\": "+str(alert_count)+"}"
 143         return HttpResponse(alert_string, content_type='text/json')
 144     elif request.path == "/messagebus/last-time/0/messages.json":
 145         messages = list(load_db("select * from messages DESC limit 30"))
 146         message_string="{\"kismet.messagebus.list\": ["
 147         for message in messages:
 148             message_string = message_string + "{"
 149             message_string = message_string + "\"kismet.messagebus.message_string\": \"" + message[4] + "\","
 150             flag = "0"
 151             if message[3] == "INFO":
 152                 flag = "0"
 153             if message[3] == "LOW":
 154                 flag = "5"
 155             if message[3] == "MEDIUM":
 156                 flag = "10"
 157             if message[3] == "HIGH":
 158                 flag = "15"
 159             if message[3] == "CRITICAL":
 160                 flag = 20
 161             if message[3] == "ERROR":
 162                 flag = 20
 163             message_string = message_string + "\"kismet.messagebus.message_flags\": \"" + str(flag) + "\","
 164             message_string = message_string + "\"kismet.messagebus.message_time\": \"" + str(message[0]) + "\""
 165             message_string = message_string + "},"
 166         message_string = message_string[:-1]
 167         message_string = message_string + "], \"kismet.messagebus.timestamp\": "+str(time.time())+" }"
 168         return HttpResponse(message_string, content_type='text/json')
 169     elif request.path == "/channels/channels.json":
 170         user_status = open('dbview/channels.json')
 171         return HttpResponse(user_status, content_type='text/json')
 172     #elif request.path == "/devices/views/all/devices.json":
 173     elif request.path.startswith("/devices/views") and request.path.endswith("devices.json"):
 174         device_request=request.path[15:-13]
 175         #print("POST INFO")
 176         #print(request.POST.getlist('search[value]'))
 177         search = str(request.POST.getlist('search[value]'))[2:-2]
 178         draw = str(request.POST.getlist('draw'))[2:-2]
 179         start = str(request.POST.getlist('start'))[2:-2]
 180         limit = str(request.POST.getlist('length'))[2:-2]
 181         total_dev=list(load_db("select count(device) from devices"))
 182         (dev_count,) = total_dev[0]
 183         dev_string = ""
 184         dev_string = "{ \"recordsTotal\": "+str(dev_count)+", \"data\": [ "
 185         if device_request == "all":
 186             if search == "":
 187                 dev_list = list(load_db("select cast(device as text) from devices LIMIT "+limit+" OFFSET "+start))
 188             else:
 189                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' LIMIT "+limit+" OFFSET "+start))
 190         elif device_request == "phy-RTLADSB":
 191             if search == "":
 192                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'ADSB' LIMIT "+limit+" OFFSET "+start))
 193             else:
 194                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'ADSB' LIMIT "+limit+" OFFSET "+start))
 195         elif device_request == "phydot11_accesspoints":
 196             if search == "":
 197                 dev_list = list(load_db("select cast(device as text) from devices where type = 'Wi-Fi AP' LIMIT "+limit+" OFFSET "+start))
 198             else:
 199                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and type = 'Wi-Fi AP' LIMIT "+limit+" OFFSET "+start))
 200         elif device_request == "phy-BTLE":
 201             if search == "":
 202                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'BTLE' LIMIT "+limit+" OFFSET "+start))
 203             else:
 204                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and type = 'BTLE' LIMIT "+limit+" OFFSET "+start))
 205         elif device_request == "phy-Bluetooth":
 206             if search == "":
 207                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'Bluetooth' LIMIT "+limit+" OFFSET "+start))
 208             else:
 209                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'Bluetooth' LIMIT "+limit+" OFFSET "+start))
 210         elif device_request == "phy-RTL433":
 211             if search == "":
 212                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'RTL433' LIMIT "+limit+" OFFSET "+start))
 213             else:
 214                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'RTL433' LIMIT "+limit+" OFFSET "+start))
 215         elif device_request == "phy-IEEE802.11":
 216             if search == "":
 217                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'IEEE802.11' LIMIT "+limit+" OFFSET "+start))
 218             else:
 219                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'IEEE802.11' LIMIT "+limit+" OFFSET "+start))
 220         elif device_request == "phy-RADIATION":
 221             if search == "":
 222                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'RADIATION' LIMIT "+limit+" OFFSET "+start))
 223             else:
 224                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'RADIATION' LIMIT "+limit+" OFFSET "+start))
 225         elif device_request == "phy-802.15.4":
 226             if search == "":
 227                 dev_list = list(load_db("select cast(device as text) from devices where phyname = '802.15.4' LIMIT "+limit+" OFFSET "+start))
 228             else:
 229                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = '802.15.4' LIMIT "+limit+" OFFSET "+start))
 230         elif device_request == "phy-RTLAMR":
 231             if search == "":
 232                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'METER' LIMIT "+limit+" OFFSET "+start))
 233             else:
 234                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'METER' LIMIT "+limit+" OFFSET "+start))
 235         elif device_request == "phy-NrfMousejack":
 236             if search == "":
 237                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'NrfMousejack' LIMIT "+limit+" OFFSET "+start))
 238             else:
 239                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'NrfMousejack' LIMIT "+limit+" OFFSET "+start))
 240         elif device_request == "phy-UAV":
 241             if search == "":
 242                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'UAV' LIMIT "+limit+" OFFSET "+start))
 243             else:
 244                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'UAV' LIMIT "+limit+" OFFSET "+start))
 245         elif device_request == "phy-Z-Wave":
 246             if search == "":
 247                 dev_list = list(load_db("select cast(device as text) from devices where phyname = 'Z-Wave' LIMIT "+limit+" OFFSET "+start))
 248             else:
 249                 dev_list = list(load_db("select cast(device as text) from devices where cast(device as text) like '%"+search+"%' and phyname = 'Z-Wave' LIMIT "+limit+" OFFSET "+start))
 250         for device in dev_list:
 251             (dev,) = device
 252             dev_json = json.loads(dev)
 253             newdev = {}
 254             newdev['kismet.device.base.commonname'] = dev_json['kismet.device.base.commonname']
 255             newdev['kismet.device.base.type'] = dev_json['kismet.device.base.type']
 256             newdev['kismet.device.base.phyname'] = dev_json['kismet.device.base.phyname']
 257             newdev['kismet.device.base.crypt'] = dev_json['kismet.device.base.crypt']
 258             newdev['kismet.device.base.channel'] = dev_json['kismet.device.base.channel']
 259             newdev['kismet.device.base.datasize'] = dev_json['kismet.device.base.datasize']
 260             newdev['kismet.device.base.last_time'] = dev_json['kismet.device.base.last_time']
 261             newdev['kismet.device.base.first_time'] = dev_json['kismet.device.base.first_time']
 262             newdev['kismet.device.base.key'] = dev_json['kismet.device.base.key']
 263             newdev['kismet.device.base.macaddr'] = dev_json['kismet.device.base.macaddr']
 264             newdev['kismet.device.base.frequency'] = dev_json['kismet.device.base.frequency']
 265             newdev['kismet.device.base.manuf'] = dev_json['kismet.device.base.manuf']
 266             if newdev['kismet.device.base.phyname'] == "IEEE802.11":
 267                 newdev['adsb.device'] = 0
 268                 newdev['bluetooth.device'] = 0
 269                 newdev['uav.device'] = 0
 270             if newdev['kismet.device.base.phyname'] == "Bluetooth":
 271                 newdev['adsb.device'] = 0
 272                 newdev['uav.device'] = 0
 273                 newdev['buetooth.device'] = dev_json['bluetooth.device']
 274             if newdev['kismet.device.base.phyname'] == "ADSB":
 275                 newdev['bluetooth.device'] = 0
 276                 newdev['uav.device'] = 0
 277                 newdev['adsb.device'] = dev_json['adsb.device']
 278             if "kismet.common.rrd.last_time" in dev_json:
 279                 newdev['kismet.common.rrd.last_time'] = dev_json['kismet.common.rrd.last_time']
 280             if "dot11.device.num_associated_clients" in dev_json:
 281                 newdev['dot11.device.num_associated_clients'] = dev_json['dot11.device.num_associated_clients']
 282             if "dot11.device.last_bssid" in dev_json:
 283                 newdev['dot11.device.last_bssid'] = dev_json['dot11.device.last_bssid']
 284             if "dot11.advertisedssid.dot11e_channel_utilization_perc" in dev_json:
 285                 newdev['dot11.advertisedssid.dot11e_channel_utilization_perc'] = dev_json['dot11.advertisedssid.dot11e_channel_utilization_perc']
 286             if "dot11.advertisedssid.dot11e_qbss_stations" in dev_json:
 287                 newdev['dot11.advertisedssid.dot11e_qbss_stations'] = dev_json['dot11.advertisedssid.dot11e_qbss_stations']
 288             if "kismet.common.signal.last_signal" in dev_json:
 289                 newdev['kismet.common.signal.last_signal'] = dev_json['kismet.common.signal.last_signal']
 290             if "dot11.device.bss_timestamp" in dev_json:
 291                 newdev['dot11.device.bss_timestamp'] = dev_json['dot11.device.bss_timestamp']
 292             if "dot11.advertisedssid.dot11e_qbss" in dev_json:
 293                 newdev['dot11.advertisedssid.dot11e_qbss'] = dev_json['dot11.advertisedssid.dot11e_qbss']
 294             if "dot11.device.wpa_handshake_list" in dev_json:
 295                 newdev['dot11.device.wpa_handshake_list'] = dev_json['dot11.device.wpa_handshake_list']
 296             if "dot11.device.pmkid_packet" in dev_json:
 297                 newdev['dot11.device.pmkid_packet'] = dev_json['dot11.device.pmkid_packet']
 298             if "kismet.common.rrd.serial_time" in dev_json:
 299                 newdev['kismet.common.rrd.serial_time'] = dev_json['kismet.common.rrd.serial_time']
 300
 301             #print("====")
 302             #print(json.dumps(newdev))
 303             #print(dev_json['kismet.device.base.commonname'])
 304             #print("====")
 305             #dev_string = dev_string + dev + ","
 306             dev_string = dev_string + json.dumps(newdev) + ","
 307         dev_string = dev_string[:-1]
 308         dev_string = dev_string + "],\"draw\": "+draw+",\"recordsFiltered\": "+str(dev_count)+"}"
 309         return HttpResponse(dev_string, content_type='text/json')
 310     elif request.path == "/eventbus/events.ws":
 311         return HttpResponse("[]", content_type='text/json')
 312     elif request.path == "/phy/DOT/map_data.json":
 313         node_list = ""
 314         link_list = ""
 315         dev_list = list(load_db("select cast(device as text) from devices where phyname = 'IEEE802.11' and cast(device as text) like '%dot11.device.client_map%'"))
 316         for device in dev_list:
 317             (dev,) = device
 318             dev_json = json.loads(dev)
 319             newdev = {}
 320             node_list = node_list + "{ \"id\": \""+dev_json["kismet.device.base.macaddr"]+"\", \"label\": \""+dev_json["kismet.device.base.macaddr"]+"\", \"level\": 1},"
 321             for device in dev_json['dot11.device']['dot11.device.client_map']:
 322                 node_list = node_list + "{ \"id\": \""+device+"\", \"label\": \""+device+"\", \"level\": 2},"
 323                 link_list = link_list + "{ \"target\": \""+device+"\", \"source\": \""+dev_json["kismet.device.base.macaddr"]+"\" , \"strength\": 0.7 },"
 324         node_list = node_list[:-1]
 325         link_list = link_list[:-1]
 326         thang="{ \"nodes\": [" +node_list+"], \"links\": [" +link_list+"] }"
 327         return HttpResponse(thang, content_type='text/json')
 328     elif request.path == "/phy/RUSS/map_data.json":
 329         min_long = 361.0
 330         max_long = 0.0
 331         min_lat = 181.0
 332         max_lat = 0.0
 333         multikey = "{}"
 334         russlist = "{ \"kismet.wireless.map.devices\": [ "
 335         dev_list = list(load_db("select cast(device as text) from devices where (phyname = 'Bluetooth' or phyname = 'IEEE802.11') and cast(device as text) like '%kismet.common.location.geopoint%'"))
 336         for device in dev_list:
 337             (dev,) = device
 338             dev_json = json.loads(dev)
 339             newdev = {}
 340             newdev['kismet.device.base.first_time'] = dev_json['kismet.device.base.first_time']
 341             try:
 342               (tmp_min_long,tmp_min_lat) = dev_json['kismet.device.base.location']['kismet.common.location.min_loc']['kismet.common.location.geopoint']
 343               tmp_min_lat = round(tmp_min_lat + 91, 6)
 344               tmp_min_long = round(tmp_min_long + 181, 6)
 345               if (tmp_min_lat != 91 and tmp_min_long !=181):
 346                   if (tmp_min_lat < min_lat):
 347                       min_lat = tmp_min_lat
 348                   if (tmp_min_long < min_long):
 349                       min_long = tmp_min_long
 350               (tmp_max_long,tmp_max_lat) = dev_json['kismet.device.base.location']['kismet.common.location.max_loc']['kismet.common.location.geopoint']
 351               tmp_max_lat = round(tmp_max_lat + 91,6)
 352               tmp_max_long = round(tmp_max_long +181,6)
 353               if (tmp_max_lat != 91 and tmp_max_long !=181):
 354                   if (tmp_max_lat > max_lat):
 355                       max_lat = tmp_max_lat
 356                   if (tmp_max_long > max_long):
 357                       max_long = tmp_max_long
 358               russlist = russlist + str(dev_json['kismet.device.base.location']['kismet.common.location.avg_loc']['kismet.common.location.geopoint']) + ","
 359             except:
 360                 try:
 361                   (tmp_min_long,tmp_min_lat) = dev_json['dot11.device']['dot11.device.client_map']['dot11.client.location']['kismet.common.location.min_loc']['kismet.common.location.geopoint']
 362                   tmp_min_lat = round(tmp_min_lat + 91, 6)
 363                   tmp_min_long = round(tmp_min_long + 181, 6)
 364                   if (tmp_min_lat != 91 and tmp_min_long !=181):
 365                       if (tmp_min_lat < min_lat):
 366                          min_lat = tmp_min_lat
 367                       if (tmp_min_long < min_long):
 368                          min_long = tmp_min_long
 369                   (tmp_max_long,tmp_max_lat) = dev_json['dot11.device']['dot11.device.client_map']['dot11.client.location']['kismet.common.location.max_loc']['kismet.common.location.geopoint']
 370                   tmp_max_lat = round(tmp_max_lat + 91,6)
 371                   tmp_max_long = round(tmp_max_long +181,6)
 372                   if (tmp_max_lat != 91 and tmp_max_long !=181):
 373                       if (tmp_max_lat > max_lat):
 374                           max_lat = tmp_max_lat
 375                       if (tmp_max_long > max_long):
 376                           max_long = tmp_max_long
 377                   russlist = russlist + str(dev_json['dot11.device']['dot11.device.client_map']['dot11.client.location']['kismet.common.location.avg_loc']['kismet.common.location.geopoint']) + ","
 378                 except:
 379                   print("poop")
 380         russlist = russlist[:-1]
 381         min_lat = round(min_lat - 91, 6)
 382         min_long = round(min_long - 181, 6)
 383         max_lat = round(max_lat - 91, 6)
 384         max_long = round(max_long - 181, 6)
 385         russlist = russlist + " ], \"kismet.wireless.map.min_lon\": "+str(min_long) + ", \"kismet.wireless.map.max_lat\": "+str(max_lat)+", \"kismet.wireless.map.min_lat\": "+str(min_lat)+", \"kismet.wireless.map.max_lon\": "+str(max_long)+" }"
 386         return HttpResponse(russlist, content_type='text/json')
 387     elif request.path == "/devices/multikey/as-object/devices.json":
 388         #ClientMap incomplete.... figure out where the rest of the JSON comes from
 389         search_json = ""
 390         multikey = "{"
 391         for key, value in request.POST.items():
 392             search_json=json.loads(value)
 393             for device in search_json['devices']:
 394                 device_json = list(load_db("select cast(device as text) from devices where devkey='"+str(device)+"'"))
 395                 (tmp,) = device_json
 396                 device_json_x = json.loads(str(tmp[0]))
 397                 multikey = multikey + "\""+str(device)+"\": {"
 398                 for field in search_json['fields']:
 399                     if (field[0:6] == "kismet"):
 400                         multikey = multikey + "\""+field+"\": \""+device_json_x[field]+"\","
 401                 multikey = multikey + "\"dot11.device.client_map\": {},"
 402                 multikey = multikey[:-1]
 403                 multikey = multikey + "},"
 404         multikey = multikey[:-1]
 405         multikey = multikey + "}"
 406         return HttpResponse(multikey, content_type='text/json')
 407     elif request.path == "/phy/ADSB/map_data.json":
 408         #I had to do a stupid lat/long offset to draw the map grid because for some stupid reason python wouldnt do number scales right?
 409         #limiting to 100 until i figure out paging
 410         min_long = 361.0
 411         max_long = 0.0
 412         min_lat = 181.0
 413         max_lat = 0.0
 414         adsblist = "{ \"kismet.adsb.map.devices\": [ "
 415         dev_list = list(load_db("select cast(device as text) from devices where phyname = 'ADSB' limit 100"))
 416         for device in dev_list:
 417             (dev,) = device
 418             dev_json = json.loads(dev)
 419             newdev = {}
 420             newdev['kismet.device.base.first_time'] = dev_json['kismet.device.base.first_time']
 421             if "kismet.device.base.location" in dev_json:
 422                 newdev['kismet.device.base.location'] = dev_json['kismet.device.base.location']
 423                 (tmp_min_long,tmp_min_lat) = newdev['kismet.device.base.location']['kismet.common.location.min_loc']['kismet.common.location.geopoint']
 424                 tmp_min_lat = round(tmp_min_lat + 91, 6)
 425                 tmp_min_long = round(tmp_min_long + 181, 6)
 426                 if (tmp_min_lat != 91 and tmp_min_long !=181):
 427                   if (tmp_min_lat < min_lat):
 428                       min_lat = tmp_min_lat
 429                   if (tmp_min_long < min_long):
 430                       min_long = tmp_min_long
 431                 (tmp_max_long,tmp_max_lat) = newdev['kismet.device.base.location']['kismet.common.location.max_loc']['kismet.common.location.geopoint']
 432                 tmp_max_lat = round(tmp_max_lat + 91,6)
 433                 tmp_max_long = round(tmp_max_long +181,6)
 434                 if (tmp_max_lat != 91 and tmp_max_long !=181):
 435                     if (tmp_max_lat > max_lat):
 436                         max_lat = tmp_max_lat
 437                     if (tmp_max_long > max_long):
 438                         max_long = tmp_max_long
 439             newdev['kismet.device.base.macaddr'] = dev_json['kismet.device.base.macaddr']
 440             newdev['adsb.device'] = dev_json['adsb.device']
 441             newdev['kismet.device.base.type'] = dev_json['kismet.device.base.type']
 442             newdev['kismet.device.base.commonname'] = dev_json['kismet.device.base.commonname']
 443             newdev['kismet.device.base.name'] = dev_json['kismet.device.base.name']
 444             newdev['kismet.device.base.packets.data'] = dev_json['kismet.device.base.packets.data']
 445             newdev['kismet.device.base.frequency'] = dev_json['kismet.device.base.frequency']
 446             newdev['kismet.device.base.phyname'] = dev_json['kismet.device.base.phyname']
 447             newdev['kismet.device.base.last_time'] = dev_json['kismet.device.base.last_time']
 448             newdev['kismet.device.base.key'] = dev_json['kismet.device.base.key']
 449             adsblist = adsblist + json.dumps(newdev) + ","
 450         adsblist = adsblist[:-1]
 451         min_lat = round(min_lat - 91, 6)
 452         min_long = round(min_long - 181, 6)
 453         max_lat = round(max_lat - 91, 6)
 454         max_long = round(max_long - 181, 6)
 455         adsblist = adsblist + " ], \"kismet.adsb.map.min_lon\": "+str(min_long) + ", \"kismet.adsb.map.max_lat\": "+str(max_lat)+", \"kismet.adsb.map.min_lat\": "+str(min_lat)+", \"kismet.adsb.map.max_lon\": "+str(max_long)+" }"
 456         return HttpResponse(adsblist, content_type='text/json')