You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
438 lines
13 KiB
438 lines
13 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE // |
|
// Some code by AI // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "util/acarsmultipartassembler.h" |
|
|
|
#include <QMap> |
|
|
|
namespace { |
|
|
|
const QChar KEY_SEPARATOR(0x1f); |
|
const int MAX_MESSAGE_BLOCKS = 16; |
|
|
|
} |
|
|
|
int AcarsMultipartAssembler::Assembly::partNumber(quint64 sourceId) const |
|
{ |
|
int number = 0; |
|
|
|
for (const Part& part : m_parts) |
|
{ |
|
if (!m_uplink && (part.m_sourceId == sourceId)) |
|
{ |
|
const ushort sequence = part.m_blockSequence.unicode(); |
|
return ((sequence >= 'A') && (sequence <= 'Z')) |
|
? sequence - 'A' + 1 |
|
: 0; |
|
} |
|
|
|
if (!part.m_duplicate) { |
|
++number; |
|
} |
|
if (part.m_sourceId == sourceId) { |
|
return number; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
bool AcarsMultipartAssembler::Assembly::isMultipart() const |
|
{ |
|
return (m_uniquePartCount > 1) |
|
|| (m_duplicateCount > 0) |
|
|| (m_status != Complete); |
|
} |
|
|
|
AcarsMultipartAssembler::AcarsMultipartAssembler(int timeoutSeconds) : |
|
m_timeoutSeconds(timeoutSeconds), |
|
m_nextId(1) |
|
{ |
|
} |
|
|
|
AcarsMultipartAssembler::Result AcarsMultipartAssembler::add(const Part& part) |
|
{ |
|
expire(part.m_received); |
|
return part.m_uplink ? addUplink(part) : addDownlink(part); |
|
} |
|
|
|
QSharedPointer<const AcarsMultipartAssembler::Assembly> |
|
AcarsMultipartAssembler::assemblyFor(quint64 sourceId) const |
|
{ |
|
return m_sourceAssemblies.value(sourceId); |
|
} |
|
|
|
void AcarsMultipartAssembler::clear() |
|
{ |
|
m_downlinks.clear(); |
|
m_uplinks.clear(); |
|
m_uplinkReferences.clear(); |
|
m_sourceAssemblies.clear(); |
|
m_nextId = 1; |
|
} |
|
|
|
QString AcarsMultipartAssembler::statusText(Status status) |
|
{ |
|
switch (status) |
|
{ |
|
case InProgress: |
|
return "In progress"; |
|
case Complete: |
|
return "Complete"; |
|
case Incomplete: |
|
return "Incomplete"; |
|
case Ambiguous: |
|
return "Ambiguous"; |
|
} |
|
|
|
return QString(); |
|
} |
|
|
|
QString AcarsMultipartAssembler::downlinkKey(const Part& part) |
|
{ |
|
return part.m_address + KEY_SEPARATOR |
|
+ part.m_originator + KEY_SEPARATOR |
|
+ part.m_messageNumber; |
|
} |
|
|
|
QString AcarsMultipartAssembler::uplinkKey(const Part& part) |
|
{ |
|
return part.m_address + KEY_SEPARATOR |
|
+ part.m_label + KEY_SEPARATOR |
|
+ part.m_subLabel; |
|
} |
|
|
|
bool AcarsMultipartAssembler::validMessageNumber(const QString& number) |
|
{ |
|
return (number.size() == 2) |
|
&& number[0].isDigit() |
|
&& number[1].isDigit(); |
|
} |
|
|
|
int AcarsMultipartAssembler::sequenceIndex(QChar sequence) |
|
{ |
|
const ushort value = sequence.unicode(); |
|
return ((value >= 'A') && (value <= 'Z')) ? value - 'A' : -1; |
|
} |
|
|
|
bool AcarsMultipartAssembler::sameBlock(const Part& lhs, const Part& rhs) |
|
{ |
|
return (lhs.m_blockId == rhs.m_blockId) |
|
&& (lhs.m_text == rhs.m_text) |
|
&& (lhs.m_label == rhs.m_label) |
|
&& (lhs.m_subLabel == rhs.m_subLabel) |
|
&& (lhs.m_originator == rhs.m_originator) |
|
&& (lhs.m_messageNumber == rhs.m_messageNumber) |
|
&& (lhs.m_blockSequence == rhs.m_blockSequence) |
|
&& (lhs.m_more == rhs.m_more); |
|
} |
|
|
|
QSharedPointer<AcarsMultipartAssembler::Assembly> |
|
AcarsMultipartAssembler::createAssembly(const Part& part) |
|
{ |
|
QSharedPointer<Assembly> assembly(new Assembly); |
|
assembly->m_id = m_nextId++; |
|
assembly->m_uplink = part.m_uplink; |
|
assembly->m_firstReceived = part.m_received; |
|
assembly->m_lastReceived = part.m_received; |
|
return assembly; |
|
} |
|
|
|
AcarsMultipartAssembler::Result AcarsMultipartAssembler::addDownlink(Part part) |
|
{ |
|
const int sequence = sequenceIndex(part.m_blockSequence); |
|
const bool sequenced = validMessageNumber(part.m_messageNumber) |
|
&& !part.m_originator.isEmpty() |
|
&& (sequence >= 0); |
|
|
|
// A legal no-text block has no MSN. Treat other unsequenced blocks as standalone but |
|
// make an ETB block ambiguous because there is no safe way to attach its successor. |
|
if (!sequenced) |
|
{ |
|
QSharedPointer<Assembly> assembly = createAssembly(part); |
|
appendPart(assembly, part); |
|
assembly->m_combinedText = part.m_text; |
|
assembly->m_uniquePartCount = 1; |
|
assembly->m_status = part.m_more ? Ambiguous : Complete; |
|
return {assembly, 1, false}; |
|
} |
|
|
|
const QString key = downlinkKey(part); |
|
QSharedPointer<Assembly> assembly = m_downlinks.value(key); |
|
|
|
if (assembly) |
|
{ |
|
const Part *firstPart = nullptr; |
|
for (const Part& existing : assembly->m_parts) |
|
{ |
|
if (!existing.m_duplicate) |
|
{ |
|
firstPart = &existing; |
|
break; |
|
} |
|
} |
|
if (firstPart |
|
&& ((firstPart->m_label != part.m_label) |
|
|| (firstPart->m_subLabel != part.m_subLabel))) |
|
{ |
|
part.m_conflict = true; |
|
} |
|
|
|
for (const Part& existing : assembly->m_parts) |
|
{ |
|
if ((existing.m_blockSequence == part.m_blockSequence) && sameBlock(existing, part)) |
|
{ |
|
part.m_duplicate = true; |
|
appendPart(assembly, part); |
|
refreshDownlink(assembly); |
|
return {assembly, assembly->partNumber(part.m_sourceId), true}; |
|
} |
|
} |
|
|
|
// A new A with a different DBI/payload is a restart, not the successor of A. |
|
if (sequence == 0) |
|
{ |
|
if (assembly->m_status == InProgress) { |
|
assembly->m_status = Incomplete; |
|
} |
|
assembly = QSharedPointer<Assembly>(); |
|
} |
|
} |
|
|
|
if (!assembly) |
|
{ |
|
assembly = createAssembly(part); |
|
m_downlinks.insert(key, assembly); |
|
} |
|
else |
|
{ |
|
for (const Part& existing : assembly->m_parts) |
|
{ |
|
if (!existing.m_duplicate && (existing.m_blockSequence == part.m_blockSequence)) |
|
{ |
|
part.m_conflict = true; |
|
break; |
|
} |
|
} |
|
} |
|
|
|
appendPart(assembly, part); |
|
refreshDownlink(assembly); |
|
return {assembly, assembly->partNumber(part.m_sourceId), part.m_duplicate}; |
|
} |
|
|
|
AcarsMultipartAssembler::Result AcarsMultipartAssembler::addUplink(Part part) |
|
{ |
|
const QString referenceKey = part.m_address; |
|
const auto referenceIt = m_uplinkReferences.constFind(referenceKey); |
|
const bool reusedUbi = (referenceIt != m_uplinkReferences.constEnd()) |
|
&& (referenceIt->m_part.m_blockId == part.m_blockId); |
|
|
|
if (reusedUbi |
|
&& sameBlock(referenceIt->m_part, part)) |
|
{ |
|
part.m_duplicate = true; |
|
appendPart(referenceIt->m_assembly, part); |
|
refreshUplink(referenceIt->m_assembly); |
|
return { |
|
referenceIt->m_assembly, |
|
referenceIt->m_assembly->partNumber(part.m_sourceId), |
|
true |
|
}; |
|
} |
|
|
|
const QString key = uplinkKey(part); |
|
QSharedPointer<Assembly> assembly = m_uplinks.value(key); |
|
|
|
if (reusedUbi) { |
|
part.m_conflict = true; |
|
} |
|
|
|
if (!assembly) |
|
{ |
|
assembly = createAssembly(part); |
|
if (part.m_more) { |
|
m_uplinks.insert(key, assembly); |
|
} |
|
} |
|
|
|
appendPart(assembly, part); |
|
refreshUplink(assembly); |
|
|
|
if (!part.m_more) { |
|
m_uplinks.remove(key); |
|
} |
|
|
|
UplinkReference reference; |
|
reference.m_part = part; |
|
reference.m_assembly = assembly; |
|
m_uplinkReferences.insert(referenceKey, reference); |
|
|
|
return {assembly, assembly->partNumber(part.m_sourceId), false}; |
|
} |
|
|
|
void AcarsMultipartAssembler::appendPart( |
|
const QSharedPointer<Assembly>& assembly, |
|
const Part& part) |
|
{ |
|
assembly->m_parts.append(part); |
|
assembly->m_lastReceived = part.m_received; |
|
m_sourceAssemblies.insert(part.m_sourceId, assembly); |
|
} |
|
|
|
void AcarsMultipartAssembler::refreshDownlink(const QSharedPointer<Assembly>& assembly) |
|
{ |
|
QMap<int, const Part *> ordered; |
|
bool conflict = false; |
|
bool ended = false; |
|
int finalSequence = assembly->m_finalSequence; |
|
int duplicates = 0; |
|
|
|
for (const Part& part : assembly->m_parts) |
|
{ |
|
if (part.m_duplicate) |
|
{ |
|
++duplicates; |
|
continue; |
|
} |
|
|
|
const int sequence = sequenceIndex(part.m_blockSequence); |
|
conflict = conflict || part.m_conflict || (sequence < 0); |
|
|
|
if ((sequence >= 0) && !ordered.contains(sequence)) { |
|
ordered.insert(sequence, &part); |
|
} |
|
|
|
if (!part.m_more) |
|
{ |
|
ended = true; |
|
finalSequence = sequence; |
|
} |
|
} |
|
|
|
assembly->m_combinedText.clear(); |
|
for (const Part *part : ordered) { |
|
assembly->m_combinedText.append(part->m_text); |
|
} |
|
|
|
assembly->m_missingSequences.clear(); |
|
const int lastExpected = ended ? finalSequence : (ordered.isEmpty() ? -1 : ordered.lastKey()); |
|
for (int sequence = 0; sequence <= lastExpected; ++sequence) |
|
{ |
|
if (!ordered.contains(sequence)) { |
|
assembly->m_missingSequences.append(QString(QChar('A' + sequence))); |
|
} |
|
} |
|
|
|
assembly->m_finalSequence = finalSequence; |
|
assembly->m_uniquePartCount = ordered.size(); |
|
assembly->m_duplicateCount = duplicates; |
|
|
|
if (conflict |
|
|| (ordered.size() > MAX_MESSAGE_BLOCKS) |
|
|| (!ordered.isEmpty() && (ordered.lastKey() >= MAX_MESSAGE_BLOCKS))) |
|
{ |
|
assembly->m_status = Ambiguous; |
|
} else if (ended) { |
|
assembly->m_status = assembly->m_missingSequences.isEmpty() ? Complete : Incomplete; |
|
} else { |
|
assembly->m_status = InProgress; |
|
} |
|
} |
|
|
|
void AcarsMultipartAssembler::refreshUplink(const QSharedPointer<Assembly>& assembly) |
|
{ |
|
bool conflict = false; |
|
bool ended = false; |
|
int uniqueParts = 0; |
|
int duplicates = 0; |
|
|
|
assembly->m_combinedText.clear(); |
|
|
|
for (const Part& part : assembly->m_parts) |
|
{ |
|
if (part.m_duplicate) |
|
{ |
|
++duplicates; |
|
continue; |
|
} |
|
|
|
++uniqueParts; |
|
assembly->m_combinedText.append(part.m_text); |
|
conflict = conflict || part.m_conflict; |
|
ended = ended || !part.m_more; |
|
} |
|
|
|
assembly->m_uniquePartCount = uniqueParts; |
|
assembly->m_duplicateCount = duplicates; |
|
|
|
if (conflict || (uniqueParts > MAX_MESSAGE_BLOCKS)) { |
|
assembly->m_status = Ambiguous; |
|
} else { |
|
assembly->m_status = ended ? Complete : InProgress; |
|
} |
|
} |
|
|
|
void AcarsMultipartAssembler::expire(const QDateTime& received) |
|
{ |
|
auto expireAssemblies = [this, &received](QHash<QString, QSharedPointer<Assembly>>& active) |
|
{ |
|
auto it = active.begin(); |
|
while (it != active.end()) |
|
{ |
|
const QSharedPointer<Assembly>& assembly = it.value(); |
|
if (assembly->m_lastReceived.secsTo(received) > m_timeoutSeconds) |
|
{ |
|
if (assembly->m_status == InProgress) { |
|
assembly->m_status = Incomplete; |
|
} |
|
it = active.erase(it); |
|
} |
|
else |
|
{ |
|
++it; |
|
} |
|
} |
|
}; |
|
|
|
expireAssemblies(m_downlinks); |
|
expireAssemblies(m_uplinks); |
|
|
|
// ... and the source-to-assembly lookup with them. It was never pruned at all, so it |
|
// grew by one entry per message received for the life of the channel - the same leak |
|
// the retained AcarsMessage list was, one indirection further along. |
|
auto sourceIt = m_sourceAssemblies.begin(); |
|
while (sourceIt != m_sourceAssemblies.end()) |
|
{ |
|
if (sourceIt.value()->m_lastReceived.secsTo(received) > m_timeoutSeconds) { |
|
sourceIt = m_sourceAssemblies.erase(sourceIt); |
|
} else { |
|
++sourceIt; |
|
} |
|
} |
|
|
|
auto reference = m_uplinkReferences.begin(); |
|
while (reference != m_uplinkReferences.end()) |
|
{ |
|
if (reference->m_part.m_received.secsTo(received) > m_timeoutSeconds) { |
|
reference = m_uplinkReferences.erase(reference); |
|
} else { |
|
++reference; |
|
} |
|
} |
|
}
|
|
|