19425374606

Committed 17 Nov 2025 09:51AM UTC coverage: 34.54% (-0.007%) from 34.547%

Build # 19425374606

Build Type

push

github

Committed by

stephendade

Commit Message

Video server: RTSP server has seperate pipline for each client

Run Details

330 of 1234 branches covered (26.74%)

Branch coverage included in aggregate %.

1006 of 2634 relevant lines covered (38.19%)

2.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

8.8

/server/networkManager.js

const { exec, execSync, execFile } = require('child_process')

function getAdapters (callback) {
  // Get all network adapter name, type and states
  exec('sudo nmcli -t -f device,type,state dev', (error, stdout, stderr) => {
    const netStatusList = []
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      stdout.split('\n').forEach(function (item) {
        const device = item.split(':')
        if (device.length === 3 && device[1] !== 'loopback' && device[1] !== 'bridge' && device[1] !== 'wifi-p2p' && device[1] !== 'can0' && device[1] !== 'can1') {
          console.log('Adding Network device ' + device[0])
          // if wifi, check for avail channels
          const freqList = []
          freqList.push({ value: 0, freq: 0, label: 'auto', band: 0 })
          if (device[1] === 'wifi') {
            try {
              const output = execSync('iwlist ' + device[0] + ' channel')
              const allFreqs = output.toString().split('\n')
              for (let i = 0, len = allFreqs.length; i < len; i++) {
                if (allFreqs[i].includes('Channel ') && !allFreqs[i].includes('Current')) {
                  const ln = allFreqs[i].split(' ').filter(i => i)
                  if (ln.length > 4) {
                    freqList.push({ value: parseInt(ln[1]), freq: ln[3], label: '' + ln[1] + ' (' + ln[3] + ' GHz)', band: ((parseFloat(ln[3]) < 3) ? 'bg' : 'a') })
                  }
                }
              }
            } catch (e) {
              console.error('exec error: ' + e)
              return callback(e)
            }
          }
          netStatusList.push({ value: device[0], label: device[0] + ' (' + device[1] + ')', type: device[1], state: device[2], channels: freqList, isDisabled: !!((device[2] === 'unavailable' && device[1] === 'wifi')) })
        }
      })
    }
    return callback(null, netStatusList)
  })
}

function getWirelessStatus (callback) {
  // get the "flight mode" status of the wireless (wifi) adapters
  exec('sudo nmcli -t radio wifi', (error, stdout, stderr) => {
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      console.log('Wifi is ' + stdout)
      if (stdout === 'enabled\n') {
        return callback(null, true)
      } else {
        return callback(null, false)
      }
    }
  })
}

function setWirelessStatus (status, callback) {
  exec('sudo nmcli radio wifi ' + ((status === true) ? 'on' : 'off') + ' && sudo nmcli -t radio wifi', (error, stdout, stderr) => {
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      if (stdout === 'enabled\n') {
        return callback(null, true)
      } else {
        return callback(null, false)
      }
    }
  })
}

function activateConnection (conName, callback) {
  // activate the connection (by id)
  // assumed that conName is a valid UUID
  execFile('sudo', ['nmcli', 'connection', 'mod', conName, 'connection.autoconnect', 'yes'], (error, stdout, stderr) => {
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      execFile('sudo', ['nmcli', 'connection', 'up', conName], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Activated network: ' + conName)
          return callback(null, 'OK')
        }
      })
    }
  })
}

function deactivateConnection (conName, callback) {
  // deactivate the connection (by id)
  // assumed that conName is a valid UUID
  // need to disable auto-connect too
  execFile('sudo', ['nmcli', 'connection', 'mod', conName, 'connection.autoconnect', 'no'], (error, stdout, stderr) => {
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      execFile('sudo', ['nmcli', 'connection', 'down', conName], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Dectivated network: ' + conName)
          return callback(null, 'OK')
        }
      })
    }
  })
}

function getPrimaryWifiDevice(callback) {
  exec('iw dev | grep Interface | awk \'{print $2}\'', (error, stdout, stderr) => {
      if (error) {
          console.error(`exec error: ${error}`)
          return callback(error)
      }
      if (stderr) {
          console.error(`stderr: ${stderr}`)
          return callback(new Error(stderr))
      }
      const device = stdout.trim().split('\n')[0]
      callback(null, device)
  });
}

