package/network/services/hostapd/files/wpa_supplicant.uc

   1 let libubus = require("ubus");
   2 import { open, readfile } from "fs";
   3 import { wdev_create, wdev_set_mesh_params, wdev_remove, is_equal, wdev_set_up, vlist_new, phy_open } from "common";
   4
   5 let ubus = libubus.connect();
   6
   7 wpas.data.config = {};
   8 wpas.data.iface_phy = {};
   9 wpas.data.macaddr_list = {};
  10
  11 function iface_stop(iface)
  12 {
  13         let ifname = iface.config.iface;
  14
  15         if (!iface.running)
  16                 return;
  17
  18         delete wpas.data.iface_phy[ifname];
  19         wpas.remove_iface(ifname);
  20         wdev_remove(ifname);
  21         iface.running = false;
  22 }
  23
  24 function iface_start(phydev, iface, macaddr_list)
  25 {
  26         let phy = phydev.name;
  27
  28         if (iface.running)
  29                 return;
  30
  31         let ifname = iface.config.iface;
  32         let wdev_config = {};
  33         for (let field in iface.config)
  34                 wdev_config[field] = iface.config[field];
  35         if (!wdev_config.macaddr)
  36                 wdev_config.macaddr = phydev.macaddr_next();
  37
  38         wpas.data.iface_phy[ifname] = phy;
  39         wdev_remove(ifname);
  40         let ret = wdev_create(phy, ifname, wdev_config);
  41         if (ret)
  42                 wpas.printf(`Failed to create device ${ifname}: ${ret}`);
  43         wdev_set_up(ifname, true);
  44         wpas.add_iface(iface.config);
  45         iface.running = true;
  46 }
  47
  48 function iface_cb(new_if, old_if)
  49 {
  50         if (old_if && new_if && is_equal(old_if.config, new_if.config)) {
  51                 new_if.running = old_if.running;
  52                 return;
  53         }
  54
  55         if (new_if && old_if)
  56                 wpas.printf(`Update configuration for interface ${old_if.config.iface}`);
  57         else if (old_if)
  58                 wpas.printf(`Remove interface ${old_if.config.iface}`);
  59
  60         if (old_if)
  61                 iface_stop(old_if);
  62 }
  63
  64 function prepare_config(config)
  65 {
  66         config.config_data = readfile(config.config);
  67
  68         return { config: config };
  69 }
  70
  71 function set_config(phy_name, config_list)
  72 {
  73         let phy = wpas.data.config[phy_name];
  74
  75         if (!phy) {
  76                 phy = vlist_new(iface_cb, false);
  77                 wpas.data.config[phy_name] = phy;
  78         }
  79
  80         let values = [];
  81         for (let config in config_list)
  82                 push(values, [ config.iface, prepare_config(config) ]);
  83
  84         phy.update(values);
  85 }
  86
  87 function start_pending(phy_name)
  88 {
  89         let phy = wpas.data.config[phy_name];
  90         let ubus = wpas.data.ubus;
  91
  92         if (!phy || !phy.data)
  93                 return;
  94
  95         let phydev = phy_open(phy_name);
  96         if (!phydev) {
  97                 wpas.printf(`Could not open phy ${phy_name}`);
  98                 return;
  99         }
 100
 101         let macaddr_list = wpas.data.macaddr_list[phy_name];
 102         phydev.macaddr_init(macaddr_list);
 103
 104         for (let ifname in phy.data)
 105                 iface_start(phydev, phy.data[ifname]);
 106 }
 107
 108 let main_obj = {
 109         phy_set_state: {
 110                 args: {
 111                         phy: "",
 112                         stop: true,
 113                 },
 114                 call: function(req) {
 115                         if (!req.args.phy || req.args.stop == null)
 116                                 return libubus.STATUS_INVALID_ARGUMENT;
 117
 118                         let phy = wpas.data.config[req.args.phy];
 119                         if (!phy)
 120                                 return libubus.STATUS_NOT_FOUND;
 121
 122                         try {
 123                                 if (req.args.stop) {
 124                                         for (let ifname in phy.data)
 125                                                 iface_stop(phy.data[ifname]);
 126                                 } else {
 127                                         start_pending(req.args.phy);
 128                                 }
 129                         } catch (e) {
 130                                 wpas.printf(`Error chaging state: ${e}\n${e.stacktrace[0].context}`);
 131                                 return libubus.STATUS_INVALID_ARGUMENT;
 132                         }
 133                         return 0;
 134                 }
 135         },
 136         phy_set_macaddr_list: {
 137                 args: {
 138                         phy: "",
 139                         macaddr: [],
 140                 },
 141                 call: function(req) {
 142                         let phy = req.args.phy;
 143                         if (!phy)
 144                                 return libubus.STATUS_INVALID_ARGUMENT;
 145
 146                         wpas.data.macaddr_list[phy] = req.args.macaddr;
 147                         return 0;
 148                 }
 149         },
 150         phy_status: {
 151                 args: {
 152                         phy: ""
 153                 },
 154                 call: function(req) {
 155                         if (!req.args.phy)
 156                                 return libubus.STATUS_INVALID_ARGUMENT;
 157
 158                         let phy = wpas.data.config[req.args.phy];
 159                         if (!phy)
 160                                 return libubus.STATUS_NOT_FOUND;
 161
 162                         for (let ifname in phy.data) {
 163                                 try {
 164                                         let iface = wpas.interfaces[ifname];
 165                                         if (!iface)
 166                                                 continue;
 167
 168                                         let status = iface.status();
 169                                         if (!status)
 170                                                 continue;
 171
 172                                         if (status.state == "INTERFACE_DISABLED")
 173                                                 continue;
 174
 175                                         status.ifname = ifname;
 176                                         return status;
 177                                 } catch (e) {
 178                                         continue;
 179                                 }
 180                         }
 181
 182                         return libubus.STATUS_NOT_FOUND;
 183                 }
 184         },
 185         config_set: {
 186                 args: {
 187                         phy: "",
 188                         config: [],
 189                         defer: true,
 190                 },
 191                 call: function(req) {
 192                         if (!req.args.phy)
 193                                 return libubus.STATUS_INVALID_ARGUMENT;
 194
 195                         wpas.printf(`Set new config for phy ${req.args.phy}`);
 196                         try {
 197                                 if (req.args.config)
 198                                         set_config(req.args.phy, req.args.config);
 199
 200                                 if (!req.args.defer)
 201                                         start_pending(req.args.phy);
 202                         } catch (e) {
 203                                 wpas.printf(`Error loading config: ${e}\n${e.stacktrace[0].context}`);
 204                                 return libubus.STATUS_INVALID_ARGUMENT;
 205                         }
 206
 207                         return {
 208                                 pid: wpas.getpid()
 209                         };
 210                 }
 211         },
 212         config_add: {
 213                 args: {
 214                         driver: "",
 215                         iface: "",
 216                         bridge: "",
 217                         hostapd_ctrl: "",
 218                         ctrl: "",
 219                         config: "",
 220                 },
 221                 call: function(req) {
 222                         if (!req.args.iface || !req.args.config)
 223                                 return libubus.STATUS_INVALID_ARGUMENT;
 224
 225                         if (wpas.add_iface(req.args) < 0)
 226                                 return libubus.STATUS_INVALID_ARGUMENT;
 227
 228                         return {
 229                                 pid: wpas.getpid()
 230                         };
 231                 }
 232         },
 233         config_remove: {
 234                 args: {
 235                         iface: ""
 236                 },
 237                 call: function(req) {
 238                         if (!req.args.iface)
 239                                 return libubus.STATUS_INVALID_ARGUMENT;
 240
 241                         wpas.remove_iface(req.args.iface);
 242                         return 0;
 243                 }
 244         },
 245 };
 246
 247 function handle_debug_config(cfg) {
 248         if (!cfg)
 249                 return;
 250
 251         let data = cfg.service;
 252         if (!data)
 253                 return;
 254
 255         data = data.wpa_supplicant;
 256         if (!data)
 257                 return;
 258
 259         wpas.udebug_set(!!+data.enabled);
 260 }
 261
 262 wpas.data.ubus = ubus;
 263 wpas.data.obj = ubus.publish("wpa_supplicant", main_obj);
 264 wpas.data.debug_sub = ubus.subscriber((req) => {
 265         if (req.type != "config")
 266                 return;
 267
 268         handle_debug_config(req.data);
 269 });
 270
 271 wpas.data.debug_sub.subscribe("udebug");
 272 handle_debug_config(ubus.call("udebug", "get_config", {}));
 273
 274 function iface_event(type, name, data) {
 275         let ubus = wpas.data.ubus;
 276
 277         data ??= {};
 278         data.name = name;
 279         wpas.data.obj.notify(`iface.${type}`, data, null, null, null, -1);
 280         ubus.call("service", "event", { type: `wpa_supplicant.${name}.${type}`, data: {} });
 281 }
 282
 283 function iface_hostapd_notify(phy, ifname, iface, state)
 284 {
 285         let ubus = wpas.data.ubus;
 286         let status = iface.status();
 287         let msg = { phy: phy };
 288
 289         switch (state) {
 290         case "DISCONNECTED":
 291         case "AUTHENTICATING":
 292         case "SCANNING":
 293                 msg.up = false;
 294                 break;
 295         case "INTERFACE_DISABLED":
 296         case "INACTIVE":
 297                 msg.up = true;
 298                 break;
 299         case "COMPLETED":
 300                 msg.up = true;
 301                 msg.frequency = status.frequency;
 302                 msg.sec_chan_offset = status.sec_chan_offset;
 303                 break;
 304         default:
 305                 return;
 306         }
 307
 308         ubus.call("hostapd", "apsta_state", msg);
 309 }
 310
 311 function iface_channel_switch(phy, ifname, iface, info)
 312 {
 313         let msg = {
 314                 phy: phy,
 315                 up: true,
 316                 csa: true,
 317                 csa_count: info.csa_count ? info.csa_count - 1 : 0,
 318                 frequency: info.frequency,
 319                 sec_chan_offset: info.sec_chan_offset,
 320         };
 321         ubus.call("hostapd", "apsta_state", msg);
 322 }
 323
 324 return {
 325         shutdown: function() {
 326                 for (let phy in wpas.data.config)
 327                         set_config(phy, []);
 328                 wpas.ubus.disconnect();
 329         },
 330         iface_add: function(name, obj) {
 331                 iface_event("add", name);
 332         },
 333         iface_remove: function(name, obj) {
 334                 iface_event("remove", name);
 335         },
 336         state: function(ifname, iface, state) {
 337                 let phy = wpas.data.iface_phy[ifname];
 338                 if (!phy) {
 339                         wpas.printf(`no PHY for ifname ${ifname}`);
 340                         return;
 341                 }
 342
 343                 iface_hostapd_notify(phy, ifname, iface, state);
 344
 345                 if (state != "COMPLETED")
 346                         return;
 347
 348                 let phy_data = wpas.data.config[phy];
 349                 if (!phy_data)
 350                         return;
 351
 352                 let iface_data = phy_data.data[ifname];
 353                 if (!iface_data)
 354                         return;
 355
 356                 let wdev_config = iface_data.config;
 357                 if (!wdev_config || wdev_config.mode != "mesh")
 358                         return;
 359
 360                 wdev_set_mesh_params(ifname, wdev_config);
 361         },
 362         event: function(ifname, iface, ev, info) {
 363                 let phy = wpas.data.iface_phy[ifname];
 364                 if (!phy) {
 365                         wpas.printf(`no PHY for ifname ${ifname}`);
 366                         return;
 367                 }
 368
 369                 if (ev == "CH_SWITCH_STARTED")
 370                         iface_channel_switch(phy, ifname, iface, info);
 371         }
 372 };