2. File e programmi

2.1 File: nozioni preliminari

Linux ha un file system---intendendo con cio' ``la struttura delle directory e dei file in esse contenuti''---molto simile a quello del DOS. I file hanno dei nomi che seguono certe regole, sono messi in directory, alcuni sono eseguibili, e tra questi ultimi molti hanno degli switch. Inoltre, ci sono i caratteri wildcards, la redirezione e il piping. Ci sono solo alcune piccole differenze:

• sotto DOS, i nomi dei file seguono la regola dell'8.3; per esempio, ILMIOFIL.TXT. Sotto Linux si puo' fare meglio. Se avete installato Linux con un filesystem come ext2 o umsdos, potete usare nomi piu' lunghi, e con piu' di un punto: per esempio, Ecco.un_NOME_molto.LUNGO. Notare che ho usato lettere maiuscole e minuscole: infatti...
• maiuscole e minuscole sono considerate diverse. Quindi, FILENAME.tar.gz e filename.tar.gz sono due file diversi. ls e' un comando, LS e' un errore;
• gli utenti di Windows 95 possono usare i nomi di file lunghi con Linux, naturalmente. Se il nome di un file contiene spazi (pratica sconsigliata ma possibile), bisogna racchiudere il nome del file tra apici quando vi ci si riferisce. Per esempio:

  $ # questo comando crea una directory di nome "I miei file vecchi"
  $ mkdir "I miei file vecchi"
  $ ls
  I miei file vecchi      bin     tmp
  

  Alcuni caratteri non dovrebbero ma possono essere usati; tra gli altri, !*$&. Non vi spiego come.
• non ci sono estensioni obbligatorie come .COM ed .EXE per i programmi, o .BAT per i file batch. I files eseguibili sono contrassegnati da un asterisco '*' alla fine del loro nome quando si da' il comando ls -F. Per esempio:

  $ ls -F
  Direttorio/   cindy.jpg    cjpg*    lettera.txt    script*    vecchio~
  

  I files cjpg* e script* sono eseguibili---``programmi''. Sotto DOS, i file di backup hanno il nome che finisce in .BAK, sotto Linux finiscono con una tilde '~'. Inoltre, un file il cui nome inizia con un punto viene considerato un file nascosto. Per esempio, il file .io.sono.nascosto non apparira' dopo il comando ls.
• gli switch dei programmi DOS si ottengono con /switch, con i programmi Linux si ottengono con -switch or --switch. Esempio: dir /s diventa ls -R. Notare che molti programmi DOS, come PKZIP o ARJ, hanno gli switch in stile Unix.

Ora potete saltare alla sezione Tradurre i comandi dal DOS a Linux, ma se fossi in voi continuerei a leggere.

2.2 Link simbolici

Unix ha un tipo di file che il DOS non ha: il link simbolico. Questo e' un puntatore ad un file o directory, e puo' essere usato al posto del file o directory a cui punta; e' molto simile ai colegamenti di Windows 95. Esempi di link simbolici sono /usr/X11, che punta a /usr/X11R6; /dev/modem, che punta a /dev/cua0 o /dev/cua1.

Per fare un link simbolico:

$ ln -s <file_o_dir> <nomelink>

Esempio:

$ ln -s /usr/doc/g77/DOC g77manual.txt

Ora potete riferirvi a g77manual.txt al posto di /usr/doc/g77/DOC. Ecco come appaiono i link quando date ls:

$ ls -F
g77manual.txt@
$ ls -l
(various things...)           g77manual.txt -> /usr/doc/g77/DOC

2.3 Permessi e Proprieta'

I file e le directory DOS hanno i seguenti attributi: A (archivio), H (hidden, nascosto), R (read-only, solo lettura), and S (system, file di sistema). Solo H e R hanno senso sotto Linux: i files nascosti iniziano con un punto, e per quanto riguarda l'attributo R, continuate a leggere.

Sotto Unix un file ha dei ``permessi'' e un proprietario, che appartiene ad un ``gruppo''. Guardate questo esempio:

$ ls -l /bin/ls
-rwxr-xr-x  1  root  bin  27281 Aug 15 1995 /bin/ls*

Il primo campo contiene i permessi del file /bin/ls, che appartiene a root, gruppo bin. Tralasciando le altre informazioni (il libro di Matt Welsh e' li' per quello), ricordate che -rwxr-xr-x significa (da sinistra a destra):

- e' il tipo di file (- = file normale, d = directory, l = link, etc.); rwx sono i permessi per il proprietario del file (read, write, execute); r-x sono i permessi per il gruppo cui il proprietario del file appartiene (non spieghero' il concetto di gruppo, ne potete fare a meno finché siete principianti ;-) r-x sono i permessi per tutti gli altri utenti (read, execute).

