mirror/ULib
1
0
Fork 0
mirror of https://github.com/stefanocasazza/ULib.git synced 2025-09-28 19:05:55 +08:00
Code Issues Releases Wiki Activity
9c8b17c297
ULib/examples/PEC_log/PEC_report_anomalie.cpp
stefanocasazza b6ee1e71fd fix
2017-07-25 12:41:44 +02:00

954 lines
30 KiB
C++
Raw Blame History

// PEC_report_anomalie.cpp
#include "PEC_report_anomalie.h"
#include <ulib/container/hash_map.h>
time_t Messaggio::now;
time_t Messaggio::max_ttl;
time_t Messaggio::range_ttl;
UString* Messaggio::id_max_ttl;
Messaggio* Messaggio::msg;
uint32_t PEC_report_anomalie::nmsg;
uint32_t PEC_report_anomalie::nanomalie;
uint32_t PEC_report_anomalie::nout_of_range;
#define U_OUTPUT 0
#define U_CONSEGNA 1
#define U_ACCETTAZIONE 2
#define U_BUSTA_TRASPORTO 3
#define U_PRESA_IN_CARICO 4
#define U_MITTENTE_CHANGE 5
#define U_RILEVAZIONE_VIRUS 6
#define U_DESTINATARI_CHANGE 7
#define U_ERROR_MESSAGE_INCORRECT_MESSAGE "incoherent message - id = <%.*s>"
#ifdef U_COVERITY_FALSE_POSITIVE
#define U_MEMSET_VALUE 0
#else
#define U_MEMSET_VALUE '0'
#endif
static inline void swap(time_t& a, time_t& b)
{
U_TRACE(5, "::swap(%p,%p)", &a, &b)
time_t tmp = a;
a = b;
b = tmp;
}
inline void Messaggio::allocDestinatari(int n)
{
U_TRACE(5, "Messaggio::allocDestinatari(%d)", n)
U_CHECK_MEMORY
vdestinatari_domini = (char*) malloc(n+1);
vdestinatari_certificati = (char*) malloc(n+1);
vdestinatari_presa_in_carico = (char*) malloc(n+1);
vdestinatari_mancata_consegna = (char*) malloc(n+1);
vdestinatari_avvenuta_consegna = (char*) malloc(n+1);
vdestinatari_rilevazione_virus = (char*) malloc(n+1);
vdestinatari_mancata_consegna_virus = (char*) malloc(n+1);
// coverity[NO_EFFECT]
(void) memset(vdestinatari_presa_in_carico, U_MEMSET_VALUE, n);
(void) memset(vdestinatari_mancata_consegna, U_MEMSET_VALUE, n);
(void) memset(vdestinatari_avvenuta_consegna, U_MEMSET_VALUE, n);
(void) memset(vdestinatari_rilevazione_virus, U_MEMSET_VALUE, n);
(void) memset(vdestinatari_mancata_consegna_virus, U_MEMSET_VALUE, n);
vdestinatari_domini[n] =
vdestinatari_certificati[n] =
vdestinatari_presa_in_carico[n] =
vdestinatari_mancata_consegna[n] =
vdestinatari_avvenuta_consegna[n] =
vdestinatari_rilevazione_virus[n] =
vdestinatari_mancata_consegna_virus[n] = '\0';
}
Messaggio::Messaggio() : id(*PEC_report::id), mittente(*PEC_report::mittente), identifier(*PEC_report::identifier)
{
U_TRACE_REGISTER_OBJECT(5, Messaggio, "")
(void) memset(flag, U_MEMSET_VALUE, sizeof(flag));
ttl = 0;
start = PEC_report::nseconds + PEC_report::getTime();
destinatari = PEC_report::getValueField(U_destinatari);
U_INTERNAL_DUMP("start = %ld (%#19D)", start, start)
U_INTERNAL_DUMP("PEC_report::nseconds = %ld (%#19D)", PEC_report::nseconds, PEC_report::nseconds)
// NB: need duplicate string because depends on mmap()'s content of document...
id.duplicate();
mittente.duplicate();
identifier.duplicate();
destinatari.duplicate();
UVector<UString> vec(destinatari, ", ");
UString elem;
uint32_t n = vec.size();
char* vdestcert = (char*) malloc(n+1);
char* vdestdomini = (char*) malloc(n+1);
// coverity[NO_EFFECT]
(void) memset(vdestcert, U_MEMSET_VALUE, n);
(void) memset(vdestdomini, U_MEMSET_VALUE, n);
for (uint32_t i = 0; i < n; ++i)
{
elem = vec.at(i);
if (elem.c_char(0) == '(')
{
if (memcmp(elem.data(), U_CONSTANT_TO_PARAM("(certificato")) == 0) vdestcert[vdestinatari.size()-1] = '1';
continue;
}
vdestdomini[vdestinatari.size()] = (PEC_report::isDomainAddress(elem) ? '1' : '0');
vdestinatari.push_back(elem);
}
n = vdestinatari.size();
allocDestinatari(n);
U_MEMCPY(vdestinatari_domini, vdestdomini, n);
U_MEMCPY(vdestinatari_certificati, vdestcert, n);
free(vdestcert);
free(vdestdomini);
U_INTERNAL_DUMP("vdestinatari_certificati = %S", vdestinatari_certificati)
U_INTERNAL_DUMP("vdestinatari_domini = %S", vdestinatari_domini)
}
Messaggio::~Messaggio()
{
U_TRACE_UNREGISTER_OBJECT(5, Messaggio)
free(vdestinatari_domini);
free(vdestinatari_certificati);
free(vdestinatari_presa_in_carico);
free(vdestinatari_mancata_consegna);
free(vdestinatari_avvenuta_consegna);
free(vdestinatari_rilevazione_virus);
free(vdestinatari_mancata_consegna_virus);
}
bool Messaggio::setRicezione(const UString& elem)
{
U_TRACE(5, "Messaggio::setRicezione(%.*S)", U_STRING_TO_TRACE(elem))
// 3) Ogni indirizzo email certificato contenuto nel campo destinatari di una busta di trasporto, dovrà apparire una sola
// volta nell'attributo ricezione di una presa in carico/rilevazione virus con lo stesso identificativo
uint32_t i = msg->vdestinatari.find(elem, true);
if (i == U_NOT_FOUND ||
msg->vdestinatari_certificati[i] == '0')
{
if (PEC_report::tipology[U_presa_in_carico])
{
msg->flag[U_PRESA_IN_CARICO] = '1';
}
else
{
U_INTERNAL_ASSERT(PEC_report::tipology[U_rilevazione_virus])
msg->flag[U_RILEVAZIONE_VIRUS] = '1';
}
}
else if (PEC_report::tipology[U_presa_in_carico])
{
msg->vdestinatari_presa_in_carico[i] += 1;
}
else
{
U_INTERNAL_ASSERT(PEC_report::tipology[U_rilevazione_virus])
msg->vdestinatari_rilevazione_virus[i] += 1;
}
U_RETURN(false);
}
bool Messaggio::setConsegna(const UString& elem)
{
U_TRACE(5, "Messaggio::setConsegna(%.*S)", U_STRING_TO_TRACE(elem))
// 5) Ogni indirizzo email certificato contenuto nel campo destinatari di una busta di trasporto, dovrà apparire una sola
// volta nell'attributo consegna di una avvenuta/mancata consegna con lo stesso identificativo
uint32_t i = msg->vdestinatari.find(elem, true);
if (i == U_NOT_FOUND ||
msg->vdestinatari_certificati[i] == '0')
{
if (PEC_report::tipology[U_errore_consegna] ||
PEC_report::tipology[U_avvenuta_consegna])
{
msg->flag[U_CONSEGNA] = '1';
}
else
{
U_INTERNAL_ASSERT(PEC_report::tipology[U_rilevazione_virus])
msg->flag[U_RILEVAZIONE_VIRUS] = '1';
}
}
else if (PEC_report::tipology[U_errore_consegna])
{
msg->vdestinatari_mancata_consegna[i] += 1;
bool errore_virus = PEC_report::checkValueField(U_errore, U_STRING_FROM_CONSTANT("virus"));
U_INTERNAL_DUMP("errore_virus = %b", errore_virus)
if (errore_virus) msg->vdestinatari_mancata_consegna_virus[i] += 1;
}
else if (PEC_report::tipology[U_avvenuta_consegna])
{
msg->vdestinatari_avvenuta_consegna[i] += 1;
}
else
{
U_INTERNAL_ASSERT(PEC_report::tipology[U_rilevazione_virus])
msg->vdestinatari_rilevazione_virus[i] += 1;
}
U_RETURN(false);
}
void PEC_report_anomalie::processLine(bool bnew)
{
U_TRACE(5, "PEC_report_anomalie::processLine(%b)", bnew)
if (bnew == false)
{
Messaggio::now = PEC_report::nseconds + PEC_report::getTime();
if (Messaggio::now < Messaggio::msg->start) swap(Messaggio::now, Messaggio::msg->start);
Messaggio::msg->ttl = (Messaggio::now - Messaggio::msg->start);
if (Messaggio::id_max_ttl &&
Messaggio::msg->ttl > Messaggio::max_ttl)
{
Messaggio::max_ttl = Messaggio::msg->ttl;
*Messaggio::id_max_ttl = Messaggio::msg->identifier;
U_INTERNAL_DUMP("Messaggio::max_ttl = %ld", Messaggio::max_ttl)
U_INTERNAL_DUMP("Messaggio::id_max_ttl = %.*S", U_STRING_TO_TRACE(*Messaggio::id_max_ttl))
}
if (Messaggio::msg->ttl > Messaggio::range_ttl)
{
static UString* prev_id_ttl;
if (prev_id_ttl != PEC_report::identifier)
{
prev_id_ttl = PEC_report::identifier;
++nout_of_range;
U_WARNING(U_ERROR_MESSAGE_OUT_OF_TTL, Messaggio::msg->ttl / U_ONE_DAY_IN_SECOND,
Messaggio::range_ttl / U_ONE_DAY_IN_SECOND,
U_STRING_TO_TRACE(*PEC_report::identifier));
}
}
if (Messaggio::msg->flag[U_MITTENTE_CHANGE] == '1' ||
Messaggio::msg->flag[U_DESTINATARI_CHANGE] == '1') return;
if (mittente->equalnocase(Messaggio::msg->mittente) == false)
{
Messaggio::msg->flag[U_MITTENTE_CHANGE] = '1';
if (tipology[U_posta_certificata]) Messaggio::msg->mittente.replace(*mittente);
return;
}
UString destinatari = PEC_report::getValueField(U_destinatari);
if (destinatari.equalnocase(Messaggio::msg->destinatari) == false)
{
Messaggio::msg->flag[U_DESTINATARI_CHANGE] = '1';
return;
}
}
if (tipology[U_posta_certificata])
{
// 1) Deve esistere una BustaTrasporto (tipo=posta-certificata)
Messaggio::msg->flag[U_BUSTA_TRASPORTO] += 1;
U_INTERNAL_DUMP("flag[U_BUSTA_TRASPORTO] = %C", Messaggio::msg->flag[U_BUSTA_TRASPORTO])
// check if messaggio incoerente
if (PEC_report::isDomainAddress(Messaggio::msg->mittente)) Messaggio::msg->flag[U_OUTPUT] = '1';
U_INTERNAL_DUMP("flag[U_OUTPUT] = %C", Messaggio::msg->flag[U_OUTPUT])
if (Messaggio::msg->flag[U_OUTPUT] == '0' &&
u_atoi(Messaggio::msg->vdestinatari_domini) == 0)
{
U_WARNING(U_ERROR_MESSAGE_INCORRECT_MESSAGE, U_STRING_TO_TRACE(*PEC_report::identifier));
}
}
else if (tipology[U_accettazione])
{
// 2) Per una BustaTrasporto (tipo=posta-certificata) dove il mittente appartiene a dominio specificato
// deve esistere una sola Accettazione (tipo=accettazione)
Messaggio::msg->flag[U_ACCETTAZIONE] += 1;
}
else if (tipology[U_presa_in_carico])
{
(void) PEC_report::callForAllEntryField(U_ricezione, Messaggio::setRicezione);
}
else if (tipology[U_errore_consegna])
{
(void) PEC_report::callForAllEntryField(U_consegna, Messaggio::setConsegna);
}
else if (tipology[U_avvenuta_consegna])
{
(void) PEC_report::callForAllEntryField(U_consegna, Messaggio::setConsegna);
}
else if (tipology[U_rilevazione_virus])
{
// from version > 2.0...
// int U_field = U_consegna;
UString U_value = getValueField(U_consegna);
bPFstr U_function = Messaggio::setConsegna;
if (U_value.empty())
{
// U_field = U_ricezione;
U_value = getValueField(U_ricezione);
U_function = Messaggio::setRicezione;
}
(void) PEC_report::callForAllEntryField(U_value, U_function);
}
// cerr << *Messaggio::msg << std::endl;
}
bool Messaggio::isAnomalia()
{
U_TRACE(5, "Messaggio::isAnomalia()")
U_CHECK_MEMORY
if (flag[U_BUSTA_TRASPORTO] == '0')
{
if (PEC_report::isDomainAddress(mittente)) flag[U_OUTPUT] = '1';
U_INTERNAL_DUMP("flag[U_OUTPUT] = %C", flag[U_OUTPUT])
}
if (flag[U_MITTENTE_CHANGE] == '1' ||
flag[U_DESTINATARI_CHANGE] == '1' ||
flag[U_BUSTA_TRASPORTO] != '1' ||
flag[U_CONSEGNA] != '0' ||
flag[U_PRESA_IN_CARICO] != '0' ||
flag[U_RILEVAZIONE_VIRUS] != '0' ||
flag[U_OUTPUT] != flag[U_ACCETTAZIONE])
{
U_INTERNAL_DUMP("flag[U_OUTPUT] = %C", Messaggio::msg->flag[U_OUTPUT])
U_INTERNAL_DUMP("flag[U_ACCETTAZIONE] = %C", Messaggio::msg->flag[U_ACCETTAZIONE])
U_INTERNAL_DUMP("flag[U_CONSEGNA] = %C", Messaggio::msg->flag[U_CONSEGNA])
U_INTERNAL_DUMP("flag[U_BUSTA_TRASPORTO] = %C", Messaggio::msg->flag[U_BUSTA_TRASPORTO])
U_INTERNAL_DUMP("flag[U_PRESA_IN_CARICO] = %C", Messaggio::msg->flag[U_PRESA_IN_CARICO])
U_INTERNAL_DUMP("flag[U_MITTENTE_CHANGE] = %C", Messaggio::msg->flag[U_MITTENTE_CHANGE])
U_INTERNAL_DUMP("flag[U_RILEVAZIONE_VIRUS] = %C", Messaggio::msg->flag[U_RILEVAZIONE_VIRUS])
U_INTERNAL_DUMP("flag[U_DESTINATARI_CHANGE] = %C", Messaggio::msg->flag[U_DESTINATARI_CHANGE])
U_RETURN(true);
}
for (uint32_t i = 0, n = vdestinatari.size(); i < n; ++i)
{
/*
3A) Per ogni rilevazione virus con lo stesso identificativo ci deve essere una sola mancata consegna (errore=virus)
con cui il campo consegna coincide
3B) Per ogni mancata consegna (errore=virus) con lo stesso identificativo ci deve essere una sola rilevazione virus
con cui il campo consegna coincide
*/
if ((flag[U_OUTPUT] == '1') &&
(vdestinatari_rilevazione_virus[i] != vdestinatari_mancata_consegna_virus[i]))
{
U_INTERNAL_DUMP("vdestinatari_rilevazione_virus[%d] = %C", i, vdestinatari_rilevazione_virus[i])
U_INTERNAL_DUMP("vdestinatari_mancata_consegna_virus[%d] = %C", i, vdestinatari_mancata_consegna_virus[i])
U_RETURN(true);
}
if (vdestinatari_certificati[i] == '0')
{
if (vdestinatari_presa_in_carico[i] != '0' ||
vdestinatari_mancata_consegna[i] != '0' ||
vdestinatari_avvenuta_consegna[i] != '0' ||
vdestinatari_rilevazione_virus[i] != '0')
{
U_RETURN(true);
}
}
else
{
if (flag[U_OUTPUT] == '1')
{
// msg SPEDITO - tutti i destinatari CERTIFICATI...
if (vdestinatari_presa_in_carico[i] != '1'||
((vdestinatari_mancata_consegna[i] - '0') +
(vdestinatari_avvenuta_consegna[i] - '0')) != 1)
{
U_RETURN(true);
}
}
else
{
// msg RICEVUTO - tutti i destinatari CERTIFICATI di domini APPARTENENTI a domini specificati...
if (vdestinatari_domini[i] == '1')
{
if (vdestinatari_presa_in_carico[i] != '1')
{
U_RETURN(true);
}
if (((vdestinatari_mancata_consegna[i] - '0') +
(vdestinatari_avvenuta_consegna[i] - '0') +
(vdestinatari_rilevazione_virus[i] - '0')) != 1)
{
U_RETURN(true);
}
}
else
{
// ...i destinatari CERTIFICATI DEVONO appartenere a domini specificati...
if (vdestinatari_presa_in_carico[i] != '0' ||
vdestinatari_mancata_consegna[i] != '0' ||
vdestinatari_avvenuta_consegna[i] != '0' ||
vdestinatari_rilevazione_virus[i] != '0')
{
U_RETURN(true);
}
}
}
}
}
U_RETURN(false);
}
void PEC_report_anomalie::reportDestinatari(void* elem)
{
U_TRACE(5, "PEC_report_anomalie::reportDestinatari(%p)", elem)
UStringRep* str = (UStringRep*)elem;
UString tmp(U_CAPACITY);
UXMLEscape::encode(UString(str), tmp);
(void) sprintf(buffer, U_XML_MSG_ENTRY_Recipients, U_STRING_TO_TRACE(tmp));
std::cout << buffer;
}
bool PEC_report_anomalie::reportAnomalie(UStringRep* key, void* elem)
{
U_TRACE(5, "PEC_report_anomalie::reportAnomalie(%p,%p)", key, elem)
U_INTERNAL_ASSERT_POINTER(elem);
Messaggio::msg = (Messaggio*)elem;
++nanomalie;
UString tmp1(U_CAPACITY), tmp2(U_CAPACITY);
UXMLEscape::encode(Messaggio::msg->identifier, tmp1);
UXMLEscape::encode(Messaggio::msg->mittente, tmp2);
(void) sprintf(buffer, U_XML_MSG_ENTRY_START,
Messaggio::msg->flag[U_OUTPUT] == '1' ? "Output" : "Input",
U_STRING_TO_TRACE(tmp1),
Messaggio::msg->getData(),
U_STRING_TO_TRACE(Messaggio::msg->id),
U_STRING_TO_TRACE(tmp2));
std::cout << buffer;
Messaggio::msg->vdestinatari.callForAllEntry(PEC_report_anomalie::reportDestinatari);
if (Messaggio::msg->flag[U_MITTENTE_CHANGE] == '1')
{
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Mittente incoerente");
std::cout << buffer;
}
if (Messaggio::msg->flag[U_DESTINATARI_CHANGE] == '1')
{
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Destinatari incoerenti");
std::cout << buffer;
}
const char* testo;
uint32_t num_consegne, i, n;
bool flag_presa_in_carico_mancante, flag_presa_in_carico_duplicato, flag_consegna_mancante, flag_consegna_duplicato;
if (Messaggio::msg->flag[U_MITTENTE_CHANGE] == '1' ||
Messaggio::msg->flag[U_DESTINATARI_CHANGE] == '1') goto end;
if (Messaggio::msg->flag[U_BUSTA_TRASPORTO] != '1')
{
if (Messaggio::msg->flag[U_BUSTA_TRASPORTO] == '0')(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Busta di trasporto mancante");
else (void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Busta di trasporto duplicata");
std::cout << buffer;
}
if (Messaggio::msg->flag[U_OUTPUT] != Messaggio::msg->flag[U_ACCETTAZIONE])
{
if (Messaggio::msg->flag[U_ACCETTAZIONE] == '0') (void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Accettazione mancante");
else if (Messaggio::msg->flag[U_ACCETTAZIONE] == '1') (void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Accettazione incoerente");
else (void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Accettazione duplicata");
std::cout << buffer;
}
flag_presa_in_carico_mancante = flag_presa_in_carico_duplicato = flag_consegna_mancante = flag_consegna_duplicato = false;
for (i = 0, n = Messaggio::msg->vdestinatari.size(); i < n; ++i)
{
/*
3A) Per ogni rilevazione virus con lo stesso identificativo ci deve essere una sola mancata consegna (errore=virus)
con cui il campo consegna coincide
3B) Per ogni mancata consegna (errore=virus) con lo stesso identificativo ci deve essere una sola rilevazione virus
con cui il campo consegna coincide
*/
if ((Messaggio::msg->flag[U_OUTPUT] == '1') &&
(Messaggio::msg->vdestinatari_rilevazione_virus[i] !=
Messaggio::msg->vdestinatari_mancata_consegna_virus[i]))
{
if (Messaggio::msg->vdestinatari_rilevazione_virus[i] == '0')
{
testo = "Rilevazione virus mancante per un destinatario";
}
else if (Messaggio::msg->vdestinatari_mancata_consegna_virus[i] == '0')
{
testo = "Mancata consegna virus mancante per un destinatario";
}
else
{
if (Messaggio::msg->vdestinatari_rilevazione_virus[i] >
Messaggio::msg->vdestinatari_mancata_consegna_virus[i])
{
testo = "Rilevazione virus duplicata per un destinatario";
}
else
{
U_INTERNAL_ASSERT_MINOR(Messaggio::msg->vdestinatari_rilevazione_virus[i],
Messaggio::msg->vdestinatari_mancata_consegna_virus[i])
testo = "Mancata consegna virus duplicata per un destinatario";
}
}
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, testo);
std::cout << buffer;
}
// destinatari NON CERTIFICATI...
if (Messaggio::msg->vdestinatari_certificati[i] == '0')
{
// 4A
if (Messaggio::msg->vdestinatari_presa_in_carico[i] != '0')
{
Messaggio::msg->flag[U_PRESA_IN_CARICO] = '1';
}
// 4B
if (Messaggio::msg->vdestinatari_rilevazione_virus[i] != '0')
{
Messaggio::msg->flag[U_RILEVAZIONE_VIRUS] = '1';
}
// 5
if (Messaggio::msg->vdestinatari_mancata_consegna[i] != '0' ||
Messaggio::msg->vdestinatari_avvenuta_consegna[i] != '0')
{
Messaggio::msg->flag[U_CONSEGNA] = '1';
}
}
else
{
if (Messaggio::msg->flag[U_OUTPUT] == '1')
{
// msg SPEDITO - tutti i destinatari CERTIFICATI...
if (Messaggio::msg->vdestinatari_presa_in_carico[i] != '1')
{
if (Messaggio::msg->vdestinatari_presa_in_carico[i] == '0')
{
if (flag_presa_in_carico_mancante) continue;
flag_presa_in_carico_mancante = true;
testo = "Presa in carico mancante per almeno un destinatario";
}
else
{
if (flag_presa_in_carico_duplicato) continue;
flag_presa_in_carico_duplicato = true;
testo = "Presa in carico duplicata per almeno un destinatario";
}
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, testo);
std::cout << buffer;
}
num_consegne = (Messaggio::msg->vdestinatari_mancata_consegna[i] - '0') +
(Messaggio::msg->vdestinatari_avvenuta_consegna[i] - '0');
U_INTERNAL_DUMP("num_consegne = %u", num_consegne)
if (num_consegne != 1)
{
if (num_consegne == 0)
{
if (flag_consegna_mancante) continue;
flag_consegna_mancante = true;
testo = "Avvenuta consegna o errore consegna mancante per almeno un destinatario";
}
else
{
if (flag_consegna_duplicato) continue;
flag_consegna_duplicato = true;
testo = (Messaggio::msg->vdestinatari_mancata_consegna[i] != '0' &&
Messaggio::msg->vdestinatari_avvenuta_consegna[i] != '0')
? "Avvenuta consegna o errore consegna in conflitto per almeno un destinatario"
: "Avvenuta consegna o errore consegna duplicata per almeno un destinatario";
}
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, testo);
std::cout << buffer;
}
}
else
{
// msg RICEVUTO - tutti i destinatari CERTIFICATI di domini APPARTENENTI a domini specificati...
if (Messaggio::msg->vdestinatari_domini[i] == '1')
{
if (Messaggio::msg->vdestinatari_presa_in_carico[i] != '1')
{
if (Messaggio::msg->vdestinatari_presa_in_carico[i] == '0')
{
if (flag_presa_in_carico_mancante) continue;
flag_presa_in_carico_mancante = true;
testo = "Presa in carico mancante per almeno un destinatario";
}
else
{
if (flag_presa_in_carico_duplicato) continue;
flag_presa_in_carico_duplicato = true;
testo = "Presa in carico duplicata per almeno un destinatario";
}
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, testo);
std::cout << buffer;
}
num_consegne = (Messaggio::msg->vdestinatari_mancata_consegna[i] - '0') +
(Messaggio::msg->vdestinatari_avvenuta_consegna[i] - '0') +
(Messaggio::msg->vdestinatari_rilevazione_virus[i] - '0');
U_INTERNAL_DUMP("num_consegne = %u", num_consegne)
if (num_consegne != 1)
{
if (num_consegne == 0)
{
if (flag_consegna_mancante) continue;
flag_consegna_mancante = true;
testo = "Avvenuta consegna o errore consegna o rilevazione virus mancante per almeno un destinatario";
}
else
{
if (flag_consegna_duplicato) continue;
flag_consegna_duplicato = true;
testo = (Messaggio::msg->vdestinatari_mancata_consegna[i] != '0' &&
Messaggio::msg->vdestinatari_avvenuta_consegna[i] != '0' &&
Messaggio::msg->vdestinatari_rilevazione_virus[i] != '0')
? "Avvenuta consegna o errore consegna o rilevazione virus in conflitto per almeno un destinatario"
: "Avvenuta consegna o errore consegna o rilevazione virus duplicata per almeno un destinatario";
}
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, testo);
std::cout << buffer;
}
}
else
{
// ...i destinatari CERTIFICATI DEVONO appartenere a domini specificati...
if (Messaggio::msg->vdestinatari_presa_in_carico[i] != '0')
{
Messaggio::msg->flag[U_PRESA_IN_CARICO] = '1';
}
if (Messaggio::msg->vdestinatari_rilevazione_virus[i] != '0')
{
Messaggio::msg->flag[U_RILEVAZIONE_VIRUS] = '1';
}
if (Messaggio::msg->vdestinatari_mancata_consegna[i] != '0' ||
Messaggio::msg->vdestinatari_avvenuta_consegna[i] != '0')
{
Messaggio::msg->flag[U_CONSEGNA] = '1';
}
}
}
}
}
// 4A
if (Messaggio::msg->flag[U_PRESA_IN_CARICO] != '0')
{
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Presa in carico incoerente per almeno un destinatario");
std::cout << buffer;
}
// 4B
if (Messaggio::msg->flag[U_RILEVAZIONE_VIRUS] != '0')
{
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Rilevazione virus incoerente per almeno un destinatario");
std::cout << buffer;
}
// 5
if (Messaggio::msg->flag[U_CONSEGNA] != '0')
{
(void) sprintf(buffer, U_XML_MSG_ENTRY_Exception, "Avvenuta consegna o errore consegna incoerente per almeno un destinatario");
std::cout << buffer;
}
end:
(void) sprintf(buffer, U_XML_MSG_ENTRY_END, Messaggio::msg->flag[U_OUTPUT] == '1' ? "Output" : "Input");
std::cout << buffer;
U_RETURN(true);
}
// STREAM
U_EXPORT istream& operator>>(istream& is, Messaggio& m)
{
U_TRACE(5, "Messaggio::operator>>(%p,%p)", &is, &m)
U_INTERNAL_ASSERT_EQUALS(is.peek(), '{')
is.get(); // skip '{'
is >> m.flag
>> m.start
>> m.ttl
>> m.id
>> m.mittente
>> m.identifier
>> m.destinatari;
int num_destinatari = 0;
is >> num_destinatari;
if (num_destinatari > 0) m.allocDestinatari(num_destinatari);
is >> m.vdestinatari_certificati
>> m.vdestinatari_domini
>> m.vdestinatari_presa_in_carico
>> m.vdestinatari_mancata_consegna
>> m.vdestinatari_avvenuta_consegna
>> m.vdestinatari_rilevazione_virus
>> m.vdestinatari_mancata_consegna_virus
>> m.vdestinatari;
// skip '}'
int c;
streambuf* sb = is.rdbuf();
do { c = sb->sbumpc(); } while (c != '}' && c != EOF);
if (c == EOF) is.setstate(ios::eofbit);
return is;
}
U_EXPORT ostream& operator<<(ostream& os, const Messaggio& m)
{
U_TRACE(5, "Messaggio::operator<<(%p,%p)", &os, &m)
os.put('{');
os.put(' ');
os << m.flag;
os.put(' ');
os << m.start;
os.put(' ');
os << m.ttl;
os.put(' ');
m.id.write(os);
os.put(' ');
m.mittente.write(os);
os.put(' ');
m.identifier.write(os);
os.put(' ');
m.destinatari.write(os);
os.put(' ');
os << m.vdestinatari.size();
os.put(' ');
os << m.vdestinatari_certificati;
os.put(' ');
os << m.vdestinatari_domini;
os.put(' ');
os << m.vdestinatari_presa_in_carico;
os.put(' ');
os << m.vdestinatari_mancata_consegna;
os.put(' ');
os << m.vdestinatari_avvenuta_consegna;
os.put(' ');
os << m.vdestinatari_rilevazione_virus;
os.put(' ');
os << m.vdestinatari_mancata_consegna_virus;
os.put(' ');
os << m.vdestinatari;
os.put(' ');
os.put('}');
return os;
}
#ifdef DEBUG
# include <ulib/internal/objectIO.h>
const char* Messaggio::dump(bool reset) const
{
*UObjectIO::os << "ttl " << ttl << '\n'
<< "start " << (void*)start << '\n'
<< "flag ";
char buffer[2048];
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), flag));
*UObjectIO::os << '\n'
<< "vdestinatari_domini ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_domini));
*UObjectIO::os << '\n'
<< "vdestinatari_certificati ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_certificati));
*UObjectIO::os << '\n'
<< "vdestinatari_presa_in_carico ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_presa_in_carico));
*UObjectIO::os << '\n'
<< "vdestinatari_mancata_consegna ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_mancata_consegna));
*UObjectIO::os << '\n'
<< "vdestinatari_avvenuta_consegna ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_avvenuta_consegna));
*UObjectIO::os << '\n'
<< "vdestinatari_rilevazione_virus ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_rilevazione_virus));
*UObjectIO::os << '\n'
<< "vdestinatari_mancata_consegna_virus ";
UObjectIO::os->write(buffer, u__snprintf(buffer, sizeof(buffer), U_CONSTANT_TO_PARAM("%S"), vdestinatari_mancata_consegna_virus));
*UObjectIO::os << '\n'
<< "id (UString " << (void*)&id << ")\n"
<< "mittente (UString " << (void*)&mittente << ")\n"
<< "identifier (UString " << (void*)&identifier << ")\n"
<< "destinatari (UString " << (void*)&destinatari << ")\n"
<< "vdestinatari (UVector<UString>) " << (void*)&vdestinatari << ')';
if (reset)
{
UObjectIO::output();
return UObjectIO::buffer_output;
}
return U_NULLPTR;
}
#endif
Reference in New Issue View Git Blame Copy Permalink