function getWifiScan(callback) {
  getPrimaryWifiDevice((error, device) => {
    if (error) {
      return callback(error)
    }

    exec(`sudo iw dev ${device} scan ap-force`, (error, stdout, stderr) => {
      if (error) {
        console.error(`exec error: ${error}`)
        return callback(error)
      }
      if (stderr) {
        console.error(`stderr: ${stderr}`)
        return callback(new Error(stderr))
      }

      const networks = [];
      let current = null;

      stdout.split("\n").forEach(line => {
        line = line.trim();

        if (line.startsWith("BSS ")) {
          if (current) networks.push(current);
          current = { ssid: null, signal: null, security: "Open" };
          return;
        }

        if (!current) return;

        if (line.startsWith("SSID:")) {
          current.ssid = line.slice(5).trim();
          // if not ascii, return
          if (!/^[\x00-\x7F]*$/.test(current.ssid)) {
            return;
          }
        }

        if (line.startsWith("signal:")) {
          const dBm = parseFloat(line.split(" ")[1]);
          current.signal = dBm;
        }

        if (line.includes("RSN:")) {
          current.security = "WPA2";
        } else if (line.includes("WPA:")) {
          current.security = "WPA";
        } else if (line.includes("WEP:")) {
          current.security = "WEP";
        }
      });
      if (current) networks.push(current);
      callback(null, networks
        .filter(net => net.ssid) // Filter out entries without SSID
        .sort((a, b) => b.signal - a.signal) // Sort by signal strength descending
      );
    });
  })
}

function addConnection (conNameStr, conType, conAdapter, conSettings, callback) {
  // add a new connection with name conNameStr and settings
  // conSettings
  // nmcli connection add type wifi ifname $IFNAME con-name $APNAME ssid $SSID
  // due to the multiple edits, we need to set autoconnect to "no"
  if (conType === 'wifi') {
    // Build nmcli command gradually for readability
    // Build argument array for nmcli command
    let nmcliArgs = ['connection', 'add', 'type', conType, 'ifname', conAdapter, 'con-name', conNameStr, 'ssid', conSettings.ssid, '802-11-wireless.mode', conSettings.mode];

    if (conSettings.band !== undefined && conSettings.band !== null) {
      nmcliArgs.push('802-11-wireless.band', conSettings.band);
    }

    if (conSettings.channel !== undefined && conSettings.channel !== null) {
      const channelValue = conSettings.channel === '0' ? '' : conSettings.channel;
      nmcliArgs.push('802-11-wireless.channel', channelValue);
    }

    nmcliArgs.push('ipv4.method', conSettings.ipaddresstype, 'connection.autoconnect', 'no');

    // run nmcli connection add safely
    execFile('sudo', ['nmcli', ...nmcliArgs], (error, stdout, stderr) => {
      if (error || stderr) {
        console.error(`execFile error: ${error || stderr}`);
        return callback(error || stderr);
      } else {
        // After connection added, get the connection UUID.
        execFile('sudo', ['nmcli', '-g', 'connection.uuid', 'con', 'show', conNameStr], (error2, stdout2, stderr2) => {
          if (error2 || stderr2) {
            console.error(`execFile error (uuid): ${error2 || stderr2}`);
            return callback(error2 || stderr2);
          } else {
            const conUUID = stdout2.split('\n')[stdout2.split('\n').length - 2];
            console.log('Added network Wifi: ' + conNameStr + ' - ' + conAdapter + ' - ' + conUUID);
            this.editConnection(conUUID, conSettings, (err) => {
              // set autoconnect back to "yes"
              execFile('sudo', ['nmcli', 'connection', 'mod', conUUID, 'connection.autoconnect', 'yes'], (error3, stdout3, stderr3) => {
                if (!err && !error3 && !stderr3) {
                  console.log('addConnection() wifi OK');
                  return callback(null, 'AddOK');
                } else {
                  console.log('Error in editConnection() wifi addcon ', { message: err });
                  console.log('Error in editConnection() wifi addcon ', { message: error3 || stderr3 });
                  return callback(err || error3 || stderr3);
                }
              });
            });
          }
        });
      }
    });
  } else {
    exec('sudo nmcli connection add type ' + conType + ' ifname ' + conAdapter +
             ' con-name ' + conNameStr + ' connection.autoconnect no ' + '&&' +
             'sudo nmcli -g connection.uuid con show ' + conNameStr, (error, stdout, stderr) => {
      if (stderr) {
        console.error(`exec error: ${error}`)
        return callback(stderr)
      } else {
        // once the network is created, add in the settings
        const conUUID = stdout.split('\n')[stdout.split('\n').length - 2]
        console.log('Added network Wired: ' + conNameStr + ' - ' + conAdapter + ' - ' + conUUID)
        this.editConnection(conUUID, conSettings, (err) => {
          // set autoconnect back to "yes"
          exec('sudo nmcli connection mod ' + conUUID + ' connection.autoconnect yes', (error, stdout, stderr) => {
            if (!err && !stderr) {
              console.log('addConnection() wired OK')
              return callback(null, 'AddOK')
            } else {
              console.log('Error in editConnection() wired addcon ', { message: err })
              console.log('Error in editConnection() wired addcon ', { message: stderr })
              return callback(err)
            }
          })
        })
      }
    })
  }
}

