Determinare i permessi di file e directory

Nei sistemi operativi multi-utente viene solitamente previsto un meccanismo che garantisca l’accesso in lettura e scrittura a file e directory solo a chi ha i permessi per farlo.

I sistemi Unix-like, come Linux,  implementano un sistema che distingue i permessi di lettura, scrittura ed esecuzione in 3 livelli di accesso: il proprietario (user), un gruppo di utenti (group) e tutti gli altri. Il file system associa a ogni file (e directory) una mascheratura di bit, ciascuno dei quali ha un significato e il relativo valore determina il permesso di accesso. Si hanno un bit per stabilire il permesso in lettura, un’altro bit per il permesso in scrittura e un altro ancora per il permesso di esecuzione. Questa tripla si ripete per altre due volte, ottenendo così tre triple, una per livello.

Tuttavia, per questioni di leggibilità, si preferisce visualizzare questa mascheratura attraverso il suo corrispettivo valore decimale che possiamo calcolare tramite questo schema:

Livello Read Write Execute Somma
User 4 2 1 7
Group 4 2 1 7
All 4 2 1 7

Per ottenere il valore è sufficiente calcolare la somma di ogni riga.

Per esempio: abilitiamo l’utente-proprietario ad accedere in lettura e in scrittura, mentre la sola lettura tutti gli altri. Lo schema verrebbe così:

Livello Read Write Execute Somma
User 4 2 6
Group 4 4
All 4 4

Pertanto, per impostare questi permessi ad un ipotetico file pippo è sufficiente aprire una shell e scrivere:

# chmod 644 pippo

Se i permessi di lettura e scrittura risultano ovvi, quello di esecuzione merita una spiegazione a parte. Questo tipo di abilitazione ha un significato particolare quando viene associato a:

  • file: in questo caso indica se il file può essere eseguito o meno. Pensiamo ad esempio ad un file binario o a uno shell script.
  • directory: in questo caso indica se si hanno i permessi aprirla, ovvero leggerne il suo contenuto.

 

Disco esterno per la Playstation 3

La Playstation 3 è dotata di due porte USB alle quali è possibile collegare un disco esterno ed utilizzarlo come memoria di massa per archiviarci musica e filmati. Prima però deve essere inizializzato correttamente.

Innanzitutto deve essere formattato in FAT32. Potrebbe sembrare strano ma Windows, a causa di alcune limitazioni imposte, potrebbe avere qualche difficoltà a formattare il disco in questo formato se la sua capacità supera i 32 GB (cosa assai probabile). Per questo motivo potrebbe essere più conveniente farlo in Linux/Ubuntu tramite il pacchetto dosfstools. Assicuriamoci pertanto di averlo installato sul sistema. Poi colleghiamo il disco e individuiamo il corretto device. Quindi procediamo alla sua formattazione, operazione che cancellerà qualunque informazioni si trovi già nel disco:

$ sudo mkdosfs -F 32 -I /dev/<device>

Una volta completata la formattazione montiamo il nuovo filesystem e creare le directory tramite questi comandi:

$ sudo mkdir /<mount-point>/PICTURE
$ sudo mkdir /<mount-point>/MUSIC
$ sudo mkdir /<mount-point>/VIDEO
$ sudo mkdir /<mount-point>/PS3
$ sudo mkdir /<mount-point>/PS3/EXPORT
$ sudo mkdir /<mount-point>/PS3/SAVEDATA
$ sudo mkdir /<mount-point>/PS3/THEME

Adesso copiate tutti i dati che desiderate nelle cartelle appropriate.I file saranno  visibili nella XMB della console.

Un ultimo accorgimento: il formato FAT32 non permette di immagazzinare file di dimensione superiore ai 4.0 GB. Eventuali filmati dovranno essere divisi in più file oppure ricompressi.

Rimuovere gli attributi “hidden” e “system” dei file FAT su GNU/Linux

Recentemente mi è capitato di avere un chiavetta USB in cui non vedevo più le cartelle e i documenti. Apparentemente sembrava tutto ok: lo scandisk non rilevava danni alla FAT, lo spazio continuava a essere occupato, eppure non si vedeva niente, sembrava vuoto. Anche la ricerca dei file pareva non trovare più i miei documenti.

Prima di rassegnarmi e buttare via la chiavetta, ho provato ad inserirla nel PC con Ubuntu: L’intenzione era quella di provare a recuperare almeno parte dei miei documenti. Ho aperto così una finestra della shell e ho listato il contenuto della chiavetta. Con stupore mi sono accorto che tutti i miei documenti erano ancora lì!

