Crash_Override
/
FreeDATA
mirror of https://github.com/DJ2LS/FreeDATA
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
FreeDATA/gui/sock.js

750 lines
21 KiB
JavaScript
Raw Blame History

var net = require("net");
const path = require("path");
const { ipcRenderer } = require("electron");
const log = require("electron-log");
const socketLog = log.scope("tnc");
const utf8 = require("utf8");
// https://stackoverflow.com/a/26227660
var appDataFolder =
process.env.APPDATA ||
(process.platform == "darwin"
? process.env.HOME + "/Library/Application Support"
: process.env.HOME + "/.config");
var configFolder = path.join(appDataFolder, "FreeDATA");
var configPath = path.join(configFolder, "config.json");
const config = require(configPath);
var client = new net.Socket();
var socketchunk = ""; // Current message, per connection.
// split character
const split_char = "\0;\1;";
// globals for getting new data only if available so we are saving bandwidth
var rxBufferLengthTnc = 0;
var rxBufferLengthGui = 0;
var rxMsgBufferLengthTnc = 0;
var rxMsgBufferLengthGui = 0;
// global to keep track of TNC connection error emissions
var tncShowConnectStateError = 1;
// global for storing ip information
var tnc_port = config.tnc_port;
var tnc_host = config.tnc_host;
// network connection Timeout
setTimeout(connectTNC, 2000);
function connectTNC() {
//exports.connectTNC = function(){
//socketLog.info('connecting to TNC...')
//clear message buffer after reconnecting or initial connection
socketchunk = "";
if (config.tnclocation == "localhost") {
client.connect(3000, "127.0.0.1");
} else {
client.connect(tnc_port, tnc_host);
}
}
client.on("connect", function (data) {
socketLog.info("TNC connection established");
let Data = {
busy_state: "-",
arq_state: "-",
//channel_state: "-",
frequency: "-",
mode: "-",
bandwidth: "-",
dbfs_level: 0,
};
ipcRenderer.send("request-update-tnc-state", Data);
// also update tnc connection state
ipcRenderer.send("request-update-tnc-connection", {
tnc_connection: client.readyState,
});
tncShowConnectStateError = 1;
});
client.on("error", function (data) {
if (tncShowConnectStateError == 1) {
socketLog.error("TNC connection error");
socketLog.info("TNC is started by the GUI process.");
socketLog.debug(data);
// setTimeout( function() { exports.connectTNC(tnc_host, tnc_port); }, 2000 );
tncShowConnectStateError = 0;
}
setTimeout(connectTNC, 500);
client.destroy();
let Data = {
tnc_connection: client.readyState,
busy_state: "-",
arq_state: "-",
//channel_state: "-",
frequency: "-",
mode: "-",
bandwidth: "-",
dbfs_level: 0,
};
ipcRenderer.send("request-update-tnc-state", Data);
ipcRenderer.send("request-update-tnc-connection", {
tnc_connection: client.readyState,
});
});
/*
client.on('close', function(data) {
socketLog.info(' TNC connection closed');
setTimeout(connectTNC, 2000)
});
*/
client.on("end", function (data) {
socketLog.info("TNC connection ended");
ipcRenderer.send("request-update-tnc-connection", {
tnc_connection: client.readyState,
});
client.destroy();
setTimeout(connectTNC, 500);
});
writeTncCommand = function (command) {
//socketLog.info(command)
// we use the writingCommand function to update our TCPIP state because we are calling this function a lot
// if socket opened, we are able to run commands
if (client.readyState == "open") {
client.write(command + "\n");
}
if (client.readyState == "closed") {
socketLog.info("CLOSED!");
}
if (client.readyState == "opening") {
socketLog.info("connecting to TNC...");
}
};
client.on("data", function (socketdata) {
ipcRenderer.send("request-update-tnc-connection", {
tnc_connection: client.readyState,
});
/*
inspired by:
stackoverflow.com questions 9070700 nodejs-net-createserver-large-amount-of-data-coming-in
*/
socketdata = socketdata.toString("utf8"); // convert data to string
socketchunk += socketdata; // append data to buffer so we can stick long data together
// check if we received begin and end of json data
if (socketchunk.startsWith('{"') && socketchunk.endsWith('"}\n')) {
var data = "";
// split data into chunks if we received multiple commands
socketchunk = socketchunk.split("\n");
//don't think this is needed anymore
//data = JSON.parse(socketchunk[0])
// search for empty entries in socketchunk and remove them
for (i = 0; i < socketchunk.length; i++) {
if (socketchunk[i] === "") {
socketchunk.splice(i, 1);
}
}
//iterate through socketchunks array to execute multiple commands in row
for (i = 0; i < socketchunk.length; i++) {
//check if data is not empty
if (socketchunk[i].length > 0) {
//try to parse JSON
try {
data = JSON.parse(socketchunk[i]);
} catch (e) {
socketLog.info(e); // "SyntaxError
socketLog.info(socketchunk[i]);
socketchunk = "";
}
}
if (data["command"] == "tnc_state") {
//socketLog.info(data)
// set length of RX Buffer to global variable
rxBufferLengthTnc = data["rx_buffer_length"];
rxMsgBufferLengthTnc = data["rx_msg_buffer_length"];
let Data = {
mycallsign: data["mycallsign"],
mygrid: data["mygrid"],
ptt_state: data["ptt_state"],
busy_state: data["tnc_state"],
arq_state: data["arq_state"],
arq_session: data["arq_session"],
//channel_state: data['CHANNEL_STATE'],
frequency: data["frequency"],
speed_level: data["speed_level"],
mode: data["mode"],
bandwidth: data["bandwidth"],
dbfs_level: data["audio_dbfs"],
fft: data["fft"],
channel_busy: data["channel_busy"],
scatter: data["scatter"],
info: data["info"],
rx_buffer_length: data["rx_buffer_length"],
rx_msg_buffer_length: data["rx_msg_buffer_length"],
tx_n_max_retries: data["tx_n_max_retries"],
arq_tx_n_frames_per_burst: data["arq_tx_n_frames_per_burst"],
arq_tx_n_bursts: data["arq_tx_n_bursts"],
arq_tx_n_current_arq_frame: data["arq_tx_n_current_arq_frame"],
arq_tx_n_total_arq_frames: data["arq_tx_n_total_arq_frames"],
arq_rx_frame_n_bursts: data["arq_rx_frame_n_bursts"],
arq_rx_n_current_arq_frame: data["arq_rx_n_current_arq_frame"],
arq_n_arq_frames_per_data_frame:
data["arq_n_arq_frames_per_data_frame"],
arq_bytes_per_minute: data["arq_bytes_per_minute"],
arq_seconds_until_finish: data["arq_seconds_until_finish"],
arq_compression_factor: data["arq_compression_factor"],
total_bytes: data["total_bytes"],
arq_transmission_percent: data["arq_transmission_percent"],
stations: data["stations"],
beacon_state: data["beacon_state"],
hamlib_status: data["hamlib_status"],
listen: data["listen"],
audio_recording: data["audio_recording"],
speed_list: data["speed_list"],
//speed_table: [{"bpm" : 5200, "snr": -3, "timestamp":1673555399},{"bpm" : 2315, "snr": 12, "timestamp":1673555500}],
};
ipcRenderer.send("request-update-tnc-state", Data);
//continue to next for loop iteration, nothing else needs to be done here
continue;
}
// ----------- catch tnc messages START -----------
if (data["freedata"] == "tnc-message") {
// update transmission status
/*
if (data['arq'] == 'transmission' && data['status'] == 'transmitting'){
let state = {
status: data['status'],
uuid: data['uuid'],
percent: data['percent'],
bytesperminute: data['bytesperminute'],
};
ipcRenderer.send('request-update-transmission-status', state);
}
*/
// CQ TRANSMITTING
if (data["cq"] == "transmitting") {
ipcRenderer.send("request-show-cq-toast-transmitting", {
data: [data],
});
}
// CQ RECEIVED
if (data["cq"] == "received") {
ipcRenderer.send("request-show-cq-toast-received", { data: [data] });
}
// QRV TRANSMITTING
if (data["qrv"] == "transmitting") {
ipcRenderer.send("request-show-qrv-toast-transmitting", {
data: [data],
});
}
// QRV RECEIVED
if (data["qrv"] == "received") {
ipcRenderer.send("request-show-qrv-toast-received", { data: [data] });
}
// BEACON TRANSMITTING
if (data["beacon"] == "transmitting") {
ipcRenderer.send("request-show-beacon-toast-transmitting", {
data: [data],
});
}
// BEACON RECEIVED
if (data["beacon"] == "received") {
ipcRenderer.send("request-show-beacon-toast-received", {
data: [data],
});
ipcRenderer.send("request-new-msg-received", { data: [data] });
}
// PING TRANSMITTING
if (data["ping"] == "transmitting") {
ipcRenderer.send("request-show-ping-toast-transmitting", {
data: [data],
});
}
// PING RECEIVED
if (data["ping"] == "received") {
ipcRenderer.send("request-show-ping-toast-received", {
data: [data],
});
ipcRenderer.send("request-new-msg-received", { data: [data] });
}
// PING ACKNOWLEDGE
if (data["ping"] == "acknowledge") {
ipcRenderer.send("request-show-ping-toast-received-ack", {
data: [data],
});
ipcRenderer.send("request-new-msg-received", { data: [data] });
}
// ARQ SESSION
if (data["arq"] == "session") {
// ARQ OPEN
if (data["status"] == "connecting") {
ipcRenderer.send("request-show-arq-toast-session-connecting", {
data: [data],
});
// ARQ OPENING
} else if (data["status"] == "connected") {
ipcRenderer.send("request-show-arq-toast-session-connected", {
data: [data],
});
// ARQ OPENING
} else if (data["status"] == "waiting") {
ipcRenderer.send("request-show-arq-toast-session-waiting", {
data: [data],
});
// ARQ OPENING
} else if (data["status"] == "close") {
ipcRenderer.send("request-show-arq-toast-session-close", {
data: [data],
});
// ARQ OPENING
} else if (data["status"] == "failed") {
ipcRenderer.send("request-show-arq-toast-session-failed", {
data: [data],
});
}
}
// ARQ TRANSMISSION
if (data["arq"] == "transmission") {
// ARQ OPEN
if (data["status"] == "opened") {
ipcRenderer.send("request-show-arq-toast-datachannel-opened", {
data: [data],
});
// ARQ OPENING ISS
} else if (data["status"] == "opening" && data["irs"] == "False") {
ipcRenderer.send("request-show-arq-toast-datachannel-opening", {
data: [data],
});
// ARQ OPENING IRS
} else if (data["status"] == "opening" && data["irs"] == "True") {
ipcRenderer.send(
"request-show-arq-toast-datachannel-received-opener",
{ data: [data] }
);
// ARQ WAITING
} else if (data["status"] == "waiting") {
ipcRenderer.send("request-show-arq-toast-datachannel-waiting", {
data: [data],
});
// ARQ RECEIVING
} else if (data["status"] == "receiving") {
ipcRenderer.send("request-update-reception-status", {
data: [data],
});
// ARQ TRANSMISSION FAILED
} else if (data["status"] == "failed") {
if (data["reason"] == "protocol version missmatch") {
ipcRenderer.send(
"request-show-arq-toast-transmission-failed-ver",
{ data: [data] }
);
} else {
ipcRenderer.send("request-show-arq-toast-transmission-failed", {
data: [data],
});
}
ipcRenderer.send("request-update-transmission-status", {
data: [data],
});
// ARQ TRANSMISSION RECEIVED
} else if (data["status"] == "received") {
ipcRenderer.send("request-show-arq-toast-transmission-received", {
data: [data],
});
ipcRenderer.send("request-update-transmission-status", {
data: [data],
});
dataArray = [];
messageArray = [];
socketLog.info(data);
// we need to encode here to do a deep check for checking if file or message
//var encoded_data = atob(data['data'])
var encoded_data = atob_FD(data["data"]);
var splitted_data = encoded_data.split(split_char);
if (splitted_data[0] == "f") {
dataArray.push(data);
}
if (splitted_data[0] == "m") {
messageArray.push(data);
console.log(data);
}
rxBufferLengthGui = dataArray.length;
let Files = {
data: dataArray,
};
ipcRenderer.send("request-update-rx-buffer", Files);
ipcRenderer.send("request-new-msg-received", Files);
rxMsgBufferLengthGui = messageArray.length;
let Messages = {
data: messageArray,
};
ipcRenderer.send("request-new-msg-received", Messages);
// ARQ TRANSMISSION TRANSMITTING
} else if (data["status"] == "transmitting") {
ipcRenderer.send(
"request-show-arq-toast-transmission-transmitting",
{ data: [data] }
);
ipcRenderer.send("request-update-transmission-status", {
data: [data],
});
// ARQ TRANSMISSION TRANSMITTED
} else if (data["status"] == "transmitted") {
ipcRenderer.send(
"request-show-arq-toast-transmission-transmitted",
{ data: [data] }
);
ipcRenderer.send("request-update-transmission-status", {
data: [data],
});
}
}
}
// ----------- catch tnc info messages END -----------
// if we manually checking for the rx buffer we are getting an array of multiple data
if (data["command"] == "rx_buffer") {
socketLog.info(data);
// iterate through buffer list and sort it to file or message array
dataArray = [];
messageArray = [];
for (i = 0; i < data["data-array"].length; i++) {
try {
// we need to encode here to do a deep check for checking if file or message
//var encoded_data = atob(data['data-array'][i]['data'])
var encoded_data = atob_FD(data["data-array"][i]["data"]);
var splitted_data = encoded_data.split(split_char);
if (splitted_data[0] == "f") {
dataArray.push(data["data-array"][i]);
}
if (splitted_data[0] == "m") {
messageArray.push(data["data-array"][i]);
}
} catch (e) {
socketLog.info(e);
}
}
rxBufferLengthGui = dataArray.length;
let Files = {
data: dataArray,
};
ipcRenderer.send("request-update-rx-buffer", Files);
rxMsgBufferLengthGui = messageArray.length;
let Messages = {
data: messageArray,
};
//ipcRenderer.send('request-update-rx-msg-buffer', Messages);
ipcRenderer.send("request-new-msg-received", Messages);
}
}
//finally delete message buffer
socketchunk = "";
}
});
function hexToBytes(hex) {
for (var bytes = [], c = 0; c < hex.length; c += 2)
bytes.push(parseInt(hex.substr(c, 2), 16));
return bytes;
}
//Get TNC State
exports.getTncState = function () {
command = '{"type" : "get", "command" : "tnc_state"}';
writeTncCommand(command);
};
//Get DATA State
exports.getDataState = function () {
command = '{"type" : "get", "command" : "data_state"}';
//writeTncCommand(command)
};
// Send Ping
exports.sendPing = function (dxcallsign) {
command =
'{"type" : "ping", "command" : "ping", "dxcallsign" : "' +
dxcallsign +
'"}';
writeTncCommand(command);
};
// Send CQ
exports.sendCQ = function () {
command = '{"type" : "broadcast", "command" : "cqcqcq"}';
writeTncCommand(command);
};
// Set AUDIO Level
exports.setTxAudioLevel = function (value) {
command =
'{"type" : "set", "command" : "tx_audio_level", "value" : "' + value + '"}';
writeTncCommand(command);
};
// Send File
exports.sendFile = function (
dxcallsign,
mode,
frames,
filename,
filetype,
data,
checksum
) {
socketLog.info(data);
socketLog.info(filetype);
socketLog.info(filename);
var datatype = "f";
data =
datatype +
split_char +
filename +
split_char +
filetype +
split_char +
checksum +
split_char +
data;
socketLog.info(data);
//socketLog.info(btoa(data))
//Btoa / atob will not work with charsets > 8 bits (i.e. the emojis); should probably move away from using it
//TODO: Will need to update anyother occurences and throughly test
//data = btoa(data)
data = btoa_FD(data);
command =
'{"type" : "arq", "command" : "send_raw", "parameter" : [{"dxcallsign" : "' +
dxcallsign +
'", "mode" : "' +
mode +
'", "n_frames" : "' +
frames +
'", "data" : "' +
data +
'"}]}';
writeTncCommand(command);
};
// Send Message
exports.sendMessage = function (
dxcallsign,
mode,
frames,
data,
checksum,
uuid,
command
) {
data = btoa_FD(
"m" +
split_char +
command +
split_char +
checksum +
split_char +
uuid +
split_char +
data
);
command =
'{"type" : "arq", "command" : "send_raw", "uuid" : "' +
uuid +
'", "parameter" : [{"dxcallsign" : "' +
dxcallsign +
'", "mode" : "' +
mode +
'", "n_frames" : "' +
frames +
'", "data" : "' +
data +
'", "attempts": "15"}]}';
socketLog.info(command);
socketLog.info("-------------------------------------");
writeTncCommand(command);
};
//STOP TRANSMISSION
exports.stopTransmission = function () {
command = '{"type" : "arq", "command": "stop_transmission"}';
writeTncCommand(command);
};
// Get RX BUffer
exports.getRxBuffer = function () {
command = '{"type" : "get", "command" : "rx_buffer"}';
// call command only if new data arrived
if (rxBufferLengthGui != rxBufferLengthTnc) {
writeTncCommand(command);
}
};
// START BEACON
exports.startBeacon = function (interval) {
command =
'{"type" : "broadcast", "command" : "start_beacon", "parameter": "' +
interval +
'"}';
writeTncCommand(command);
};
// STOP BEACON
exports.stopBeacon = function () {
command = '{"type" : "broadcast", "command" : "stop_beacon"}';
writeTncCommand(command);
};
// OPEN ARQ SESSION
exports.connectARQ = function (dxcallsign) {
command =
'{"type" : "arq", "command" : "connect", "dxcallsign": "' +
dxcallsign +
'", "attempts": "15"}';
writeTncCommand(command);
};
// CLOSE ARQ SESSION
exports.disconnectARQ = function () {
command = '{"type" : "arq", "command" : "disconnect"}';
writeTncCommand(command);
};
// SEND TEST FRAME
exports.sendTestFrame = function () {
command = '{"type" : "set", "command" : "send_test_frame"}';
writeTncCommand(command);
};
// RECORD AUDIO
exports.record_audio = function () {
command = '{"type" : "set", "command" : "record_audio"}';
writeTncCommand(command);
};
// SET FREQUENCY
exports.set_frequency = function (frequency) {
command =
'{"type" : "set", "command" : "frequency", "frequency": ' + frequency + "}";
writeTncCommand(command);
};
// SET MODE
exports.set_mode = function (mode) {
command = '{"type" : "set", "command" : "mode", "mode": "' + mode + '"}';
console.log(command);
writeTncCommand(command);
};
ipcRenderer.on("action-update-tnc-ip", (event, arg) => {
client.destroy();
let Data = {
busy_state: "-",
arq_state: "-",
//channel_state: "-",
frequency: "-",
mode: "-",
bandwidth: "-",
dbfs_level: 0,
};
ipcRenderer.send("request-update-tnc-state", Data);
tnc_port = arg.port;
tnc_host = arg.adress;
connectTNC();
});
/**
* String to base64
* @param {string} data in normal/usual utf-8 format
* @returns base64 encoded string
*/
function btoa_FD(data) {
return Buffer.from(data, "utf-8").toString("base64");
}
/**
* base64 to string
* @param {string} data in base64 encoding
* @returns utf-8 normal/usual string
*/
function atob_FD(data) {
return Buffer.from(data, "base64").toString("utf-8");
}
// https://stackoverflow.com/a/50579690
// crc32 calculation
//console.log(crc32('abc'));
//console.log(crc32('abc').toString(16).toUpperCase()); // hex
var crc32 = function (r) {
for (var a, o = [], c = 0; c < 256; c++) {
a = c;
for (var f = 0; f < 8; f++) a = 1 & a ? 3988292384 ^ (a >>> 1) : a >>> 1;
o[c] = a;
}
for (var n = -1, t = 0; t < r.length; t++)
n = (n >>> 8) ^ o[255 & (n ^ r.charCodeAt(t))];
return (-1 ^ n) >>> 0;
};
Reference in New Issue View Git Blame Copy Permalink