Anche la directory /bin ha dei permessi: vedi la sezione Permessi delle directory per ulteriori dettagli. Ecco perché non potete cancellare il file /bin/ls, a meno che non siate root: non avete i permessi necessari. Per cambiare i permessi di un file, il comando e':

$ chmod <whoXperm> <file>

dove who e' u (user, cioe' proprietario), g (group, gruppo), o (other, altri), X e' + o -, perm e' r (read, lettura), w (write, scrittura), o x (execute, esecuzione). Esempi:

$ chmod u+x file

setta il permesso di esecuzione per il proprietario. Scorciatoia: chmod +x file.

$ chmod go-rw file

toglie i permessi di lettura e scrittura per tutti tranne il proprietario.

$ chmod ugo+rwx file

da' a tutti i permessi di lettura, scrittura ed esecuzione.

# chmod +s file

rende un file ``setuid'' o ``suid'': ciascuno lo puo' eseguire con i permessi del proprietario. Di solito si incontrano file ``suid root''.

Una maniera piu' breve di riferirsi ai permessi e' con i numeri: rwxr-xr-x puo' essere espresso con 755 (ogni lettera corrisponde a un bit: --- e' 0, --x e' 1, -w- e' 2, -wx e' 3...). Sembra difficile, ma con un po' di pratica capirete il concetto.

root, essendo il cossiddetto superutente, puo' cambiare i permessi di ogni file. C'e' molto di piu' sull'argomento---LMP.

2.4 Convertire i comandi dal DOS a Linux

Alla sinistra, i comandi DOS; a destra, i corrispondenti comandi Linux.

COPY:           cp
DEL:            rm
MOVE:           mv
REN:            mv
TYPE:           more, less, cat

Operatori per la redirezione e il plumbing: < > >> |

Wildcards: * ?

nul: /dev/null

prn, lpt1: /dev/lp0 or /dev/lp1; lpr

- ESEMPI -

DOS                                     Linux
---------------------------------------------------------------------

C:\GUIDO>COPY JOE.TXT JOE.DOC           $ cp joe.txt joe.doc
C:\GUIDO>COPY *.* TOTAL                 $ cat * > total
C:\GUIDO>COPY FRACTALS.DOC PRN          $ lpr fractals.doc
C:\GUIDO>DEL TEMP                       $ rm temp
C:\GUIDO>DEL *.BAK                      $ rm *~
C:\GUIDO>MOVE PAPER.TXT TMP\            $ mv paper.txt tmp/
C:\GUIDO>REN PAPER.TXT PAPER.ASC        $ mv paper.txt paper.asc
C:\GUIDO>PRINT LETTER.TXT               $ lpr letter.txt
C:\GUIDO>TYPE LETTER.TXT                $ more letter.txt
C:\GUIDO>TYPE LETTER.TXT                $ less letter.txt
C:\GUIDO>TYPE LETTER.TXT > NUL          $ cat letter.txt > /dev/null
        n/a                             $ more *.txt *.asc
        n/a                             $ cat section*.txt | less

Note:

• * e' migliore sotto Linux: * prende tutti i file tranne quelli nascosti; .* tutti i file nascosti (ma anche la directory corrente `.' e la directory genitrice `..'); *.* prende tutti i file che hanno un `.' nel mezzo o che finiscono per punto; p*a prende sia `pera' che `palla'; *l* prende sia `mela' che `filo';
• usando more, premere SPAZIO per leggere il file, `q' o CTRL-C per uscire. less e' piu' intuitivo, si possono usare i tasti freccia;
• non c'e' UNDELETE, quindi pensarci bene prima di cancellare un file;
• oltre a < > >> del DOS, Linux ha 2> per redirigere i messaggi di errore (stderr); inoltre, 2>&1 redirige stderr su stdout, mentre 1>&2 redirige stdout su stderr;
• Linux ha un altro wildcard: la coppia []. Uso: [abc]* prende i file che cominciano con a, b, c; *[I-N,1,2,3] prende i file che finiscono con I, J, K, L, M, N, 1, 2, 3;
• non c'e' un RENAME alla DOS; cioe', mv *.xxx *.yyy non funziona. Potete usare questo script; dettagli alla sezione Shell Scripts.

  ---

  #!/bin/sh
  # ren: rename multiple files according to several rules
  
  if [ $# -lt 3 ] ; then
    echo "usage: ren \"pattern\" \"replacement\" files..."
    exit 1
  fi
      
  OLD=$1 ; NEW=$2 ; shift ; shift
      
  for file in $*
  do
    new=echo ${file} | sed s/${OLD}/${NEW}/g
    mv ${file} $new
  done
  

  ---

  Attenti pero': non e' equivalente al REN del DOS, poiché usa le ``regular expressions'' che non conoscete ancora. In breve, se volete cambiare le estensioni dei file, scrivete: ren ``htm$'' ``html'' *htm. Non dimenticate il $.
• usare cp -i e mv -i per essere avvisati se un file sta per essere sovrascritto.

2.5 Programmi: Multitasking e Sessioni

Per far partire un programma, si scrive il suo nome come col DOS. Se la directory (Sezione Directories) dove il programma risiede e' nel PATH (Sezione Files di inizializzazione), il programma parte. Eccezione: sotto Linux, un programma che sta nella directory corrente non parte se la directory non e' inclusa nel PATH. Scappatoia: se prog e' il programma, scrivere ./prog.

Questa e' una tipica linea di comando:

$ command -s1 -s2 ... -sn par1 par2 ... parn < input > output

dove -s1, ..., -sn sono gli switch del programma, par1, ..., parn sono gli argomenti del programma. Si possono dare piu' comandi sulla stessa linea:

$ command1 ; command2 ; ... ; commandn

Tutto qui per quanto riguarda i programmi, ma e' facile fare dei passi avanti. Uno dei vantaggi di Linux e' il multitasking: puo' far girare piu' programmi (d'ora in poi, processi) allo stesso tempo. Si possono lanciare programmi in background e continuare a lavorare. Inoltre, Linux mette a disposizione piu' sessioni di lavoro contemporanee: e' come avere tanti computer allo stesso tempo!

• Per passare di sessione in sessione (1..6) nelle console virtuali:

  $ ALT-F1 ... ALT-F6
  

• Per far partire un'altra sessione nella stessa console virtuale senza lasciare quella corrente:

   
  $ su - <loginname> 
  

  Esempio:

   
  $ su - root 
  

  Questo e' utile, tra l'altro, per usare i floppy (Sezione Floppies): normalmente, solo root lo puo' fare.
• Per chiudere una sessione:

  $ exit
  

  Se ci sono dei job sospesi (vedi piu' avanti) si viene avvisati.
• Per lanciare normalmente un processo in primo piano:

  $ progname [-switches] [parameters] [< input] [> output]
  

• Per lanciare un processo in background, aggiungere una `e commerciale' '&' alla fine della linea di comando:

   
  $ progname [-switches] [parameters] [< input] [> output] &
  [1] 123
  

  la shell identifica i processi dando loro un numero (es. [1]; vedi sotto) e un PID (123 nel nostro esempio).
• Per vedere quanti processi ci sono:

  $ ps -a
  

  Questo comando da' una lista dei processi attualmente in esecuzione.
• Per uccidere (terminare) un processo:

  $ kill <PID>
  

  Potreste dover uccidere un processo se non sapete come uscirne normalmente... ;-). A volte, un processo si puo' uccidere solo con:

  $ kill -SIGKILL <PID>
  

  Oltre a questo, la shell consente di fermare o sospendere un processo, mandare un processo in background, e portare un processo dal background in primo piano. In questo contesto, i processi sono chiamati `job'.
• Per vedere quanti job ci sono:

  $ jobs
  

  qui i job sono identificati dal loro numero, non dal PID.
• Per fermare un job che gira in primo piano (non sempre funziona):

  $ CTRL-C
  

• Per sospendere un processo che gira in primo piano (idem):

  $ CTRL-Z
  

• Per mandare in background un processo sospeso:

  $ bg <job>
  

• Per portare un job in primo piano:

  $ fg <job>
  

• Per uccidere un job:

  $ kill <%job>
  

  dove <job> puo' essere 1, 2, 3, ... Usando questi comandi si puo' formattare un disco, zippare dei files, compilare un programma e decompattare un archivio tutto allo stesso tempo, e ancora avere il prompt a disposizione. Provate a farlo col DOS! E provate con Windows, giusto per vedere la differenza in performance.

2.6 Eseguire programmi su computer remoti

Per eseguire un programma su un computer remoto il cui indirizzo IP e' remote.bigone.edu, si fa:

$ telnet remote.bigone.edu

Dopo il login, si fa partire il programma. Ovviamente, bisogna avere uno shell account sul computer remoto.

Se avete X11, si possono far girare anche applicazioni X sul computer remoto, e queste verranno visualizzate sul vostro schermo. Siano remote.bigone.edu il computer remoto e local.linux.box il vostro PC. Per far girare da local.linux.box un programma X che sta su remote.bigone.edu, si fa:

• far partire X11 ed un xterm o equivalente emulatore di terminale, poi digitare:

  $ xhost +remote.bigone.edu
  $ telnet remote.bigone.edu
  

• dopo il login, digitare:

  remote:$ DISPLAY=local.linux.box:0.0
  remote:$ progname &
  

  (invece di DISPLAY..., potreste dover scrivere: setenv DISPLAY local.linux.box:0.0. Dipende dalla shell remota.)

Et voila! Ora progname parte su remote.bigone.edu e viene visualizzato sulla vostra macchina. È pero' meglio non provarci tramite modem, perché e' assolutamente troppo lento.