Newsgroup: it.comp.os.linux.debian
Titolo: Collegamento Comando --> Script

Salve, premetto che lavoro sulla distribuzione Ubuntu 5.10.
Ho cercato nelle discussioni e un pò in giro, ma non credo di averci
capito molto; inoltre non so bene se le soluzioni trovate erano
appropriate per il mio scopo. Allora, io ho uno shell script ( file.sh
per intenderci ) in cui ho scritto due semplici comandi di richiamo di
altri comandi. Ora, vorrei associare un comando da terminale che mi
eseguisse autonomamente il mio script. Faccio un esempio :
quando da terminale scrivete alien, il sistema capisce che deve
richiamare lo script alien per la conversione dei *.mbr ( o come si
kiamano i pacchetti mandiriva ) in *.deb.
Ebbene, io vorrei fare la stessa cosa; associare un comando, per
esempio miocmd1, che mi esegua in automatico il mio script. Da quanto
ho letto è possibile, ma non ho ben capito dove e cosa devo modificare
nelle impostazioni, per renderlo possibile.
Grazie dell'aiuto.
Marco

 esempio miocmd1, che mi esegua in automatico il mio script. Da quanto
  Sicuramente ho capito male io, ma se hai uno script 'file.sh' che e' 
eseguibile e lo piazzi nel path (che so, in /usr/local/bin) non ti e' 
sufficiente digitare direttamente 'file.sh' senza fare altro?
  Saluti,
-- 
Gianfranco Bertozzi
Linux User #183585
gber...@tiscali.it

Veramente è proprio quello che volevo fare...
In maniera sintetica, cosa ho fatto ?? Ponendo i file sh nel bin di usr
faccio "conoscere" al sistema gli script e quindi i comandi ??


Molto in breve:
1) Prendi il tuo script di shell, e mettici come prima riga
    #!/bin/bash
    (senza spazi davanti al "#", e senza righe vuote prima)
2) Piazza il tuo script di shell in /usr/local/bin
3) Cambia i permessi al tuo script di shell in modo che sia
    leggibile ed eseguibile da tutti.
    Con Nautilus di Gnome significa:
    - tasto destro sullo script -> proprietà -> linguetta "Permessi"
    - imposti lettura, scrittura ed esecuzione per il proprietario
    - imposti lettura ed esecuzione per gruppo e altri
4) Apri un terminale, digiti il nome del tuo script, e dovrebbe
    funzionare.
Meno in breve:
Quando apri un terminale, in esso viene automaticamente avviato un 
programma, che per default è una shell come ad esempio Bash.
Ogni volta che digiti un comando nella shell, la shell prende la prima 
parola del comando e fa questo ragionamento:
1) la parola contiene "/"? Se si, allora si tratta di un nome
    relativo od assoluto di un file: se il file indicato esiste
    ed è eseguibile, salta direttamente al punto 4.
2) la parola non contiene "/"? Allora vediamo se si tratta di un
    comando interno (es. "cd" è un comando interno, implementato
    direttamente dalla shell). Se lo è, passa ad eseguirlo.
3) Se invece non si tratta di un comando interno, va a cercare in
    tutte le cartelle elencate nella variabile d'ambiente $PATH
    se esiste un file che abbia i permessi di esecuzione e che si
    chiami esattamente come il comando da eseguire. Il primo file
    trovato che soddisfa queste condizioni viene preso per buono
    Notare che se tra le cartelle elencate in $PATH non c'è la cartella
    corrente ("."), la cartella corrente NON viene esaminata (a
    differenza di MS-DOS e Windows, dove invece viene sempre
    implicitamente esaminata anche se non è elencata in $PATH).
4) Ora che abbiamo il file, la palla viene passata al kernel che
    riverifica che il file esista e che abbia i permessi di lettura ed 	
    esecuzione appropriati per l'utente che lo vuole avviare.
    Fatto questo, cerca di stabilire se si tratta di un file
    eseguibile binario o se invece non lo è. Per stabilirlo, il kernel
    guarda i primi byte del file.
    Se si tratta di un file eseguibile binario, il kernel lo "avvia"
    caricandolo in memoria. Fine del giro.
5) Se non si tratta di un eseguibile binario, allora il kernel
    guarda se i primi due byte del file corrispondono ai caratteri
    ASCII "#!". Se non corrispondono, il kernel risponde errore
    (il file non è un eseguibile, anche se ha i permessi d'esecuzione),
    ed il giro finisce.
6) Se invece corrispondono, il kernel prende ciò che segue i
    due caratteri (nel nostro caso "/bin/bash") e lo considera come
    il nome di un file da eseguire e a cui passare come parametro
    il nome dello script. Il risultato netto è che il kernel
    esegue per te il comando "/bin/bash /usr/local/bin/script.sh"
Il giro è sostanzialmente questo (ho semplificato e ho omesso dei casi 
speciali ed il trattamento dei parametri, ma copre la stragrande 
maggioranza dei casi).
Notare quindi che per un sistema Unix, gli script (di shell o di 
qualsiasi altro linguaggio di scripting) e gli eseguibili binari hanno 
pari dignità, e, se vuoi, ci puoi anche leggere il motivo per cui "#" è 
il carattere di commento in quasi tutti i linguaggi di scripting.
-- 
  (\_/)   |   \    \  | ___|_   |_   |   /\/\  ianezz a casa sua... :-)
  (^.^)   |  _ \  | \ | _|     /    /   {^.^ } Verba volant, scripta
/(")(") _|_/  _\_|  _|____|____|____| (")(")\ manent, data corrupted