function editConnection (conName, conSettings, callback) {
  // edit an existing connection
  // assumed that conName is a valid UUID
  // there are 4 types of edits - AttachedInterface, IP, Wifi security, Wifi AP
  // small amount of callback hell here :(
  console.log(conSettings)
  editConnectionAttached(conName, conSettings, (errAttach) => {
    console.log('Attach')
    if (!errAttach) {
      editConnectionIP(conName, conSettings, (errIP) => {
        console.log('IP')
        if (!errIP) {
          editConnectionPSK(conName, conSettings, (errPSK) => {
            console.log('PSK')
            if (!errPSK) {
              editConnectionAPClient(conName, conSettings, (errAP) => {
                console.log('AP')
                if (!errAP) {
                  return callback(null, 'EditOK')
                } else {
                  return callback(errAP)
                }
              })
            } else {
              console.log('Error in editConnection() errPSK ', { message: errPSK })
              return callback(errPSK)
            }
          })
        } else {
          console.log('Error in editConnection() errIP ', { message: errIP })
          return callback(errIP)
        }
      })
    } else {
      console.log('Error in editConnection() errAttach ', { message: errAttach })
      return callback(errAttach)
    }
  })
}

function editConnectionAttached (conName, conSettings, callback) {
  // edit the attached interface for a connection
  if (conSettings.attachedIface === '&quot;&quot;' || conSettings.attachedIface === 'undefined') {
    conSettings.attachedIface = '""'
  }

  execFile('sudo', ['nmcli', 'connection', 'mod', conName, 'connection.interface-name', conSettings.attachedIface], (error, stdout, stderr) => {
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      console.log('Edited network Attachment: ' + conName + ' to ' + conSettings.attachedIface)
      return callback(null, 'EditAttachOK')
    }
  })
}

function editConnectionIP (conName, conSettings, callback) {
  // first sort out the IP Addressing (DHCP/static) for LAN and Wifi Client
  if (Object.keys(conSettings.ssid).length === 0 || conSettings.mode === 'infrastructure') {
    if (conSettings.ipaddresstype === 'auto') {
      execFile('sudo', ['nmcli', 'connection', 'mod', conName, 'ipv4.method', 'auto', 'ipv4.addresses', ''], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Edited network IP Auto: ' + conName)
          return callback(null, 'EditOK')
        }
      })
    } else if (Object.keys(conSettings.ipaddress).length !== 0 && Object.keys(conSettings.subnet).length !== 0) {
      execFile('sudo', ['nmcli', 'connection', 'mod', conName, 'ipv4.addresses', conSettings.ipaddress + '/' +
        netmask2CIDR(conSettings.subnet), 'ipv4.method', conSettings.ipaddresstype], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Edited network IP manual: ' + conName)
          return callback(null, 'EditOK')
        }
      })
    }
  } else {
    console.log('editConnectionIP() not required')
    return callback(null, 'EditNotRequired')
  }
}

