cellular-infrastructure
/
osmocom-analog
9
1
Fork 2
Code Issues 12 Pull Requests 2 Projects Releases Wiki Activity
osmocom-analog/src/fuvst/mup.c

1137 lines
27 KiB
C
Executable File
Raw Blame History

/* C-Netz Mobile User Part message coding
*
* (C) 2020 by Andreas Eversberg <jolly@eversberg.eu>
* All Rights Reserved
*
* 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, either 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 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 <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <inttypes.h>
#include "../libdebug/debug.h"
#include "mup.h"
#include "systemmeldungen.h"
const char *einrichtrungstyp_string(uint8_t T)
{
static char unknown[4];
switch (T) {
case 1:
return "OGK";
case 2:
return "SPK";
case 3:
return "PHE";
case 4:
return "PFG";
case 5:
return "PBR";
case 6:
return "FME";
case 8:
return "DKV";
case 9:
return "SAE";
case 10:
return "FDS";
case 11:
return "BS ";
case 12:
return "MSC";
case 13:
return "OSK";
default:
sprintf(unknown, "%03d", T);
return unknown;
}
}
static const char *version_string(uint8_t V)
{
switch (V) {
case 0:
return "undefined";
case 1:
return "LM3.6 BS";
case 2:
return "LM4 BS";
case 3:
return "LM5 BS";
case 4:
return "LM6 BS";
case 5:
return "LM7 BS";
case 6:
return "LM8 BS";
}
return "unknown";
}
static const char *chip_string(uint8_t C)
{
switch (C) {
case 0:
return "chipfunction off";
case 1:
return "chipfunction on";
}
return "unknown";
}
static const char *beacon_string(uint8_t B)
{
switch (B) {
case 0:
return "normal BS";
case 1:
return "stand alone beacon";
case 2:
return "low power beacon CCH pair 2 exclusively";
case 3:
return "low power beacon CCH pair 3 exclusively";
case 4:
return "low power beacon";
}
return "unknown";
}
static const char *qualitaet_string(uint8_t Q)
{
switch (Q) {
case 0:
return "unsichere Angabe";
case 1:
return "sichere Angabe";
}
return "unknown";
}
static const char *wiederholung_string(uint8_t N)
{
switch (N) {
case 0:
return "keine Wiederholung";
case 1:
return "Wiederholung";
}
return "unknown";
}
static const char *woche_string(uint8_t Q)
{
switch (Q) {
case 1:
return "Sonntag";
case 2:
return "Montag";
case 3:
return "Dienstag";
case 4:
return "Mittwoch";
case 5:
return "Donnerstag";
case 6:
return "Freitag";
case 7:
return "Samstag";
}
return "unknown";
}
static const char *aktivdatei_string(uint8_t A)
{
switch (A) {
case 0:
return "wurde gesendet";
case 1:
return "wurde nicht gesendet";
}
return "unknown";
}
static const char *prio_string(uint8_t P)
{
switch (P) {
case 0:
return "Verbindung ohne Prioritaet";
case 1:
return "Verbindung mit Prioritaet";
}
return "unknown";
}
static const char *rufzeit_string(uint8_t F)
{
switch (F) {
case 0:
return "Begrenzung durch SPK";
case 1:
return "Begrenzung durch MSC";
}
return "unknown";
}
static const char *typ_string(uint8_t V)
{
switch (V) {
case 0:
return "gehender Verbindungs-Aufbau";
case 1:
return "kommender Verbindungs-Aufbau";
}
return "unknown";
}
static const char *fufst_cause(uint8_t X)
{
switch (X) {
case 0:
return "undefiniert";
case 1:
return "Einh.A (A-BS)";
case 2:
return "Einh.B (B-BS)";
case 3:
return "Tln-besetzt (A-BS)";
case 4:
return "Gassenbesetzt";
case 5:
return "Time-Out: kein Sprechkanal";
case 6:
return "Time-Out: kein Melden B (A-BS)";
case 7:
return "Funk-Tln nicht verbindungsberechtigt";
case 8:
return "WS ist blockiert (Time out)";
case 9:
return "Funk-Tln nicht aktiv";
case 10:
return "Funk-Tln nicht erreichbar";
case 11:
return "Time-Out: keine Reaktion von der MSC";
case 12:
return "Umbuchung in WS oder gegenlaeufige Einbuchung";
case 13:
return "ungueltige Wahl";
case 17:
return "Time out: Gespraechszeitbegrenzung (BS)";
case 18:
return "Qualitaet Sprechkanal (Funkverbindung MS->BS)";
case 19:
return "Qualitaet Fu-Tln-Geraet (Funkverbindung BS->MS)";
case 20:
return "Signalisierungsverlust Sprechkanal (MS->BS)";
case 21:
return "Signalisierungsverlust Fu-Tln-Geraet (BS-MS)";
case 22:
return "Sprechkanal-Funktionsstoerung (HW-/SW Fehler)";
case 23:
return "Umschalten";
case 24:
return "Authentifikation negativ";
case 25:
return "Stoerung Randomzahluebertragung";
case 27:
return "Kein Melden B (B-BS), Infobox aktiviert";
case 26:
return "Stoerung Autorisierungsparameteruebertragung";
}
return "unknown";
}
static const char *futln_cause(uint8_t Y)
{
switch (Y) {
case 0:
return "Gassenbesetzt";
case 1:
return "Teilnehmer-besetzt";
case 2:
return "Funktechnisch";
case 3:
return "Timeout";
case 4:
return "ungueltige Wahl";
}
return "unknown";
}
/*
* message coding and decoding
*/
/* base station boots */
void decode_swaf(uint8_t *data, int len, uint8_t *V, uint8_t *N, uint8_t *U, uint8_t *F, uint8_t *C, uint8_t *B)
{
if (len < 6) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*V = data[0];
*N = data[1];
*U = data[2];
*F = data[3];
*C = data[4];
*B = data[5];
PDEBUG(DMUP, DEBUG_INFO, "(BS SWAF) Wiederanlauf der BS: version=%d (%s) FuFSt=%d,%d,%d chip=%d (%s) beacon=%d (%s)\n", *V, version_string(*V), *N, *U, *F, *C, chip_string(*C), *B, beacon_string(*B));
}
/* ack to base station boot */
int encode_swqu(uint8_t *opcode, uint8_t **data, uint8_t A)
{
static uint8_t buffer[1];
PDEBUG(DMUP, DEBUG_INFO, "(MSC SWQU) Wiederanlaufquittung des MSC: aktivdatei=%d (%s)\n", A, aktivdatei_string(A));
*opcode = OPCODE_SWQU;
buffer[0] = A;
*data = buffer;
return sizeof(buffer);
}
/* base station requests time */
void decode_suaf(uint8_t *data, int len, uint8_t *V, uint8_t *N, uint8_t *U, uint8_t *F, uint8_t *C, uint8_t *B)
{
if (len < 6) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*V = data[0];
*N = data[1];
*U = data[2];
*F = data[3];
*C = data[4];
*B = data[5];
PDEBUG(DMUP, DEBUG_INFO, "(BS SUAF) Datum-Uhrzeit-Anforderung der BS: version=%d (%s) FuFSt=%d,%d,%d chip=%d (%s) beacon=%d (%s)\n", *V, version_string(*V), *N, *U, *F, *C, chip_string(*C), *B, beacon_string(*B));
}
/* ack to time request */
int encode_suqu(uint8_t *opcode, uint8_t **data, uint8_t Q, uint8_t N, time_t now)
{
static uint8_t buffer[8];
struct tm *tm;
uint8_t R, W, D, M, J, h, m, s;
tm = localtime(&now);
R = 0x00;
W = tm->tm_wday + 1; /* 1 = Sonntag */
D = tm->tm_mday;
M = tm->tm_mon + 1;
J = tm->tm_year % 100; /* Erlaubt: 0--99 */
h = tm->tm_hour;
m = tm->tm_min;
s = tm->tm_sec;
PDEBUG(DMUP, DEBUG_INFO, "(MSC SUQU) Datum-Uhrzeit-Quittung des MSC: Q=%d (%s) Widerholung=%d (%s) Wochentag=%d (%s) Datum: %d.%d.%d %d:%02d:%02d\n", Q, qualitaet_string(Q), N, wiederholung_string(N), W, woche_string(W), D, M, J, h, m, s);
*opcode = OPCODE_SUQU;
buffer[0] = Q | (N << 1) | (R << 2);
buffer[1] = W;
buffer[2] = D;
buffer[3] = M;
buffer[4] = J;
buffer[5] = h;
buffer[6] = m;
buffer[7] = s;
*data = buffer;
return sizeof(buffer);
}
/* base station lists voice channels */
void decode_sssaf(uint8_t *data, int len)
{
uint8_t E_;
uint16_t A, E;
uint8_t S = 0xff, last_S = 0xff;
int i, start_i = 0, stop_i = 0;
if (len < 11) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
E_ = data[0] >> 7;
A = data[1] | (data[2] << 8);
E = data[3] | (data[4] << 8);
PDEBUG(DMUP, DEBUG_INFO, "(BS SSSAF) Sprechkanal-Sammel-Sperrauftrag der BS: Liste-Ende=%d Anfang=%d Ende=%d\n", E_, A, E);
if (E - A + 1 > 6 * 8) {
PDEBUG(DMUP, DEBUG_INFO, " -> Bereich zu gross für Nachricht!\n");
return;
}
if ((int)E - (int)A < 0)
return;
/* count number of channels + 1, so that we can output the last range at the end */
for (i = 0; i <= E - A + 1; i++) {
/* after all loop turns (A..E), output last range */
if (i == E - A + 1)
goto end;
S = (data[5 + (i >> 3)] >> (i & 7)) & 1;
/* set start of range if first channel */
if (i == 0)
start_i = i;
/* set stop of range, if first channel OR same state as last channel OR for last channel */
if (i == 0 || S == last_S)
stop_i = i;
/* output range if we have a change in channel or is we reached the last channels */
if (i > 0 && S != last_S) {
end:
if (start_i == stop_i)
PDEBUG(DMUP, DEBUG_INFO, " -> SpK #%d=%d (%s)\n", start_i + A, last_S, (last_S) ? "gesperrt" : "frei");
else
PDEBUG(DMUP, DEBUG_INFO, " -> SpK #%d..%d=%d (%s)\n", start_i + A, stop_i + A, last_S, (last_S) ? "gesperrt" : "frei");
/* new start */
start_i = stop_i = i;
}
last_S = S;
}
}
/* ack voice channel list */
void encode_sssqu(uint8_t *opcode)
{
*opcode = OPCODE_SSSQU;
PDEBUG(DMUP, DEBUG_INFO, "(MSC SSSQU) Sprechkanal-Sammel-Sperrquittung des MSC\n");
}
/* base station locks a voice channel */
void decode_ssaf(uint8_t *data, int len, uint8_t *S)
{
if (len < 1) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*S = data[0];
PDEBUG(DMUP, DEBUG_INFO, "(BS SSAF) Sprechkanal-Sperr-Auftrag der BS: SPK=%d\n", *S);
}
/* ack to lockeed voice channel */
int encode_ssqu(uint8_t *opcode, uint8_t **data, uint8_t S)
{
static uint8_t buffer[1];
PDEBUG(DMUP, DEBUG_INFO, "(MSC SSQU) Sprechkanal-Sperr-Quittung von der MSC: SPK=%d\n", S);
*opcode = OPCODE_SSQU;
buffer[0] = S;
*data = buffer;
return sizeof(buffer);
}
/* base station unlocks a voice channel */
void decode_sfaf(uint8_t *data, int len, uint8_t *S)
{
if (len < 1) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*S = data[0];
PDEBUG(DMUP, DEBUG_INFO, "(BS SFAF) Sprechkanal-Freigabe-Auftrag der BS: SPK=%d\n", *S);
}
/* ack to unlockeed voice channel */
int encode_sfqu(uint8_t *opcode, uint8_t **data, uint8_t S)
{
static uint8_t buffer[1];
PDEBUG(DMUP, DEBUG_INFO, "(MSC SFQU) Sprechkanal-Freigabe-Quittung von der MSC: SPK=%d\n", S);
*opcode = OPCODE_SFQU;
buffer[0] = S;
*data = buffer;
return sizeof(buffer);
}
/* base station ready */
void decode_svaf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS SVAF) Vermittlungsfaehig-Auftrag der BS\n");
}
/* ack to base station ready */
int encode_svqu(uint8_t *opcode, uint8_t **data)
{
PDEBUG(DMUP, DEBUG_INFO, "(MSC SVQU) Vermittlungsfaehig-Quittung des MSC\n");
*opcode = OPCODE_SVQU;
*data = NULL;
return 0;
}
/* base station requests alarm messages */
void decode_ylsaf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS YLSAF) Systemmeldungsanforderung an MSC\n");
}
/* ack to base stations alarm request */
int encode_ylsmu(uint8_t *opcode, uint8_t **data)
{
PDEBUG(DMUP, DEBUG_INFO, "(MSC YLSMU) Systemmeldungsbestaetigung vom MSC\n");
*opcode = OPCODE_YLSMU;
*data = NULL;
return 0;
}
/* base station sends alarm message */
void decode_ylsmf(uint8_t *data, int len, uint8_t *N, uint8_t *C, struct SysMeld *SM)
{
if (len < 9) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*N = data[0];
*C = data[8];
switch (*N) {
case 1:
memset(SM, 0, sizeof(*SM));
SM->FUKO = data[1] << 8;
SM->FUKO |= data[2];
SM->Monat = (data[3] >> 4) * 10 + (data[3] & 0xf);
SM->Tag = (data[4] >> 4) * 10 + (data[4] & 0xf);
SM->Stunde = (data[5] >> 4) * 10 + (data[5] & 0xf);
SM->Minute = (data[6] >> 4) * 10 + (data[6] & 0xf);
SM->Kennzeichen_posthum = data[7];
break;
case 2:
SM->Systemmeldungsnr = data[1] << 8;
SM->Systemmeldungsnr |= data[2];
SM->Indizienlaenge = data[3];
SM->Indizien[0] = data[4];
SM->Indizien[1] = data[5];
SM->Indizien[2] = data[6];
SM->Indizien[3] = data[7];
break;
case 3:
SM->Indizien[4] = data[1];
SM->Indizien[5] = data[2];
SM->Indizien[6] = data[3];
SM->Indizien[7] = data[4];
SM->Indizien[8] = data[5];
SM->Indizien[9] = data[6];
SM->ASCII_Typ = data[7];
break;
case 4:
SM->Einrichtungstyp = data[1];
SM->Einrichtungsnr = data[2];
SM->Zusatzinfo[0] = data[3];
SM->Zusatzinfo[1] = data[4];
SM->Zusatzinfo[2] = data[5];
SM->Zusatzinfo[3] = data[6];
break;
}
if (*N != 4)
return;
char indizien[24] = " ";
int i, ii;
ii = SM->Indizienlaenge;
if (ii > 10)
ii = 10;
for (i = 0; i < ii; i++) {
sprintf(indizien + (i * 2) + (i > 3) + (i > 7), "%02X", SM->Indizien[i]);
indizien[strlen(indizien)] = ' ';
}
PDEBUG(DMUP, DEBUG_INFO, "SM: %03d %02d.%02d %02d:%02d %s%02d %c H\"%04X %02d H\"%sH\"%02X%02X%02X%02X\n", *C,
SM->Monat, SM->Tag, SM->Stunde, SM->Minute,
einrichtrungstyp_string(SM->Einrichtungstyp), SM->Einrichtungsnr,
SM->ASCII_Typ ? : '0', SM->Systemmeldungsnr,
SM->Indizienlaenge, indizien,
SM->Zusatzinfo[0], SM->Zusatzinfo[1], SM->Zusatzinfo[2], SM->Zusatzinfo[3]);
print_systemmeldung(SM->Systemmeldungsnr, SM->Indizienlaenge, SM->Indizien);
}
/* base station ends list of alarm messages */
void decode_ylsef(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS YLSEF) Systemmeldungsuebertragungsende an MSC\n");
}
/* base station requests billing info */
void decode_stdaf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS STDAF) Tarifdatenauftrag der BS\n");
}
/* reply to billing info */
int encode_xgtau(uint8_t *opcode, uint8_t **data, uint8_t Z, uint32_t T, uint8_t S, uint8_t K, uint16_t CS)
{
static uint8_t buffer[9];
// Example from UeLE-ROM = { 0xff, 0x00, 0x01, 0xec, 0x3f, 0x01, 0x31, 0x1c, 0x03 };
// { 0xff, 0x00, 0x01, 0xec, 0x3f, 0x01, 0x41, 0x1c, 0x03 };
PDEBUG(DMUP, DEBUG_INFO, "(MSC XGTAU) Tarifdatensignalisierung vom MSC\n");
*opcode = OPCODE_XGTAU;
buffer[0] = 0xff;
buffer[1] = 0x00;
buffer[2] = Z;
buffer[3] = T;
buffer[4] = T >> 8;
buffer[5] = T >> 16;
buffer[6] = S | (K << 4);
buffer[7] = CS;
buffer[8] = CS >> 8;
*data = buffer;
return sizeof(buffer);
}
/* inscription */
void decode_ebaf(uint8_t *data, int len, uint16_t *T, uint8_t *U, uint8_t *N, uint16_t *s, uint8_t *u, uint8_t *b, uint8_t *l)
{
if (len < 6) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*T = (data[1] << 8) | data[0];
*U = data[2] & 0x1f;
*N = data[2] >> 5;
*s = (data[4] << 8) | data[3];
*u = (data[5] >> 1) & 0x7;
*b = (data[5] >> 6) & 0x1;
*l = data[5] >> 7;
PDEBUG(DMUP, DEBUG_INFO, "(BS EBAF) Einbuchauftrag: FuTln=%d,%d,%d (0161-%d%d%05d)\n", *N, *U, *T, *N, *U, *T);
}
/* ack to inscription */
int encode_ebpqu(uint8_t *opcode, uint8_t **data)
{
PDEBUG(DMUP, DEBUG_INFO, "(MSC EBPQU) Einbuchungs-Positiv-Quittiung vom MSC\n");
*opcode = OPCODE_EBPQU;
*data = NULL;
return 0;
}
/* leave BS */
void decode_abaf(uint8_t *data, int len, uint16_t *T, uint8_t *U, uint8_t *N)
{
if (len < 3) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*T = (data[1] << 8) | data[0];
*U = data[2] & 0x1f;
*N = data[2] >> 5;
PDEBUG(DMUP, DEBUG_INFO, "(BS ABAF) Ausbuchung-Auftrag der BS: FuTln=%d,%d,%d (0161-%d%d%05d)\n", *N, *U, *T, *N, *U, *T);
}
static char digit2char[16] = "0123456789a*#bcd";
/* MO call */
void _decode_outgoing(uint8_t *data, int len, uint16_t *T, uint8_t *U, uint8_t *N, char *number)
{
int i;
if (len < 11) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*T = (data[1] << 8) | data[0];
*U = data[2] & 0x1f;
*N = data[2] >> 5;
len = data[3] & 0xf;
if (len == 0) {
/* 16 digits, starting with 0 */
for (i = 0; i < 16; i++) {
if ((i & 1) == 0)
number[i] = digit2char[(data[3 + (i >> 1)] & 0xf)];
else
number[i] = digit2char[(data[3 + (i >> 1)] >> 4)];
}
number[16] = '\0';
} else {
/* up to 16 digits */
for (i = 0; i < len; i++) {
if ((i & 1) == 0)
number[i] = digit2char[(data[3 + ((i + 1) >> 1)] >> 4)];
else
number[i] = digit2char[(data[3 + ((i + 1) >> 1)] & 0xf)];
}
number[len] = '\0';
}
}
void decode_gvaf(uint8_t *data, int len, uint16_t *T, uint8_t *U, uint8_t *N, char *number)
{
_decode_outgoing(data, len, T, U , N, number);
PDEBUG(DMUP, DEBUG_INFO, "(BS GVAF) Gehender Verbindungs-Auftrag der BS: FuTln=%d,%d,%d (0161-%d%d%05d) number=%s\n", *N, *U, *T, *N, *U, *T, number);
}
void decode_gvwaf(uint8_t *data, int len, uint16_t *T, uint8_t *U, uint8_t *N, char *number)
{
_decode_outgoing(data, len, T, U , N, number);
PDEBUG(DMUP, DEBUG_INFO, "(BS GVWAF) Gehender Verbindungs-Warteschlange-Auftrag der BS: FuTln=%d,%d,%d (0161-%d%d%05d) number=%s\n", *N, *U, *T, *N, *U, *T, number);
}
/* ack to MO call */
int encode_gvpqu(uint8_t *opcode, uint8_t **data, uint8_t P, uint8_t e)
{
static uint8_t buffer[2];
PDEBUG(DMUP, DEBUG_INFO, "(MSC GVPQU) Verbindungs-Positiv-Quittiung vom MSC: Prio=%d (%s) AP-Pruefung=%d\n", P, prio_string(P), e);
*opcode = OPCODE_GVNQU;
buffer[0] = P;
buffer[1] = e;
*data = buffer;
return sizeof(buffer);
}
/* nack to MO call */
int encode_gvnqu(uint8_t *opcode, uint8_t **data, uint8_t X, uint8_t Y)
{
static uint8_t buffer[2];
PDEBUG(DMUP, DEBUG_INFO, "(MSC GVNQU) Verbindungs-Negativ-Quittiung vom MSC: Grund=%d (%s) Grund(FuTlg)=%d (%s)\n", X, fufst_cause(X), Y, futln_cause(Y));
*opcode = OPCODE_GVNQU;
buffer[0] = X;
buffer[1] = Y;
*data = buffer;
return sizeof(buffer);
}
/* MT call */
int encode_kvau(uint8_t *opcode, uint8_t **data, uint16_t T, uint8_t U, uint8_t N, uint8_t F, uint8_t e)
{
static uint8_t buffer[5];
PDEBUG(DMUP, DEBUG_INFO, "(MSC KVAU) Kommender Verbindungs-Auftrag vom MSC: FuTln=%d,%d,%d (0161-%d%d%05d) Rufzeitbegrenzung=%d (%s) AP-Pruefung=%d\n", N, U, T, N, U, T, F, rufzeit_string(F), e);
*opcode = OPCODE_KVAU;
buffer[0] = T;
buffer[1] = T >> 8;
buffer[2] = U | (N << 5);
buffer[3] = F;
buffer[4] = e;
*data = buffer;
return sizeof(buffer);
}
/* ack to MT call on queue */
void decode_kvwqf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS KVWQF) Kommende Verbindungs-Warteschalngen-Quittung der BS\n");
}
/* answer of MT call */
void decode_kvbaf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS KVBAF) Kommende Verbindungs-Beginn-Auftrag der BS\n");
}
/* loop test request */
void decode_staf(uint8_t *data, int len, uint8_t *Q, uint8_t *V, uint8_t *e, uint64_t *n)
{
if (len < 10) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*Q = data[0];
*V = data[1] & 1;
*e = (data[1] >> 1) & 1;
*n = (uint64_t)data[2];
*n |= (uint64_t)data[3] << 8;
*n |= (uint64_t)data[4] << 16;
*n |= (uint64_t)data[5] << 24;
*n |= (uint64_t)data[6] << 32;
*n |= (uint64_t)data[7] << 40;
*n |= (uint64_t)data[8] << 48;
*n |= (uint64_t)data[9] << 56;
PDEBUG(DMUP, DEBUG_INFO, "(BS STAF) Schleifentest-Auftrag der BS: SPK=%d Typ=%d (%s) AP-Pruefung=%d Random=0x%016" PRIx64 "\n", *Q, *V, typ_string(*V), *e, *n);
}
/* loop test positive */
int encode_stpqu(uint8_t *opcode, uint8_t **data, uint8_t Q, uint8_t A, uint8_t K, uint16_t G, uint8_t U, uint8_t X, uint8_t Y, uint8_t mystery)
{
static uint8_t buffer[7];
PDEBUG(DMUP, DEBUG_INFO, "(MSC STPQU) Schleifentest-Positiv-Quittiung vom MSC: SPK=%d\n", Q);
*opcode = OPCODE_STPQU;
buffer[0] = Q;
buffer[1] = A;
buffer[2] = K;
buffer[3] = G;
buffer[4] = G >> 8;
buffer[5] = (X << 7) | U;
buffer[6] = (Y << 7) | (mystery << 1);
*data = buffer;
return sizeof(buffer);
}
/* loop test negative */
int encode_stnqu(uint8_t *opcode, uint8_t **data, uint8_t Q)
{
static uint8_t buffer[1];
PDEBUG(DMUP, DEBUG_INFO, "(MSC STNQU) Schleifentest-Negativ-Quittiung vom MSC: SPK=%d\n", Q);
*opcode = OPCODE_STNQU;
buffer[0] = Q;
*data = buffer;
return sizeof(buffer);
}
/* authentication response */
void decode_apf(uint8_t *data, int len, uint8_t *Q, uint64_t *a)
{
if (len < 9) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*Q = data[0];
*a = (uint64_t)data[1];
*a |= (uint64_t)data[2] << 8;
*a |= (uint64_t)data[3] << 16;
*a |= (uint64_t)data[4] << 24;
*a |= (uint64_t)data[5] << 32;
*a |= (uint64_t)data[6] << 40;
*a |= (uint64_t)data[7] << 48;
*a |= (uint64_t)data[8] << 56;
PDEBUG(DMUP, DEBUG_INFO, "(BS APF) Autorisierunsparameter FUKO: SPK=%d AP=0x%016" PRIx64 "\n", *Q, *a);
}
/* start metering pulses (answer to call) */
int encode_gstau(uint8_t *opcode, uint8_t **data, uint8_t Q, uint16_t G, uint8_t U, uint8_t Y, uint8_t A, uint8_t K)
{
static uint8_t buffer[6];
PDEBUG(DMUP, DEBUG_INFO, "(MSC GSTAU) Gebuehren-Start-Auftrag vom MSC: SPK=%d\n", Q);
*opcode = OPCODE_GSTAU;
buffer[0] = Q;
buffer[1] = G;
buffer[2] = G >> 8;
buffer[3] = (Y << 7) | U;
buffer[4] = A;
buffer[5] = K;
*data = buffer;
return sizeof(buffer);
}
/* MCID */
void decode_faf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS FAF) Fang-Auftrag der BS\n");
}
/* release by base station (before SPK assignment) */
void decode_naf(uint8_t *data, int len, uint8_t *X)
{
if (len < 1) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*X = data[0];
PDEBUG(DMUP, DEBUG_INFO, "(BS AAF) Negativ-Auftrag der BS: Grund=%d (%s)\n", *X, fufst_cause(*X));
}
/* release by base station ack (before SPK assignment) */
int encode_equ(uint8_t *opcode, uint8_t **data)
{
PDEBUG(DMUP, DEBUG_INFO, "(MSC AQU) Ende-Quittung vom MSC\n");
*opcode = OPCODE_EQU;
*data = NULL;
return 0;
}
/* release by base station (after SPK assignment) */
void decode_aaf(uint8_t *data, int len, uint8_t *Q, uint8_t *X)
{
if (len < 2) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*Q = data[0];
*X = data[1];
PDEBUG(DMUP, DEBUG_INFO, "(BS AAF) Ausloese-Auftrag der BS: SPK=%d, Grund=%d (%s)\n", *Q, *X, fufst_cause(*X));
}
/* release by base station ack (after SPK assignment) */
int encode_aqu(uint8_t *opcode, uint8_t **data, uint8_t Q)
{
static uint8_t buffer[1];
PDEBUG(DMUP, DEBUG_INFO, "(MSC AQU) Ausloese-Quittung vom MSC: SPK=%d\n", Q);
*opcode = OPCODE_AQU;
buffer[0] = Q;
*data = buffer;
return sizeof(buffer);
}
/* release by network (before SPK assignment) */
int encode_nau(uint8_t *opcode, uint8_t **data, uint8_t X, uint8_t Y)
{
static uint8_t buffer[2];
PDEBUG(DMUP, DEBUG_INFO, "(MSC NAU) Negativ-Auftrag vom MSC: Grund=%d (%s) Grund(FuTlg)=%d (%s)\n", X, fufst_cause(X), Y, futln_cause(Y));
*opcode = OPCODE_NAU;
buffer[0] = X;
buffer[1] = Y;
*data = buffer;
return sizeof(buffer);
}
/* release by network ack (before SPK assignment) */
void decode_eqf(uint8_t __attribute__((unused)) *data, int __attribute__((unused)) len)
{
PDEBUG(DMUP, DEBUG_INFO, "(BS EQF) Ende-Quittung der BS\n");
}
/* release by network (after SPK assignment) */
int encode_aau(uint8_t *opcode, uint8_t **data, uint8_t Q, uint8_t X, uint8_t Y)
{
static uint8_t buffer[3];
PDEBUG(DMUP, DEBUG_INFO, "(MSC AAU) Ausloese-Auftrag vom MSC: SPK=%d, Grund=%d (%s) Grund(FuTlg)=%d (%s)\n", Q, X, fufst_cause(X), Y, futln_cause(Y));
*opcode = OPCODE_AAU;
buffer[0] = Q;
buffer[1] = X;
buffer[2] = Y;
*data = buffer;
return sizeof(buffer);
}
/* release by network ack (after SPK assignment) */
void decode_aqf(uint8_t *data, int len, uint8_t *Q)
{
if (len < 1) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*Q = data[0];
PDEBUG(DMUP, DEBUG_INFO, "(BS AQF) Ausloese-Quittung der BS: SPK=%d\n", *Q);
}
/* request data base block */
void decode_xadbf(uint8_t *data, int len, uint8_t *PJ, uint16_t *D, uint16_t *L)
{
if (len < 6) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*PJ = data[1];
*D = data[2] | (data[3] << 8);
*L = data[4] | (data[5] << 8);
PDEBUG(DMUP, DEBUG_INFO, "(BS XADBF) Auftragssign. Anfordern BS-DB-Datenblock am MSC: job=%d, offset=0x%02x length=0x%02x\n", *PJ, *D, *L);
}
/* transfer data base block */
int encode_xedbu_1(uint8_t *opcode, uint8_t **data, uint8_t R, uint8_t PJ, uint16_t A)
{
static uint8_t buffer[4];
PDEBUG(DMUP, DEBUG_INFO, "(MSC XEDBU) Ergebnissignal. Transfer BS-DB-Datenblock (header): return=%d job=%d frames=%d\n", R, PJ, A);
*opcode = OPCODE_XEDBU;
buffer[0] = R;
buffer[1] = PJ;
buffer[2] = A;
buffer[3] = A >> 8;
*data = buffer;
return sizeof(buffer);
}
int encode_xedbu_2(uint8_t *opcode, uint8_t **data, uint8_t S, uint8_t PJ, uint8_t *P)
{
static uint8_t buffer[11];
if (debuglevel == DEBUG_DEBUG)
PDEBUG(DMUP, DEBUG_INFO, "(MSC XEDBU) Ergebnissignal. Transfer BS-DB-Datenblock (data): count=%d job=%d data=%s\n", S, PJ, debug_hex(P, 9));
else if (S == 1)
PDEBUG(DMUP, DEBUG_INFO, "(MSC XEDBU) Ergebnissignal. Transfer BS-DB-Datenblock (data): Messages are not shown, due to heavy debug output!\n");
*opcode = OPCODE_XEDBU;
buffer[0] = S;
buffer[1] = PJ;
memcpy(buffer + 2, P, 9);
*data = buffer;
return sizeof(buffer);
}
int encode_xedbu_3(uint8_t *opcode, uint8_t **data, uint8_t S, uint8_t PJ, uint16_t D, uint16_t L, uint32_t CS)
{
static uint8_t buffer[9];
PDEBUG(DMUP, DEBUG_INFO, "(MSC XEDBU) Ergebnissignal. Transfer BS-DB-Datenblock (footer): count=%d job=%d offset=0x%02x length=0x%02x checksum=0x%06x\n", S, PJ, D, L, CS);
*opcode = OPCODE_XEDBU;
buffer[0] = S;
buffer[1] = PJ;
buffer[2] = D;
buffer[3] = D >> 8;
buffer[4] = L;
buffer[5] = L >> 8;
buffer[6] = CS;
buffer[7] = CS >> 8;
buffer[8] = CS >> 16;
*data = buffer;
return sizeof(buffer);
}
/* BS reboot order */
int encode_yaaau(uint8_t *opcode, uint8_t **data, uint8_t J)
{
static uint8_t buffer[2];
PDEBUG(DMUP, DEBUG_INFO, "(MSC YAAAU) Auftrag Initialisieren BS des MSC: job=%d\n", J);
*opcode = OPCODE_YAAAU;
buffer[0] = 0xff;
buffer[1] = J;
*data = buffer;
return sizeof(buffer);
}
/* MSC boots */
int encode_swau(uint8_t *opcode, uint8_t **data, uint8_t V)
{
static uint8_t buffer[1];
PDEBUG(DMUP, DEBUG_INFO, "(MSC SWAU) Wiederanlaufauftrag des MSC: version=%d (%s)\n", V, version_string(V));
*opcode = OPCODE_SWAU;
buffer[0] = V;
*data = buffer;
return sizeof(buffer);
}
/* ack to MSC boot */
void decode_swqf(uint8_t *data, int len, uint8_t *V, uint8_t *N, uint8_t *U, uint8_t *F, uint8_t *C, uint8_t *B)
{
if (len < 6) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return;
}
*V = data[0];
*N = data[1];
*U = data[2];
*F = data[3];
*C = data[4];
*B = data[5];
PDEBUG(DMUP, DEBUG_INFO, "(BS SWQF) Wiederanlauf-Quittung der BS: version=%d (%s) FuFSt=%d,%d,%d chip=%d (%s) beacon=%d (%s)\n", *V, version_string(*V), *N, *U, *F, *C, chip_string(*C), *B, beacon_string(*B));
}
/* request "Aktivdatei" (inscripted substribers) */
void encode_sadau(uint8_t *opcode)
{
*opcode = OPCODE_SADAU;
PDEBUG(DMUP, DEBUG_INFO, "(MSC SADAU) Aktivdatei-Auftrag vom MSC\n");
}
/* ack "Aktivdatei" */
int decode_sadqf(uint8_t *data, int len, uint16_t *S, uint8_t *E, uint8_t *l, uint16_t *T, uint8_t *U, uint8_t *N)
{
int i, n = 0;
if (len < 11) {
PDEBUG(DMUP, DEBUG_NOTICE, "Message too short!\n");
return 0;
}
*S = ((data[1] & 0xf) << 4) | data[0];
*E = data[1] >> 7;
for (i = 0; i < 3; i++) {
l[n] = (data[1] >> (6 - i)) & 0x1;
T[n] = (data[3 + (i * 3)] << 8) | data[2 + (i * 3)];
U[n] = data[4 + (i * 3)] & 0x1f;
N[n] = data[4 + (i * 3)] >> 5;
if (T[n] != 0 || U[n] != 0 || N[n] != 0)
n++;
}
PDEBUG(DMUP, DEBUG_INFO, "(BS SADQF) Aktivdateiquittung der BS:\n");
for (i = 0; i < n; i++)
PDEBUG(DMUP, DEBUG_INFO, " %d: FuTln=%d,%d,%d (0161-%d%d%05d)\n", i + 1, N[i], U[i], T[i], N[i], U[i], T[i]);
return n;
}
Reference in New Issue View Git Blame Copy Permalink