Facendo una ricerca su Google ho scoperto che una cosa simile era capitata anche ad altri. Probabilmente si trattava di un qualche virus che attiva i bit degli attributi nascosto e sistema dei file, rendendoli invisibili all’utente sotto Windows. La cosa più importante era che i miei file erano ancora intatti e che esisteva una soluzione basata su Linux per riportare il tutto alla normalità.

Per prima cosa assicurarsi di avere installato il pacchetto mtools:

$ sudo apt-get install mtools

Quindi creare il file .mtoolsrc nella propria home directory e inserire quanto segue:

drive s: file=/dev/<usb-device>
mtools_skip_check=1

Verificare quindi gli attributi dei file:

$ mattrib -/ s:

Correggere quindi gli attributi con questo comando:

$ mattrib -/ -h -s s:

Adesso i file e le cartelle saranno di nuovo visibili anche su Windows!

Ricordati di me, GRUB!

Per fare in modo che Grub 2.0 si ricordi dell’ultima opzione selezionata occorre modificare/aggiungere le seguenti righe nel file /etc/default/grub con il vostro editor preferito:

GRUB_DEFAULT=saved
GRUB_SAVEDEFAULT=true

Salvare le modifiche e applicare le nuove impostazioni digitando il comando:

$ sudo update-grub

Da adesso in poi Grub si ricorderà quale sistema operativo è stato avviato e lo riproporrà già selezionato tra le varie opzioni disponibili.

Controllare l’accesso ai membri di una classe

Con l’utilizzo dei qualificatori di accesso possiamo determinare quando un particolare campo o metodo di una classe può essere invocato da un’altra. Impararne il corretto utilizzo è un requisito essenziale per chiunque desideri progettare un’interfaccia software solida, robusta e ben scritta.

Il linguaggio Java definisce due livelli di accesso:

  • a livello di classe, o esternopublic, oppure package-private (nessun modificatore esplicitamente dichiarato);
  • a livello di membro di una classe, o interno: public, private, protected, o package-private (nessun modificatore esplicito).

Quando una classe viene dichiarata public, diventa visibile a tutte le altre. Se invece non viene definito nessun modificatore, allora rimane visibile soltanto all’interno dello stesso package dove la classe è stata dichiarata.

All’interno di una classe possiamo utilizzare il qualificatore public per rendere accessibile ovunque quel campo o quel metodo, oppure nessun modificatore (package-private) per limitarne l’accesso all’interno dello stesso package. In aggiunta possiamo utilizzare i qualificatori private e protected. Il primo indica che il membro può essere visto soltanto nella sua classe. Il secondo invece indica che il membro può essere visto anche dalle classi dello stesso package e, in aggiunta, dalle sue classi discendenti, anche in package differenti.

La tabella che segue schematizza quanto appena detto:

Livelli di accesso
Modifier Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

 

Come si può vedere, una classe ha sempre accesso a tutti i suoi membri. La colonna Package ci dice invece quando il membro è accessibile dalle altre classi dello stesso package. La colonna Subclass indica invece quando una classe figlia ha accesso al membro, a prescindere dal package di appartenenza. La colonna World, infine, ci dice quando tutte le altre classi hanno accesso al membro.

I livelli di accesso influiscono in maniera significativa nella progettazione di un’interfaccia software. Quando si usano le classi provenienti da una libreria esterna, come ad esempio quelle della libreria standard di Java, i qualificatori determinano infatti quali classi e quali membri è possibile utilizzare nel proprio codice sorgente. Inoltre, quando si scrive una nuova classe e si definisce il livello di accesso di ogni singola variabile e di ciascun metodo, si definisce implicitamente una nuova interfaccia, nascondendo al mondo esterno l’implementazione dell’interfaccia stessa. Questo concetto è alla base dell’incapsulamento e del polimorfismo nel paradigma della programmazione a oggetti.

Prendiamo adesso, a titolo di esempio, un insieme di classi definite in due package distinti e vediamo come i qualificatori di accessi modificano la visibilità di ogni membro nelle altre classi.

classes-access

Visibilità
Modifier Alpha Beta Alphasub Gamma
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

 

Ecco alcuni consigli per scegliere il livello di accesso più appropriato: se altri programmatori usano la nostra classe, dobbiamo assicurarci che non si verifichino errori causati da un utilizzo scorretto.

  • Limitiamo l’accesso per quel particolare membro della classe al livello più restrittivo, purché ciò abbia senso. E’ sempre meglio usare il qualificatore private a meno che non ci sia una ragione valida per fare diversamente.
  • Evitiamo di dichiarare campi public, ad eccezione delle costanti. Variabili pubbliche tendono infatti a legarti a quella particolare implementazione e limita la flessibilità nella modifica e revisione del codice.