function editConnectionPSK (conName, conSettings, callback) {
  // now sort out Wifi client/ap settings - password and security type
  if (Object.keys(conSettings.mode).length === 0) {
    return callback(null, 'EditNotRequired')
  }
  if (conSettings.mode === 'infrastructure' || conSettings.mode === 'ap') {
    // psk network
    if (conSettings.wpaType !== 'none' &&
            Object.keys(conSettings.ssid).length !== 0 &&
            Object.keys(conSettings.password).length !== 0) {
            execFile('sudo', ['nmcli', 'connection', 'mod', conName, '802-11-wireless-security.key-mgmt', conSettings.wpaType], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          execFile('sudo', ['nmcli', '-s', 'connection', 'mod', conName, '802-11-wireless-security.pairwise', 'ccmp', '802-11-wireless-security.psk', conSettings.password], (error, stdout, stderr) => {
            if (stderr) {
              console.error(`exec error: ${error}`)
              return callback(stderr)
            } else {
              console.log('Edited Wifi psk: ' + conName)
              return callback(null, 'OK')
            }
          })
        }
      })
    }
    else if (conSettings.wpaType === 'none' &&
                 Object.keys(conSettings.ssid).length !== 0) {
      execFile('sudo', ['nmcli', 'connection', 'mod', conName, 'remove', '802-11-wireless-security'], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Edited Wifi no-psk: ' + conName)
          return callback(null, 'OK')
        }
      })
    }
  } else {
    console.log('editConnectionPSK() not required')
    return callback(null, 'EditNotRequired')
  }
}

function editConnectionAPClient (conName, conSettings, callback) {
  // now sort out Wifi ap or client settings - ssid, band, starting ip
  if (Object.keys(conSettings.mode).length === 0) {
    return callback(null, 'EditNotRequired')
  }
  if (conSettings.mode === 'ap') {
    if (Object.keys(conSettings.ssid).length !== 0 &&
            Object.keys(conSettings.band).length !== 0 &&
            Object.keys(conSettings.channel).length !== 0 &&
            Object.keys(conSettings.ipaddress).length !== 0) {
      const cmds = ['nmcli', 'connection', 'mod', conName, '802-11-wireless.ssid', conSettings.ssid,
        '802-11-wireless.band', conSettings.band, 'ipv4.addresses', conSettings.ipaddress + '/24']
      if (conSettings.channel !== '0') {
        cmds.push('802-11-wireless.channel', conSettings.channel)
      }
      if (conSettings.wpaType !== 'none') {
        cmds.push('802-11-wireless-security.group', 'ccmp', '802-11-wireless-security.wps-method', '1')
      }
      execFile('sudo', cmds, (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Edited Wifi ap ssid/band: ' + conName)
          return callback(null, 'OK')
        }
      })
    } else {
      console.log('Badsettings in editConnectionAPClient')
      console.log(conSettings)
      return callback(null, 'BADARGS')
    }
  } else {
    // client connection - edit ssid if required
    if (Object.keys(conSettings.ssid).length !== 0) {
      execFile('sudo', ['nmcli', 'connection', 'mod', conName, '802-11-wireless.ssid', conSettings.ssid], (error, stdout, stderr) => {
        if (stderr) {
          console.error(`exec error: ${error}`)
          return callback(stderr)
        } else {
          console.log('Edited Wifi client ssid: ' + conName)
          return callback(null, 'OK')
        }
      })
    } else {
      console.log('Badsettings in editConnectionAPClient')
      console.log(conSettings)
      return callback(null, 'BADARGS')
    }
  }
}

function deleteConnection (conName, callback) {
  // delete the connection (by id)
  // assumed that conName is a valid UUID
  execFile('sudo', ['nmcli', 'connection', 'delete', conName], (error, stdout, stderr) => {
    if (stderr) {
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      console.log('Deleted network: ' + conName)
      return callback(null, 'OK')
    }
  })
}

function getConnections (callback) {
  let output = ''
  const conStatusList = []
  try {
    output = execSync('sudo nmcli -t -f NAME,UUID,TYPE,DEVICE connection show')
  } catch (e) {
    console.error('exec error: ' + e)
    return callback(e)
  }

  const allConns = output.toString().split('\n')
  for (let i = 0, len = allConns.length; i < len; i++) {
    const item = allConns[i]
    const connection = item.split(':')
    let curConn = {}
    let subout = ''
    if (connection.length == 4 || connection.length == 3) {
      try {
        subout = execSync('sudo nmcli -s -t -f connection.interface-name connection show ' + connection[1])
        subout = subout.toString().split(':')[1].trim()
      } catch (e) {
        console.error('exec error: ' + e)
        // return callback("");
      }
    }
    if (connection[3] === '' || connection[3] === '--') {
      curConn = { value: connection[1], label: '', labelPre: connection[0], type: connection[2], state: '', attachedIface: subout }
      conStatusList.push(curConn)
    } else if (connection.length === 4) {
      // active connection
      curConn = { value: connection[1], label: '', labelPre: connection[0], type: connection[2], state: connection[3], attachedIface: subout }
      conStatusList.push(curConn)
    }
    // if we're at the end, return callback
    if (i === allConns.length - 1) {
      console.log('getConnections() got: ' + allConns.length)
      return callback(null, conStatusList)
    }
  }
}

