Archivi categoria: WikiNotes

Come riparare i permessi in Mac OS X El Capitan

A partire dalla versione 10.11 di Mac OS X (nome in codice El Capitan) la riparazione dei permessi è diventata una procedura gestita dal sistema in maniera autonoma. Pertanto è stato rimosso il comando Ripara i permessi da Utility Disco.

Quindi l’utente non deve più preoccuparsi di farlo e lasciare che ci pensi il sistema. Tuttavia per chi lo desidera, è possibile ancora eseguire la verifica tramite Terminale:

sudo /usr/libexec/repair_packages --verify --standard-pkgs /

Se l’operazione di verifica rileva dei problemi si può procedere con la riparazione:

sudo /usr/libexec/repair_packages --repair --standard-pkgs /

Le operazioni di verifica e di riparazione possono richiedere da pochi istanti a più di mezz’ora. Attendere sempre la fine di ciascun processo.

Installare OS X 10.11 El Capitan da zero

Per effettuare un’installazione pulita di OS X El Capitan è necessario disporre di un supporto esterno da cui poter avviare l’installazione.

Il software di installazione è disponibile (per il momento) dall’App Store. Una volta scaricato sul proprio Mac (che dovrà avere i requisiti minimi previsti) sarà possibile preparare il supporto esterno per avviare l’installazione attraverso la seguente procedura.

Innanzitutto procuriamoci un hard disk esterno o una pendrive USB vuota di capacità pari ad almeno 8 GB. Tramite Utility Disco formattiamola  cosi:

  • Nome: Install OS X El Capitan
  • Formato: OS X esterno (journaled)
  • Schema: Mappa partizione GUID

Inizializzazione supporto esterno

Dopodiché apriamo Terminale e inseriamo il seguente comando:

$ sudo /Applications/Install\ OS\ X\ El\ Capitan.app/Contents/Resources/createinstallmedia --volume /Volumes/Install\ OS\ X\ El\ Capitan/ --applicationpath /Applications/Install\ OS\ X\ El\ Capitan.app/ --nointeraction

e attendiamo la fine del processo di scrittura che può richiedere diversi minuti.

Scrittura supporto esterno

A questo punto riavviamo il Mac e, tenendo premuto il tasto Alt, selezioniamo il nostro supporto esterno come disco di avvio. Seguire quindi la procedura guidata per effettuare l’installazione (o se lo si desidera aggiornare il sistema esistente) di OS X El Capitan.

Identificare l’indirizzo IP di un dispositivo con Wireshark

Al giorno d’oggi esistono diversi tipi di apparati  in grado di comunicare in rete via TCP/IP: centrali di allarme, nebbiogeni, DVR, ecc. Non solo computer quindi, ma anche dispositivi di vario genere dotati di interfaccia di rete e quindi di un indirizzo IP. Molti di essi offrono addirittura la possibilità di essere configurati via web e di essere comandati da remoto, secondo le possibilità offerte dall’infrastruttura di rete alla quale questi apparati vengono collegati.

Capita a volte, per i motivi più disparati, di perdere o dimenticare l’indirizzo IP statico assegnato al dispositivo in fase di setup. Purtroppo in questi casi si è costretti a ripristare le impostazioni di default, perdendo così tutta la configurazione. Esiste un’alternativa: utilizzare Wireshark per sniffare il traffico di rete generato dal dispositivo e identificare così il suo indirizzo IP.

La procedura consiste nell’avviare il programma, selezionare l’interfaccia di rete corretta (ad esempio la scheda ethernet integrata), avviare il capturing  e collegare il proprio computer direttamente al dispositivo tramite un cavo incrociato.

Sullo schermo appariranno i primi pacchetti. Quelli di nostro interesse sono i pacchetti ARP generati dal dispositivo. Il protocollo ARP è un sistema attraverso il quale si associa l’indirizzo IP all’indirizzo fisco della scheda di rete (mac address) e serve per l’instradamento dei pacchetti nella rete.

Non importa che la scheda del nostro computer sia configurata sulla stessa sotto rete del dispositivo, ma è importante che sia configurata con un indirizzo IP statico.

Wireshark_arp

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.

 

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.