__ _____________ ______ ____________
/ / / / _/_ __/ | / / __ \/_ __/ ____/
/ /_/ // / / / / |/ / / / / / / / __/
/ __ // / / / / /| / /_/ / / / / /___
/_/ /_/___/ /_/ /_/ |_/\____/ /_/ /_____/ [0x05 :: February 2011]
Hackkappatoio Isn't The Name Of This Ezine
http://hitnote.gotdns.org :: http://unofficialhj.gotdns.org
**********************************
* HITNOTE 0x05 :: Happy new Fear *
**********************************
Penso che un bell'effetto narrativo sarebbe il dire:
«Al momento in cui sto scrivendo non si sa se il governo cadrà o meno,
certo è più probabile la prima rispetto alla seconda ipotesi,ma
quest'incertezza sarà risolta solo dopo che questo editoriale verrà pubblicato,
dunque adesso spunterà (spero) un sorrisetto sulla faccia del lettore
soddisfatto»
ma so che al di là della caduta di un regime dovrà esservi la
volontà popolare di risollevare un Paese stremato, agonizzante, quasi in fin di
vita, sull'orlo del default e della follia psicotica indotta da mass-media
superficiali e strumentalizzati.
Ma andiamo per gradi, eseguiamo quella che i professori di letteratura
chiamerebbero climax, in musica «crescendo».
Sono approdato su unofficialhj.gotdns.org ad Agosto e subito ho compreso che i
contenuti in mio possesso erano qualitativamente e quantitativamente inferiori
rispetto a quelli dei membri di questa piccola ma vivace community.
Il progetto Hitnote mi ha particolarmente interessato per la sua estrema
semplicità -è una ezine, un sistema vecchio come il web- nell'aggregare
contenuti gratuitamente e diligentemente spiegati da chi, per puro spirito di
condivisione e divulgazione, presta il proprio operato ai curiosi.
Questa ezine si alimenta grazie all'evoluzione del forum ospitato dal buon
r0b0t82, a cui va tutto tribuito il rispetto, nonché l'ammirazione di coloro che
usufruiscono del suo servizio, un forum dicevo modesto e serio.
Dall'altra parte della barricata c'è chi crede di essere migliore, chi pensa che
divulgare in questo modo sia una perdita di tempo, un inutile impantanarsi nella
spiegazione di cose basilari: queste persone hanno aggredito le nostre
strutture, hanno prepotentemente e violentemente tentato di impedirci la
prosecuzione del nostro umile lavoro, hanno minacciato l'esistenza
di una concorrenza che fra l'altro non è nemmeno commerciale.
Possono essere costoro i rappresentanti di chi è curioso o ama condividere?
Possono paragonarsi a quelle menti che hanno abbattuto barriere d'ogni tipo,
siano esse matematiche, politiche, teoriche, fisiche (in senso sportivo),
sociali?
La risposta è ovvia, ed induce ad una conclusione che ritengo inutile riportare.
Soffocare la libertà, o peggio ancora confonderla, mistificarla o addirittura
appropriarsi dei suoi vessilli per eliminare in modo poco ortodosso la sgradita
concorrenza intellettuale: non vi sembra di parlare di temi che riguardano una
più alta sfera d'influenza delle nostre vite?
Ebbene sì, è lo stesso comportamento del Nano (potrei chiamarlo da editorialista
antefiducia «il gatto» in riferimento al gatto di Schrödinger),
poiché proprio come i succitati ha sfruttato la sua potenza quantitativa,
si noti bene questa parola: quantitativa, per sminuire e gettare fango
sull'avversario, attaccandolo poi direttamente, cercando lo scontro secondo una
logica terribile, una logica che implica l'affidare l'attacco ad uno dei propri
adepti, o supportarlo tramite il silenzio omertoso
(che il caro Dell'Utri ha ben insegnato al Gatto), per poi indifferentemente
dribblare la questione svicolando alle domande dei giornalisti.
Davvero non ho parole per descrivere un sistema maligno e cangerogeno, che ha
infracidito persino le stabili ed inalterabili fondamenta della Repubblica
Italiana replicando sé stesso attraverso la trasmissione del proprio
«codice genetico», insieme di informazioni, e direi più propriamente di modi
di fare, incerti fra l'ipocrita e il mafioso, che contaminano prima le sedi
più proprie della politica, quelle fisiche, sarebbe a dire i palazzi del potere,
i comitati provinciali et similia, e poi la sede che inizia a perdere
«metri quadri», ossia le menti degli italiani: il cancro ha colpito i loro
cervelli e sta mangiando i neuroni deputati all'analisi critica di ogni
situazione, all'elaborazione del pensiero filosofico più alto, appunto
il pensiero politico (Platone era letteralmente innamorato della politica,
Hannah Arendt la definiva come quintessenza della filosofia).
Mi chiedo come abbiano fatto 60 milioni di italiani a sopportare per 15 anni
imbrogli, allusioni al mondo della criminalità organizzata, modi di fare
spregiudicati spudoratamente sbandierati, spacciati per sacrosante prerogative
del capo del governo.
Mi chiedo anche come facciamo noi a resistere alle provocazioni di Denis
Verdini, che afferma di fregarsene dei poteri del Presidente della Repubblica,
o di chi asserisce che il Gatto può (e spero correggiate, o lettori, con un bel
poteva) ignorare le leggi perché incoronato dal Popolo (entità sacra, che io non
citerei mai se non in rarissime occasioni), e mi domando anche quale razza di
microencefali siano i finiani per non citare a memoria il "divieto di mandato
imperativo", sancito sommamente nella Costituzione quale principio di libertà e
di massima rappresentanza di ogni delegato parlamentare.
Amici, compagni, ci sarebbe da onorare paladini della conoscenza e da condannare
alla damnatio memoriae perpetua ed irreversibile i loro antagonisti, ci sarebbe
da denunciare misfatti gravissimi, ipocrisie, qualunquismi, demagogie, ignoranza
che fanno letteralmente accaponare la pelle, ma non voglio affatto rovinarvi
la salute.
E' per questo che la conclusione non è né amara, né incoraggiante: sta ad ognuno
di noi trovarne una, sulla scorta magari di quell'importante risultato ottenuto
il 14 Dicembre, e di trovare la forza di andare avanti, sia nel nostro piccolo
che in grande.
Con sincero affetto, da parte mia e dei miei fieri compagni, vi auguro una buona
lettura :)
Piston Churchell
______________
/ /\
/ / \
_______ / M E R I / \ _______________
______/| / T O C R / \ _/_______________
_|____|| / A Z I A / \ __/:___favoritismo__
____|__/ / / \ ___/:____|_____|_____|__
_|_____|_ /_____________/ V \ /_/uzione____|_____|_____
____|___/| \ \ E \ |____|_____|_____|_____|__
_|_____|/: \ \ R \ |____disinformazione____
_____corr| \ ______ \ I | /__|_____|_____|_____|__
_|_____/| \ / /\ \ T | /|_____|_____|_____|_____
____|___|_ \/ \ \ A | |____|_ipocrisia_|_____|_
_|_____|_/| / A / \ | /_|_____|_____|_____|_____
____|____|/ / I / \ | \____|_____|_____|_____|__
_|_____|__/| / Z / \ | __/_|_____|_____|_____|_____
____|_____|/ / I /__________\_______| _ /_|___nepotismo_____|_____|__
__ignoranza\_/ T /___________ ____ /_|_____|_____|_____|_____|_____
____|_____|_/ S /__/_____/__/\/:__/\____|_____|_____|_____|_oscurantismo_
_|_____|___/ U /___|_____|__\/_|__\/_/:____|_____|_____|_____|_____|_____
____|_____/ I /_|_____|_monopolio_|_____|_____|_connivenza______|_____|__
_|_____|_/ G /_____|_____|_____|_____|_____|_____|_____|_____|_____|_____
/ /
/ /
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Indice:
* 0x00 . MBB: Reversing al buio
* 0x01 . The Dark Side of C++
* 0x02 . Introduzione al Turbo Pascal
* 0x03 . Valute e sistemi di pagamento elettronici
* 0x04 . Lettera ad un figlio che forse non potrò mai avere
* 0x05 . La mistica select()
* 0x06 . La posta a scrocco
* 0x07 . Fenomeno Wikileaks -- A tribute to Piston
* 0x08 . Riddle
* 0x09 . Ringraziamenti
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**********************************
* 0x00 :: MBB: Reversing al buio *
**********************************
[ Questo articolo è pensato per chì sa già muoversi con comunicazioni seriali, ]
[ convertitori, oscilloscopi, ecc., cioè per chi è già pratico in elettronica. ]
[ e sappia cosa non fare, cioè cosa può eventualmente danneggiare gli IC. ]
A chi non sa che cosa sia un convertitore USB<-->RS232, consiglio di cominciare
a leggere un pochetto sull'argomento e di cercare informazioni su questo
protocollo da molti considerato obsoleto ma che invece è ancòra molto impiegato
nei settori professionali che esigono affidabilità, e che piace molto ai
nostalgici.
Un'ottima spiegazione su:
http://it.wikipedia.org/wiki/EIA_RS-232
e un esempio di convertitore USB/RS232 free&open su:
http://it.emcelettronica.com/usb2usart
Di che si tratta
----------------
Questa volta parliamo un pò di reversing dell'hardware, una delle cose più
soddisfacenti che quest'ignobile epoca possa offrire.
Con reversing dell'hardware intendo lo smontare e il capire l'hardware in modo
da riutilizzarlo in propri progetti o a puro titolo di curiosità.
Un esempio potrebbe essere quello del lettore-MP3 "rotto" che viene smontato e
riparato senza averne nessuno schema anzi talvolta creandone la documentazione
per far sapere ad altri cosa contiene e come funziona.
Obiettivo attuale
-----------------
L'obiettivo è trovare i segnali digitali di una blackbox, e di dumparli sul PC
per esaminarli.
Cosa serve
-----------
Ovviamente la solita atrezzatura da banco e i soliti strumenti di misura:
pinzette, "terza-mano", lente d'ingrandimento, una miriade di cacciaviti,
saldatore a stagno elettrico di bassa potenza (e del buon stagno almeno "60/40"
con anima), almeno un multimetro (i digitali hanno una maggiore impedenza di
ingresso quindi interferiscono di meno sui circuiti in tensione), e un
alimentatore tuttofare (che di solito è il primo gioiellino creato dagli
appassionati).
Questa volta però abbiamo bisogno di qualcosina in più:
-- un oscilloscopio (ancòra meglio un analizzatore di segnali/spettro), caro
strumento di misura che rappresenta esattamente le forme-d'onda cioè le
tensioni (se vi piace l'elettronica e volete fare reversing, è ora che ve ne
procuriate uno :) ) che ci servirà per trovare i segnali digitali;
-- un convertitore USB/seriale (lascio a voi la scelta) che ci servirà per
leggere i segnali digitali trovati, evitando di utilizzare la porta seriale
del PC e quindi evitando eventuali danni da collegamento; i fortunati
possessori di un Arduino (ho testato col duemilanove) possono semplicemente
usare Arduino come convertitore seriale/USB.
-- Caramelle gommose a forma di orsetto; non sono proprio indispensabili
ma sono sempre gradite.
Esecuzione
----------
Compensiamo le sonde ma attenzione:
è vivamente sconsigliato l'introdurre sonde per oscilloscopi nel naso,
usate gli appositi attrezzi(sia per sturare il naso che per compensare
le sonde).
Cominciamo con l'aprire la nostra cavia aka blackbox per esporre piste e pin
varii al puntale della nostra sonda.
Poi alimentiamola e cerchiamo i segnali a onda quadra toccando tutti i
probabili punti-caldi aka hotspots (perchè l'english fa figo).
Poi togliamo tensione, e saldiamo uno spezzone di filo su ciascun punto-caldo
e infine anche uno spezzone sul GND (negativo generale) della blackbox stessa.
Come capire a cosa corrisponde quell'onda?
Bèh se sai tenere in mano un saldatore, sai anche seguire una pista: scoprilo!
Finito di saldare tutti gli spezzoni, si collega il GND della blackbox col GND
del convertitore, poi si collega uno degli spezzoni al pin RX del convertitore
seriale, poi si alimenta la cavia, e infine si connette la USB.
Finito di esaminare il segnale su un hotspot, si scollega la USB e si collega
lo spezzone successivo all'RX del convertitore. Si capisce che c'è lo
sbattimento di dover collegare e scollegare uno per volta tutti gli spezzoni
e anche il connettore alla USB, ma quando si và a caccia la pazienza è
necessaria :)
NOTA PER ARDUINO:
In Arduino usate il pin TX con la stessa procedura spiegata sopra
dato che secondo piedinatura il pin TX di arduino corrisponde al
ricevente(RX) del lato computer e al mittente(TX) che sarebbe Arduino.
Per il primo test, apriamo il nostro terminale di fiducia (tty oppure X) e
lanciamo Screen sul device che corrisponde al nostro adattatore oppure Arduino
(consiglio di togliere prima il microcontrollore da Arduino per questa fase,
ovviamente prima spegnete Arduino) così:
screen -A -f -i -t serial_monitor_MIO /dev/tty$porta $velocita
Vedremo un sacco di caratteri non codificati e simili: ora sappiamo che il
collegamento funziona e che c'è un segnale digitale valido.
A questo punto con un programma come moserial (il mio preferito, lo trovate su
http://freshmeat.net/projects/moserial oppure http://live.gnome.org/moserial)
possiamo provare la baud-rate dove ci sono più caratteri riconoscibili.
Se non va la prima, proviamole tutte, mai demordere!
Una volta trovata possiamo salvare ciò che c'è in un file che poi andremo a
convertire in esadecimale, decimale oppure ottale (a seconda delle preferenze)
con un programma che chiunque può farsi in casa (ma non io non mastico molto il
C quindi... Grazie r0b0t82 ;) ).
Dovete solo preoccuparvi di annotare bene che cosa state facendo fare alla
cavia mentre visualizzate il segnale digitale, ed è fatta!
Vi ricordo che per cavia non si intendono esseri viventi, cotolette turbo
o esseri eterei o inanimati in genere.
Con questo metodo sono riuscito a utilizzare un sensore ottico del mouse
come encoder o come sensore di contatto col suolo, per uno dei miei robot.
Con un pò di perseveranza possiamo mandare lo stesso tipo di dato
all'hotspot per usare ad esempio un accellerometro al posto della rotellina
o qualunque altra cosa ci salti in mente :)
Non diventerete il doctor Octopus ma chi ben comincia è già a metà dell'opera...
Fine. WiiiiiIIIIIII!
d0ct0r
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*********************************
* 0x01 :: The Dark Side of C++ *
*********************************
***********************
*Ereditarietà Multipla*
***********************
L'Ereditarietà Multipla è una delle caratteristiche più potenti
della programmazione orientata agli oggetti, tanto potente
quanto a rischio di errori, tant'è che alcuni moderni linguaggi
di programmazione come Java o PHP neanche supportano questa
caratteristica.
Il concetto di ereditarietà multipla si può utilizzare quando
un oggetto mantiene una relazione è-un non con una sola classe
base, ma con più classi base. Idealmente non sarebbe mai da
utilizzare quando è possibile svolgere lo stesso compito in
modo elegante con una gerarchia di classi singola.
Iniziamo ad addentrarci in un pò di codice, per capire subito
questa caratteristica della OOP.
class Base1
{
public:
Base1() : value(0) {}
Base1(double v) : value(v) {}
double getData() const { return this->value; }
private:
double value;
};
Questa è una semplicissima classe base che contiene un valore
double, la quale fornisce una funzione membro per accedere a
quest'ultimo.
class Base2
{
public:
Base2() : value(0) {}
Base2(int v) : value(v) {}
int getData() const { return this->value; }
private:
int value;
};
Un altra classe base, praticamente uguale alla Base1, se non
per il tipo di dato contenuto, in questo caso un intero.
class Derived : public Base1, public Base2
{
public:
Derived() : Base1(), Base2(), value(0) {}
Derived(double v1, int v2, char v3) : Base1(v1),
Base2(v2), value(v3) {}
char getData() const { return this->value; }
private:
char value;
};
Ed ecco la classe derivata, notare come l'ereditarietà multipla
si realizza in modo molto simile a quella singola, ovvero con
un ':' dopo la dichiarazione della classe, ma in questo caso,
per derivare da più classi, si utilizza l'operatore ',' per
separare le classi da cui deriva.
Inoltre si può notare come il costruttore della classe
derivata, chiami esplicitamente i costruttori delle sue
classi Base per inizializzarne i membri privati.
Passiamo al codice del main.
int main()
{
Base1 b1(2.5), *b1Ptr;
Base2 b2(6), *b2Ptr;
Derived d(5.5, 9, 'A');
//Accesso ai valori tramite le singole classi
std::cout << "b1 contiene: " << b1.getData()
<< ", b2 contiene: " << b2.getData()
<< ", d contiene: " << d.getData() << std::endl;
//Accesso ai valori tramite la classe derivata
std::cout << "Valore double: " << d.Base1::getData()
<< ", valore intero: " << d.Base2::getData()
<< ", valore char: " << d.getData() << std::endl;
//Accesso agli elementi di derived tramite puntatori base
b1Ptr = &d; //d è-un b1
std::cout << "d contiene: " << b1Ptr->getData() << std::endl;
b2Ptr = &d; //d è-un b2
std::cout << "d contiene: " << b2Ptr->getData() << std::endl;
}
Allora, all'inizio della procedura main, instanziamo 3 oggetti, le
due classi base e la classe derivata, più 2 puntatori alle classi
base.
Il primo cout, semplicemente stampa i membri delle classi, ma andiamo
alla seconda cout più interessante.
La classe derivata, essendo derivata sia da Base1 che da Base2, contiene
i membri e le funzioni di entrambe le classi base, perciò, per chiamare
le giuste funzioni per ottenere il dato desiderato, si usa il nome della
classe base più l'operatore binario di risoluzione dello scope :: .
In seguito, viene dimostrata come sussiste la relazione è-un tra la
classe derivata e le sue basi.
Con b1Ptr = &d; , il puntatore alla classe Base1, punta ad una classe
derivata, ciò è permesso dal fatto che Derived è-un Base1. Notare come
con questa operazione non è necessario utilizzare l'operatore binario
di risoluzione dello scope per accedere al membro della classe Base1.
Stessa cosa in seguito con la classe Base2.
Ora, verrà introdotta un tipo di ereditarietà che ci introdurra al
prossimo argomento, ovvero l'ereditarietà virtuale.
L'ereditarietà che introduciamo adesso si chiama ereditarietà
romboidale, un tipo di ereditarietà esplicabile tramite un esempio
grafico.
classe Base_Superiore
|------------------------------|--------------------------|
classe Base1 classe Base2
|--------------------------|------------------------------|
classe Derivata
Con un pò di fantasia si può intravedere un rombo in questa gerarchia :D
Questo tipo di ereditarietà è utilizzata anche nella libreria standard
del C++, nel quale basic_ios rappresenta la classe Base_Superiore,
basic_istream e basic_ostream rappresentano le classi Base1 e Base2,
mentre basic_iostream rappresenta la classe Derivata da entrambe.
C'è però un problema con questo tipo di ereditarietà, che necessita
di un esempio per essere illustrata.
class Base_Superiore
{
public:
virtual void doIt() const = 0;
};
class Base1 : public Base_Superiore
{
public:
void doIt() const
{
std::cout << "Base1" << std::endl;
}
};
class Base2 : public Base_Superiore
{
public:
void doIt() const
{
std::cout << "Base2" << std::endl;
}
};
class Derived : public Base1, public Base2
{
public:
void doIt() const
{
std::cout << "Derived" << std::endl;
}
};
Molto semplicemente, Base_Superiore è una classe Base astratta
che fornisce il metodo virtuale puro doIt() da ridefinire in
basso alla gerarchia. In seguito, Base1, Base2 e Derived
ridefiniscono questo metodo.
Passiamo al main.
int main()
{
Base_Superiore* bs;
Derived d;
bs = &d;
}
Abbiamo un puntatore alla classe Base_Superiore e un oggetto
Derived.
Con bs = &d; associamo un oggetto di tipo Derived ad un
puntatore a Base_Superiore. Sembrerebbe tutto lecito, dato che
Derived è-un Base_Superiore.
Però, qui arriva un problema, infatti se compiliamo quel codice,
per esempio con gcc 4.5.1, otteniamo:
error: 'Base_Superiore' is an ambiguous base of 'Derived'
La spiegazione è dietro l'angolo, infatti Derived è si un elemento
della gerarchia romboidale, ma contiene al suo interno due copie
dei membri di Base_Superiore, ereditati da Base1 e Base2, come
fa il compilatore a scegliere?
Per risolvere questo si fa utilizzo dell'ereditarietà virtuale.
Il codice cambiato è il seguente:
class Base_Superiore
{
public:
virtual void doIt() const = 0;
};
class Base1 : virtual public Base_Superiore
{
public:
void doIt() const
{
std::cout << "Base1" << std::endl;
}
};
class Base2 : virtual public Base_Superiore
{
public:
void doIt() const
{
std::cout << "Base2" << std::endl;
}
};
class Derived : public Base1, public Base2
{
public:
void doIt() const
{
std::cout << "Derived" << std::endl;
}
};
int main()
{
Base_Superiore* bs;
Derived d;
bs = &d;
bs->doIt();
}
Come vedete, ho solo aggiunto la keyword virtual nella
dichiarazione delle classi Base1, e Base2.
Questo informa il compilatore di istanziare per Derived
i membri di Base_Superiore una sola volta.
**********************************
*Puntatori ai membri delle classi*
**********************************
Ci sono due operatori in C++ che raramente vengono utilizzati
ma anche loro necessitano di una spiegazione.
Gli operatori in questione sono .* e ->* e servono ad accedere
ai membri di un oggetto tramite dei puntatori.
Niente può essere più esplicativo di un esempio.
class A
{
public:
A() : value(0) {}
A(int v) : value(v) {}
int getValue() const { return this->value; }
int value;
};
int main()
{
A a(5);
A* aPtr = &a;
int A::*valPtr = &A::value;
int (A::*funPtr)() const = &A::getValue;
std::cout << "a.value, operatore .*: " << a.*valPtr << std::endl;
std::cout << "a.value, operatore .*: " << (a.*funPtr)() << std::endl;
std::cout << "a.value, operatore ->*: " << aPtr->*valPtr << std::endl;
std::cout << "a.value, operatore ->*: " << (aPtr->*funPtr)() << std::endl;
}
Allora, abbiamo una semplice classe con un metodo pubblico getValue
e un dato membro pubblico value.
Nel main, instanziamo un oggetto della classe A e un puntatore ad
esso.
Poi incontriamo due dichiarazioni particolari:
int A::*valPtr = &A::value;
Questa dichiarazione dichiara un puntatore ad un membro int _NELLA_
classe A, inizializzato con il dato membro value della classe A.
int (A::*funPtr)() const = &A::getValue;
Questa dichiarazione dichiara un puntatore a funzione _NELLA_
classe A, una funzione del tipo int (A::*)() const, inizializzata
alla funzione getValue della classe A.
Il tutto è abbastanza difficile da spiegare, ma il codice è
abbastanza autoesplicativo.
Con le prime due cout facciamo utilizzo dell'operatore .*, che ha
come parametro sinistro l'istanza della classe puntata, quindi 'a',
e come parametro destro il puntatore alla classe, nel nostro caso
valPtr e funPtr.
L'operatore ->* è praticamente analogo, e si utilizza quando invece
di un istanza della classe puntata, si ha un puntatore all'istanza
della classe puntata.
**************************
*Il qualificatore mutable*
**************************
Il qualificatore mutable è un altra caratteristica poco usata in C++
ma anch'essa merita una spiegazione.
Sostanzialmente è un metodo alternativo all'utilizzo dell'operatore
const_cast per eludere l'attributo const di una variabile.
Supponiamo di avere questo codice.
class A
{
public:
A() : value(0) {}
A(int v) : value(v) {}
int getValue() const { return this->value++; }
private:
int value;
};
int main()
{
const A a(7);
std::cout << a.getValue() << std::endl;
std::cout << a.getValue() << std::endl;
}
Tutto è abbastanza autoesplicativo.
Questo codice scritto così non funzionerebbe, dato che getValue(),
che è const cerca di modificare un oggetto const direttamente.
Per farlo compilare, si potrebbe cambiare la funzione getValue() in
questo modo.
int getValue() const { return (const_cast<A*>(this))->value++; }
Ovvero togliere al momento il qualificatore const da this.
È una soluzione che magari andrebbe bene per un codice piccolo
come questo, ma in caso di diverse funzioni come getValue, invece
di utilizzare ogni volta l'operatore const_cast, si può cambiare
il codice in questo modo.
class A
{
public:
A() : value(0) {}
A(int v) : value(v) {}
int getValue() const { return this->value++; }
private:
mutable int value;
};
int main()
{
const A a(7);
std::cout << a.getValue() << std::endl;
std::cout << a.getValue() << std::endl;
}
Ovvero, la funzione getValue è stata riportata al suo stato
iniziale, e al dato membro value è stato assegnato il
qualificatore mutable.
In questo caso, il codice compilerà, questo perchè il
qualificatore mutable rende un dato sempre modificabile, anche
se la classe è const.
***************************
*Il qualificatore explicit*
***************************
Bisogna sapere che in C++, un costruttore che prende un unico
parametro, viene utilizzato implicitamente come costruttore
di copia, un esempio.
class A
{
public:
A() : value(0) {}
A(int v) : value(v)
{
std::cout << "Calling A(int)" << std::endl;
}
private:
int value;
};
int main()
{
A a(3);
A b = 8;
A c = A(2);
}
Compilando ed eseguendo questo codice, vedremo che per ognuna delle
tre classi istanziate, verrà chiamato il costruttore A(int), che
nella prima occasione, ovvero A a(3); è esplicito, ma nelle seguenti
2 è usato implicitamente come costruttore di copia.
In alcuni casi come questo può andar bene, ma in altri no, ecco perchè
è necessario utilizzare il qualificatore explicit davanti alla
dichiarazione di A(int), che impedisce la chiamata in modo implicito
del costruttore come costruttore di copia.
edx
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
****************************************
* 0x02 :: Introduzione al Turbo Pascal *
****************************************
Quando qualcuno si iscrive all'ITI per la specializzazione informatica
ha in mente vari progetti,
e ha voglia di affrontare tanti fantastici argomenti che possono essere
trattati durante i 3 anni di
specificazione, ma a volte non è così.
Al sottoscritto è capitato di dover buttar via il primo anno di specializzazione
affrontando un linguaggio di programmazione da me considerato molto inutile
come il Turbo Pascal.
In questo articolo, intendo dare un'introduzione agli argomenti che
andranno affrontati al 1° Anno di specializzazione informatica.
Gli argomenti che andrete ad affrontare (o che forse avete già affrontato) sono:
Programmazione con Turbo Pascal con l'aggiunta di diagramma a blocchi
(simil diagrammi di flusso),
Testing del Programma e Tabella delle Variabili.
Il tutto funziona in questo modo:
Viene assegnato un esercizio (spesso richiamano vecchi argomenti di matematica)
ad Esempio:
"Programma che calcoli l'area di un rettangolo".
Si inizia con un Diagramma a Blocchi del Software che si deve scrivere.
(http://it.wikipedia.org/wiki/Diagramma_a_blocchi)
Un diagramma a blocchi serve per schematizzare il nostro software e di
comprenderne meglio il funzionamento.
Iniziamo quindi a rappresentare l'esercizio:
http://oi52.tinypic.com/34estq9.jpg
Dando un'occhiata si riesce a capire che abbiamo una parte iniziale (Inizio o
Start) e una finale (Fine o End), il triangolo viene usato per l'output..
cioè tutto quello che viene messo al suo interno verrà stampato (echo, print,
write ecc), il parallelogramma invece si occupa della lettura di una variabile,
cioè si occupa di dare un valore a una variabile prendendo il valore all'esterno
del programma (quando viene eseguito),
il rettangolo viene usato per rappresentare le operazione che il programma
attua, nel nostro caso il rettangolo ci spiega che la variabile C prende
il valore del contenuto di A e lo moltiplica per il contenuto di B.
Infine l'ultimo triangolo "stampa":
'Area :' + il contenuto della variabile C.
Proviamo a tradurre ora lo schema in Pascal:
Program Base_Altezza_rettangolo; {Base_Altezza_rettangolo è uguale al nome
del programma, posso assegnare qualsiasi nome a un programma affinchè non
contenga caratteri 'speciali' e che non ci sia spazio fra le parole}
Var a,b,c:Real; {Qui dichiaro di che tipo sono le variabili utilizzate}
Begin {Inizio}
Write('Inserisci base e altezza del rettangolo : ');{Ecco il nostro triangolo}
readln(a,b); {Assegna i valori a 'a' e 'b', (parallelogramma) }
c:=a*b; {calcolo il valore di a*b inserendo il risultato nella variabile 'c'}
Writeln('Area :',c); {Stampo finale del contenuto di c}
end.
E ora passiamo al testing, il testing del programma è un po' come provare se
funziona senza averne il compilatore.. illustrando cosa viene inserito
e cosa verrà outputtato.
__________________________________________
| | a | b | c | Visualizzazione |
| | | | | |
| | 2 | 5 | 10 | Area : 10 |
|_|______|_____|_____|____________________|
E ora la tabella della variabili che ci mostra quali variabili utilizzate sono
di input e quali si output e se qualcuna viene utilizzate come
variabile di lavoro.
___________________________________________
| | I | O | Lavoro |
| a | X | | |
| b | X | | |
|__ c __|____|___|_X___|___________________|
I <- Input
O <- Output
Ecco come dovrete lavorare con la programmazione quando frequenterete quest'anno
scolastico (+ o -, dipendono da come i professori impostano la programmazione
scolastica..
può darsi che sarete più fortunati xD)
Nelle prossime edizioni, se avrò voglia andrò avanti con le spiegazioni su nuove
funzioni del Pascal e come rappresentare la cosa in uno schema grafico.
jackdharma
From Morano School xD
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*****************************************************
* 0x03 :: Valute e sistemi di pagamento elettronici *
*****************************************************
Eccovi una lista di valute elettroniche, sistemi di pagamento on line e simili
che potrebbero tornarvi utili.
Prima di tutto però facciamo distinzione tra i classici sistemi di pagamento
e le valute elettroniche:
- I sistemi di pagamento online sono i classici metodi di pagamento
che tutti noi conosciamo, quelli che ci permettono di comprare e/o di vendere
sul web in tutta sicurezza e con estrema semplicità, come ad esempio PayPal e
PostePay.
Possono essere delle carte prepagate o delle vere e propie carte di credito.
- Ma è anche vero che ci sono altri metodi di pagamento per acquistare
l'oggetto che ci interessa ad esempio sul famoso e annoverato Ebay, metodi che
nel 2011 possono ormai sembrare obsoleti e superati.
Alcuni esempi di tipi di pagamento diversi possono essere il bonifico
bancario, che rimane ancora oggi uno dei metodi più sicuri e il contrassegno,
ovvero quello che ci permette di pagare l'oggetto direttamente al corriere,
con l'aggiunta di una piccola sovrattassa sul prezzo totale (solitamente si
aggira sui 5 euro).
- Le valute elettroniche invece (a volte dette anche "moneta elettronica")
sono un classico metodo di pagamento online, ma invece
di essere messa in circolo moneta cartacea, viene messo in circolo l'oro.
Una delle più famose, nonchè delle prime valute elettroniche è stata la
GoldMoney, con essa i possessori possono fare diverse transazioni (e acquisti)
online, oppure rivendere il proprio oro al prezzo di quotazione corrente.
Ma vediamo nel dettaglio alcuni esempi di metodi di pagamento:
- PayPal: È forse il sistema di pagamento online più famoso e più longevo
del mondo (nato addirittura nel "lontano" 1998).
In pratica il fulcro di tutto, sarà l'e-mail creata e associata
al proprio account
Una volta iscritti, infatti si potrà associare alla mail PayPal
fino a otto carte di credito o carte prepagate, di qualsiasi tipo.
Molto utileper siti quali Ebay e Web shop.
- PostePay: È una vera e propia carta prepagata accettata per molti servizi
in Italia, ma anche all'estero, in tutti i siti ad esempio che
accettano carte Visa.
- AlertPay: È un sistema di pagamento e storaggio di soldi, molto famoso nei
siti di guadagno "bux" e nelle varie eurobarre. Molto in auge da
quando paypal ha abbandonato questa fetta di mercato.
- Gold Money: Come abbiamo già detto, è una moneta digitale che ha la
peculiarità di essere basata sull'oro. cioè se si possiede 1$
nel proprio account, esso verrà modificato in base alle quotazioni
dell'oro, facendogli acquistare o perdere valore.
- E-Gold: Moneta digitale simile a Gold Money, anche qui i soldi sul
proprio conto variano col variare delle quotazioni aurifere nel
mondo. Esso è noto per essere tra le monete preferite dalle
principali organizzazioni criminali informatiche...
- OneBip: Non è propriamente una moneta elettronica ne una specie di banca
online, bensì è un sistema di trasferimento di denaro tramite..
cellulare! In pratica basta fare delle "normali" ricariche
telefoniche sul proprio telefono cellulare, e si potrà acquistare
da alcuni siti, usando difatto il credito come se fossero soldi
caricati su una normale carta di credito.
Questo servizio ultimamente è stato implementato anche da altre
aziende, come ad esempio Poste Italiane, che da poco offre un
servizio simile.
Detto questo ci sarebbe da menzionare l'ebanking, ovvero tutti quei servizi che
le banche offrono online, dalle transazioni, alla lettura degli estratti conto
ad esempio. È però un argomento che sarebbe da approfondire a parte,
e non è detto che non verrà fatto!
Ora potrete scegliere con più chiarezza e semplicità il metodo di pagamento che
fa al caso vostro!
Turbocotoletta MMX && dany15gni
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**************************************************************
* 0x04 :: Lettera ad un figlio che forse non potrò mai avere *
**************************************************************
Scrivo questa "lettera" per dei motivi molto semplici e banali: soprattutto
perchè sono stufo. Sono stufo della Mafia, sono stufo dei politici, sono stufo
delle speculazioni e delle promesse mai mantenute, del petrolio e del presente,
sono stufo di pensare a come potrà essere il mio futuro in questo paese...
Scrivo questa "lettera" ad un figlio che non ho, ad un figlio che vorrei, ad un
figlio che molto probabilmente non avrò mai.
Ho solo ventunanni è vero, ma il presente su questo strano pianeta è già
diventato passato, il tempo di una pubblicità in televisione o di bere un caffè,
e la "storia" è già cambiata.
È un concetto paradossalmente dolce e sensuale se ci pensiamo un attimo, ma in
realtà, almeno per quanto riguarda l'Italia, non è così. Non è così perchè
questo è un paese che da troppo tempo è impegnato solo a litigare e a darsi
colpe sugli errori del passato, è un paese che litiga per "accaparrarsi" quel
poco presente che rimane, è un paese che non pensa minimamente al nostro futuro,
tutto ciò semplicemente perchè non ha tempo.
Il tempo serve prima di tutto per parlare di escort, il tempo serve per far
chiudere le aziende e a lasciare migliaia di padri di famiglia per strada, il
tempo serve per fare leggi ad personam, e per creare nuovi partiti e alleanze,
non c'è tempo per parlare o solo per pensare al futuro, non c'è tempo per
tentare di migliorare questo paese.
C'è il tempo per parlare di Ruby, ma non c'è quello per creare nuovi
posti di lavoro.
Ho solo ventunanni è vero, ma per un motivo o per un altro mentalmente sono
dovuto crescere in fretta.
Quando sei un ragazzino le tue ambizioni sono banali e ridondanti, fare tanti
soldi, tanti abbastanza per poterti comprare una o più macchine di lusso, tanti
abbastanza per comprarti una o più case, le tue ambizioni
sono avere tante donne, essere potenti...
Poi si cresce, e quei "sogni" adolescenziali li ritrovi letteralmente
"reincarnati" in alcune di quelle persone che ci governano, ti guardi bene
intorno e vedi solo rabbia, tristezza e desolazione.
Solo allora capisci che le ambizioni non sono quelle, ambire ad essere uno dei
tanti potenti che ci marionettano dall'alto, non è propriamente qualcosa
di buono, ambire ad essere un giornalista bavoso non è il massimo, solo allora
capisci che ambire ad essere "ricchi" comporta tanto dolore per gli "altri",
e se nasci nella classica famiglia che nel bene o nel male fa parte della
categoria degli "altri", crescendo il potere finisce col farti schifo.
Ho notato poi come i miei coetanei, anche quelli che attivamente o
per "ignoranza" appoggiavano o dicevano di appoggiare certe "fazioni" politiche
estremiste sia di destra che di sinistra, ultimamente si sono indignati,
alcuni sono scesi addirittura in piazza, altri si limitano a condividere qualche
link sarcastico o satirico su Facebook, sembra una cavolata, ma è già qualcosa,
è già un piccolo passo avanti.
Noi giovani dovremmo essere il futuro...
C'è però chi non ci lascia il posto ed è incollato alla sua poltrona da troppo
tempo, c'è chi ci ostacola, c'è chi non pensa minimamente a noi, o meglio,
preferisce non pensarci e far finta di niente, perchè noi in qualche
modo siamo scomodi. Cresci e le tue ambizioni si allontano dal semplice
"avere potere", cresci e la tua ambizione più grande sembra incredibile,
ma diviene avere un figlio...
Dovrebbe essere un proposito per l'avvenire, qualcosa a cui pensare sorridendo,
qualcosa di concreto che possa accadere prima o poi, quando la stabilità te
lo concede, ma in questo "clima di terrore", appesi ad un filo sottilissimo che
rischia sempre più spesso di strapparsi, avere un figlio è diventato il pensiero
più triste che ci sia, avere un figlio è diventato un sogno, o meglio,
lo hanno fatto diventare un sogno, alla pari di possedere quella macchina di
lusso o una casa in centro a Milano.
Avere un figlio dovrebbe essere la cosa più bella del mondo, ma oramai
è un pensiero che si allontana sempre più da noi giovani.
E allora quando vai a dormire, e ci sono quei dieci minuti dove il tuo cervello
pensa al tutto e pensa al niente, credo che a noi ventenni, ma non solo,
almeno una volta sia apparsa dal nulla in mente una domanda del tipo:
"Tra qualche anno potrò permettermi di avere un figlio?"
Se la si analizza, è una domanda che squarcia il cuore, è la domanda che mi
incute più terrore in assoluto...
Potremo mai permetterci un figlio?
È un concetto duro da pensare se guadagni 600 euro al mese come stagista
e hai trent anni, è duro da pensare se sei un ragazzo che studia ed insegue
un pezzo di carta che, diciamocelo chiaro, in questo paese vale sempre più
quanto un rotolo di carta igienica, è duro pensare ad un figlio se sei
disoccupato, se non sei figlio di papà o raccomandato.
E allora caro figlio, ora mi rivolgo a te come entità "in sospeso" che aspetti
solo il momento opportuno per venire al mondo.
Non nascere dal mio seme, non nascere figlio di un ricercatore o di un operaio,
cerca di trovare la via "giusta", nasci figlio di un politico, loro potranno
darti tutto, anche delle leggi che faranno al caso tuo se ne avrai bisogno,
oppure nasci figlio di una escort, loro si che guadagnano bene, pensa che fanno
talmente tanta "tenerezza" che certi politici gli regalano migliaia e migliaia
di euro senza volere nulla in cambio!
Aspetta, magari potresti nascere figlio dall'unione di un politico
e di una escort!
Potresti nascere figlio di un vecchio lupo comunista, figlio dell'opposizione!
Beh, forse non ti conviene più di tanto...
Se non ti piace la classe politica, ci sono sempre i cari e "vecchi"
imprenditori, e se qualcosa va male o le cose si complicano, vi basterà fare i
bagagli e scappare all'estero, lasciando tantissimi miserabili lavoratori
con "le pezze al culo", funziona così, il pesce grosso mangia il pesce piccolo
e noi siamo plancton.
Potresti anche nascere figlio di un calciatore, guadagnano minimo due milioni di
euro all'anno per tirare calci ad un pallone, oppure figlio di un giornalista,
o anche di una bella conduttrice televisiva, che magari poi in futuro
diventerà Ministro.
Scegli bene, ma non scegliere me, non scegliere un operaio,
un ricercatore, un informatico, ...
Oppure scegli un operaio, un ricercatore, un informatico,
ma sceglili all'estero...
dany15gni
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*******************************
* 0x05 :: La mistica select() *
*******************************
Vorrei presentare al nostro piccolo pubblico una simpatica funzione disponibile
per i programmatori C/C++ messa a disposizione dalla maggior parte
dei sistemi operativi esistenti oggi.
Questa funzione permette di sapere se un file descritor(un socket, generalmente)
è pronto per la lettura o scrittura.
Anche se all'apparenza tale funzione può sembrare completamente inutile,
dopo aver letto questo breve articolo, capirete l'utilità di essa. :)
Iniziamo subito vedendo la sintassi di questa funzione
int select( int nfds,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
const struct timeval *timeout
);
Come prima cosa, ci terrei a farvi conoscere un simpatico tipo(fd_set)
con delle sue relative macro (FD_ZERO, FD_SET, FD_CLR, FD_ISSET);
Esso permette di associare ad una singola variabile più sockets.
Le quattro macro sono:
FD_ZERO(fd) => azzera le "associazioni" fd_set <=> socket
FD_SET(sck,fd) => associa un socket all'fd_set
FD_CLR(sck,fd) => dissocia un socket all'fd_set
FD_ISSET(sck,fd) => controlla se, dopo la select(), è ancora attivo il socket
(ci sono dati o è pronto per la scrittura) :)
Innazitutto va dichiarata una variabile di tipo fd_set e va azzerata.
fd_set r;
FD_ZERO(&r);
successivamente vanno associati i socket:
FD_SET(socket1,&r);
FD_SET(socket2,&r);
...bla bla bla...
Ora vediamo un esempio di uso della funzione select():
La select() nel nostro caso ci dirà se ci sono connessioni in attesa di essere
accettate su un socket in ascolto.
Come?
Se c'è un dato su un socket in ascolto, vuol dire che c'è una
connessione in attesa di essere accettata :)
Quindi,
- Come 1° parametro bisogna passare l'id del socket più alto incrementato
di uno. (non so, chi ha inventato la select vuole che sia così! :P )
- Come 2° parametro, l'fd_set associato ai vari socket
- Il 3° e 4° parametro possiamo lasciarli a NULL
(servono per usare fd_set come controllo in scrittura/eccezioni)
- Con l'ultimo parametro va definito per quanto tempo la select può restare in
attesa.
N.B:
La select ritorna quanti bytes sono presenti in lettura/scrittura/ecc,
oppure -1 in caso di errore.
Quindi:
int n,max;
SOCKET a,b;
fd_set f;
struct timeval tv;
/* impostazioni dei socket qui */
/* loop */
while(1)
{
tv.tv_sec = 0;
tv.tv_usec = 100000; /* 1/10 di secondo */
FD_ZERO(&f);
FD_SET(a,&f);
FD_SET(b,&f);
if(a>b)
max = a;
else
max = b;
n = select(max + 1,&f,NULL,NULL,&tv);
if(n<0)
{
printf("Errore %d\n",errno);
}
else
{
if(n>0)
{
if(FD_ISSET(a,&f))
{
/* leggere da questo socket */
}
if(FD_ISSET(b,&f))
{
/* leggere da questo socket */
}
}
}
}
Certo, con un sorgente così, con massimo 2 sockets predefiniti non si va
tanto avanti XD
Quindi vi allego una bozza di un mini-server costruito usando la select()
appena vista.
Abbiamo un semplice socket in listening e per gestire dinamicamente i vari
socket che accettan le connessioni ho usato lo std::vector delle STL (C++).
#include <cstdio>
#include <cstdlib>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <vector>
#define PORT 2211
struct sck_s
{
int s;
struct sockaddr_in p;
} sck_s;
std::vector<struct sck_s> sockets; /* tutte le connessioni accettate */
int l_socket; /* listen socket */
struct sockaddr_in l_params; /* parametri del socket in listening */
/* funzione inutile per dire "errore". XD */
void error(const char *str)
{
printf("Errore [%s] %d - %s\n",str,errno,strerror(errno));
exit(1);
}
int main()
{
struct timeval tv;
fd_set f;
unsigned int max,i;
socklen_t pl;
int n,m;
struct sck_s tmp;
char buf[512];
/* inizialliziamo il socket che resterà in ascolto */
l_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(l_socket<0)
error("socket");
/* ..e i suoi parametri */
l_params.sin_family = AF_INET;
l_params.sin_addr.s_addr = INADDR_ANY;
l_params.sin_port = htons(PORT);
/* provo a bindare la porta... */
if(bind(l_socket,(struct sockaddr *)&l_params,sizeof(struct sockaddr)) < 0)
error("bind");
/* in ascolto! */
if(listen(l_socket,10)<0)
error("listen");
/* listen socket pronto! */
/* loop */
while(1)
{
tv.tv_sec = 0;
tv.tv_usec = 100000; /* 1/10 di secondo */
FD_ZERO(&f);
FD_SET(l_socket,&f); /* diciamo alla select di controllare anche per */
/* l_socket */
/* iniziamo già a dire qual è per ora il limite massimo dei sockets */
max = l_socket;
/* aggiunge tutti i sockets */
for(i=0;i<sockets.size();i++)
{
if(sockets[i].s != -1) /* se NON ci sono errori */
{
FD_SET(sockets[i].s, &f);
if(max<sockets[i].s)
max = sockets[i].s;
}
else /*socket non valido*/
{
close(sockets[i].s);
sockets.erase(sockets.begin()+i); /*bye bye socket */
i--; /* grazie all'i++ del for ricontrolla lo stesso numero */
}
}
/* eccola qui la nostra amica! */
n = select(max + 1,&f,NULL,NULL,&tv);
if(n<0)
error("select");
else if(n>0)
{
/* controlliamo se ci son dati sul socket in listening */
if(FD_ISSET(l_socket,&f)) /* connessione in arrivo */
{
/* accettiamo la connessione */
tmp.s = accept(l_socket,(struct sockaddr *)&tmp.p,&pl);
if(tmp.s>0)
{
printf( "Accepted connection from %s:%d\n",
inet_ntoa(tmp.p.sin_addr), tmp.p.sin_port);
/* e accodiamola con gli altri sockets */
sockets.push_back(tmp);
}
}
/* controlliamo se ci son dati sugli altri socket */
for(i=0;i<sockets.size();i++)
{
if(FD_ISSET(sockets[i].s,&f))
{
memset(buf,0,sizeof(buf)); /*azzeriamo il buffer */
m = recv(sockets[i].s,(char *)&buf,sizeof(buf),0);
if(m<0 || !m) /* errore durante la lettura */
{
printf( "Connection closed from %s:%d\n",
inet_ntoa(sockets[i].p.sin_addr),
sockets[i].p.sin_port);
close(sockets[i].s);
sockets.erase(sockets.begin()+i);
i--;
continue;
}
else /* leggiamo! */
{
printf( "Data recieved from %s: %s\n",
inet_ntoa(sockets[i].p.sin_addr),
buf);
}
}
}
}
}
close(listen_socket);
return 0;
}
Bene, per oggi è tutto :)
Alla prossima e...attenti ai buffer overflow! ;)
r0b0t82
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
******************************
* 0x06 :: La posta a scrocco *
******************************
Devo ancora effettuare dei tests su una mia nuova trovata: la
posta gratis.
Consiste nello sfruttare le promozioni riservate alle piccole
e grandi imprese,
denominate POSTATARGET e POSTAMASSIVA.
Editori e aziende fornitrici di servizi pagano un certo
importo per poter inviare liberamente riviste e bollette ai
loro utenti, difatti se notate il fogliettino allegato e ben
visibile contenuto nell'involucro trasparente delle riviste o
il marchio che sostituisce il francobollo nelle lettere
inviate da Telecazz ed Eni, troverete il nome dei due tipi di
contratto a cui sopra accennavo.
Quali sono dunque i "fini non previsti" per i quali potremmo
usare questi autentici regali delle Poste Italiane?
Ma senza dubbio corrispondenza gratis!
Nel caso delle buste che contengono le bollette, basterà
semplicemente sostituire la bolletta che avete ricevuto con
una lettera indirizzata al vostro destinatario.
Occorrerà stamparla al computer, affinché attraverso la
plastica trasparente che permette la lettura dell'indirizzo
da parte dei postini, si possa leggere l'indirizzo del vostro
amico.
Dopo che avrete gettato la busta nella buca delle
lettere, questa tornerà all'ufficio smistamento e verrà
considerata come una bolletta fresca fresca da inoltrare al
destinatario.
Se invece vogliamo usufruire di POSTA TARGET, dopo aver
ricevuto una rivista con il foglietto indicante il vostro
indirizzo, scansionate quest'ultimo e poi al computer
modificate il destinatario.
Prendete periodico, fogliettino falsificato e
cellopane, recatevi alla posta e informate l'impiegato che
non siete voi i veri destinatari di ciò che avete ricevuto:
l'impiegato delle poste molto probabilmente tediato dal
lavoro e stupido da
tanta gentilezza di un pover'uomo che si strugge per uno
sconosciuto facendo
una lunga fila alle Poste, non indagherà oltre e vi
ringrazierà.
Così la rivista contenente il vostro messaggio segreto verrà
recapitata al vostro amico.
Un'altra variante consiste nel farvi recapitare lettere
consegnando i vostri fogliettini con il vostro indirizzo agli
amici, che non dovrano falsificarli.
Potreste continuare ad inviare "bollette" (eh eh :D) e
riviste con "allegati non previsti" (le vostre belle lettere)
cambiando sempre buca e sempre ufficio postale, per non dare
nell'occhio.
Casomai dovessero scoprirvi, ricordate che sbirciare la posta
altrui è un reato ben più grave di inviare false bollette ;)
Buon posta-scrocco a tutti.
Piston Churchell
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
******************************
* 0x07 :: Fenomeno Wikileaks *
******************************
Piston aveva inviato quest'articolo per una possibile edizione natalizia, non
più pubblicata.
Lo pubblichiamo ora, anche se con gran ritardo, almeno per rispetto di quanti
si sforzano e scrivono per questa ezine. ;)
----------------
Avendo volontariamente omesso un'analisi profonda dei mali di questo Paese,
parliamo di qualcosa di più elevato, certamente in senso geografico, ché sulle
nostre vite forse incide più il piano inferiore che quello superiore.
Non mi interessa analizzare le notizie fornite dal sito di Assange, né
tantomento parlare di Wikileaks in modo scolastico.
Mi soffermerò invece sulla figura dell'editor-in-chief della testata
(o biblioteca, essendo registrata come tale in Australia) e sulle pressioni
fatte dai governi (ed in particolare da quello statunitense).
Sulla testa di Assange pende un mandato di cattura dell'Interpol, vale a dire
che quest'uomo è ricercato adesso in 188 paesi.
E questo costituisce un duro colpo alla libertà del progetto: è la definizione
giuridica della questione, la sua regolarizzazione davanti agli occhi del mondo.
Certo, mi direte che non è ricercato per crimini di guerra o per altri motivi,
mi direte che è accusato di stupro. Ma si è mai visto un individuo che non vive
più di una manciata di ore nello stesso luogo, che è odiato da un popolo
ignorante (sapete benissimo a quale popolo, con la p minuscola,mi riferisco),
darsi pena di stuprare due donne e dare anche solo una remota possibilità ai
suoi nemici di far scattare il mandato di cui si dice sopra?
Perché non hanno fatto lo stesso con un noto truffatore, fondatore di Canal 5 in
Spagna e lì ricercato? (già, il Gatto aveva anche quest'altra..gatta da pelare!)
Dicevamo di Assange:
vanno bene le donazioni, ma io vorrei veramente parlare anche solo 30 secondi
con questa persona e fargli davvero sentire il mio affetto, fargli capire che
quando ti senti crollare il mondo addosso, quando ti minacciano in così tanti e
così gravemente che persino tu inizi a domandarti se forse hanno ragione, se
forse hai esagerato o semplicemente sei pazzo, devi trovare la ragione che ti ha
spinto a far quel che hai fatto e non devi assolutamente dargliela vinta.
La sua vita per me è preziosissima, come del resto quella di tutti gli uomini,
ma la sua più di quella degli altri, perché lui incarna anzitutto un ideale:
quello di rivelare ciò che ipocritamente è celato nelle scartoffie
d'intelligence.
Bisogna dargli coraggio,ricordargli che siamo in tanti.
Attorno al suo progetto hanno fatto vuoto tutte le industrie major d'internet,
prima quelle che gli fornivano direttamente le macchine, poi quelle che erano
ricollegate a Wikileaks per le donazioni.
È così che Paypal ha chiuso il rubinetto (e qui gli anglofoni avrebbero fatto un
titolone stratosferico, dato che leaks significa perdita d'acqua)
che erogava soldi alla fondazione.
È giusto fare qual che hanno fatto gli staffer di Wikileaks? Eticamente
dovremmo supportarli, o è il nostro risentimento nei confronti dei nostri
governi che ci induce a rivolgere loro un sorriso? Valga più di mille parole il
video e la vicenda già esposta abbondamentente di "Collateral Murder".
Quel fatto signori, il solo fatto, schietto, crudo e nudo, è la risposta alle
vostre domande.
Cosa dire invece di un governo che calpesta il Primo Emendamento, che tramite
funzionari e metodi più o meno discutibili induce chi prima sosteneva Wikileaks
ad allontanarsene? Beh, anzitutto assomiglia al nostro governo. Ma riflettendo
bene il nostro è migliore, è scoperto: sai chi mente per interesse del capo, sai
chi mente per prendere più voti e va contro il capo per questo, sai chi vuole
solo vivacchiare e chi invece è veramente interessato alla situazione.
Lì no: repubblicani e democratici sono ambigui, profondamente invischiati nel
sistema delle intelligence, negotium (un bel fuck off a business) d'eccellenza
degli americani.
Altrettanto ambiguo e promiscuo è il popolo, stregato dai mass-media,
dallo stereotipo, dal "grande sogno americano", la cui realizzazione non deve
essere minimamente intaccata da scomodi australiani assetati di verità.
Forse ad essere eticamente riprorevoli sono loro, paese senza bussola
(in positivo ed in negativo), abitato da paranoici negazionisti della strage
prima irachena e poi afghana.
Da chi dobbiamo difenderci, quali affermazioni possono uccidere la nostra
criticità? La mia risposta è chiara a questo punto.
Piston Churchell
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
******************
* 0x08 :: Riddle *
******************
Abbiamo un vincitore per lo scorso riddle: gadfly.
Per risolvere il riddle bastava creare un file PBM e scriverci dentro:
----------
P1
54 5
0111110111100111011111000011000000011001110011000100000100000100010010010000000
0011000001100001000101001000001110001111000100100000000011001001100001000101001
0000010000010000001001000000000011010110000010001001010000011111010000011101111
100000001101100000111001000110000
----------
salvarlo come .pbm
e compariva una scritta "EPIC WIN".
Riddle di questo numero:
http://hitnote.gotdns.org/riddle/0x05.jpg
In bocca al lupo ;)
r0b0t82
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**************************
* 0x09 :: Ringraziamenti *
**************************
Per questo numero si ringrazia, in ordine alfabetico:
dany15gni, d0ct0r, edx, jackdharma, Piston Churchell, r0b0t82, turbocotoletta
La ezine HITNOTE è a cura dello staff di Unofficial HJ Forum:
http://unofficialhj.gotdns.org
Il sito ufficiale di HITNOTE è:
http://hitnote.gotdns.org
Insultateci, criticateci, inviateci tutto quel che vi passa per la testa a:
mailhitnote@gmail.com
Il canale IRC su cui ci incontriamo è:
#hj @ unofficialhj.gotdns.org:6667 [6697 via SSL]
#hjssl @ unofficialhj.gotdns.org:6697 [solo via SSL]
HITNOTE 0x05 [February 2011] -- Released under Creative Commons