function getConnectionDetails (conName, callback) {
  execFile('sudo', ['nmcli', '-s', '-t', '-f', 'ipv4.addresses,802-11-wireless.band,ipv4.method,IP4.ADDRESS,802-11-wireless.ssid,802-11-wireless.mode,802-11-wireless-security.key-mgmt,802-11-wireless-security.psk,connection.interface-name,802-11-wireless.channel', 'connection', 'show', conName], (error, stdout, stderr) => {
    if (stderr) {
      // no connection with that name
      console.error(`exec error: ${error}`)
      return callback(stderr)
    } else {
      const ret = { DHCP: 'auto', IP: '', subnet: '', mode: '', wpaType: 'none', password: '' }
      stdout.split('\n').forEach(function (item) {
        if (item.split(':')[0] === '802-11-wireless.ssid') {
          ret.ssid = item.split(':')[1]
        } else if (item.split(':')[0] === '802-11-wireless.band') {
          if (item.split(':')[1] === '') {
            ret.band = 'bg'
          } else {
            ret.band = item.split(':')[1]
          }
        } else if (item.split(':')[0] === 'ipv4.method') {
          ret.DHCP = item.split(':')[1]
        }
        // DHCP IP, if using DHCP
        else if (item.split(':')[0] === 'IP4.ADDRESS[1]' && item.split(':').length > 1 && item.split(':')[1] !== '') {
          ret.IP = item.split(':')[1].split('/')[0]
          ret.subnet = CIDR2netmask(item.split(':')[1].split('/')[1])
        }
        // static IP
        else if (item.split(':')[0] === 'ipv4.addresses' && item.split(':').length > 1 && item.split(':')[1] !== '') {
          ret.IP = item.split(':')[1].split('/')[0]
          ret.subnet = CIDR2netmask(item.split(':')[1].split('/')[1])
        } else if (item.split(':')[0] === '802-11-wireless.mode') {
          ret.mode = item.split(':')[1]
        } else if (item.split(':')[0] === '802-11-wireless-security.key-mgmt') {
          ret.wpaType = item.split(':')[1]
        } else if (item.split(':')[0] === '802-11-wireless-security.psk') {
          ret.password = item.split(':')[1]
        } else if (item.split(':')[0] === 'connection.interface-name') {
          ret.attachedIface = item.split(':')[1]
        } else if (item.split(':')[0] === '802-11-wireless.channel') {
          ret.channel = item.split(':')[1]
        }
      })
      return callback(null, ret)
    }
  })
}

function CIDR2netmask (bitCountstr) {
  const mask = []
  let bitCount = parseInt(bitCountstr)
  // console.log(bitCountstr);
  for (let i = 0; i < 4; i++) {
    const n = Math.min(bitCount, 8)
    // console.log(bitCount);
    mask.push(256 - Math.pow(2, 8 - n))
    bitCount -= n
  }
  return mask.join('.')
}

function netmask2CIDR (mask) {
  let cidr = ''
  for (const m of mask.split('.')) {
    if (parseInt(m) > 255) { throw 'ERROR: Invalid Netmask' } // Check each group is 0-255
    if (parseInt(m) > 0 && parseInt(m) < 128) { throw 'ERROR: Invalid Netmask' }

    cidr += (m >>> 0).toString(2)
  }
  // Condition to check for validity of the netmask
  if (cidr.substring(cidr.search('0'), 32).search('1') !== -1) {
    console.log('Error in netmask2CIDR() ', { message: mask })
    throw 'ERROR: Invalid Netmask ' + mask
  }
  return cidr.split('1').length - 1
}

module.exports = {
  getAdapters,
  getConnections,
  getConnectionDetails,
  activateConnection,
  deleteConnection,
  editConnection,
  addConnection,
  deactivateConnection,
  getWirelessStatus,
  setWirelessStatus,
  getWifiScan
}

stephendade / Rpanion-server / 19425374606

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous