<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>
<HEAD>
<TITLE> From DOS/Windows to Linux HOWTO : File e programmi</TITLE>
<LINK HREF="DOS-to-Linux-HOWTO-3.html" REL=next>
<LINK HREF="DOS-to-Linux-HOWTO-1.html" REL=previous>
<LINK HREF="DOS-to-Linux-HOWTO.html#toc2" REL=contents>
</HEAD>
<BODY>
<A HREF="DOS-to-Linux-HOWTO-3.html">Avanti</A>
<A HREF="DOS-to-Linux-HOWTO-1.html">Indietro</A>
<A HREF="DOS-to-Linux-HOWTO.html#toc2">Indice</A>
<HR>
<H2><A NAME="s2">2. File e programmi</A></H2>
<P>
<P>
<H2><A NAME="ss2.1">2.1 File: nozioni preliminari</A>
</H2>
<P>
<P>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:
<P>
<UL>
<LI> 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, <CODE>Ecco.un_NOME_molto.LUNGO</CODE>. Notare che ho usato
lettere maiuscole e minuscole: infatti...
</LI>
<LI> maiuscole e minuscole sono considerate diverse. Quindi,
<CODE>FILENAME.tar.gz</CODE> e <CODE>filename.tar.gz</CODE> sono due file diversi.
<CODE>ls</CODE> e' un comando, <CODE>LS</CODE> e' un errore;
</LI>
<LI> 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:
<BLOCKQUOTE><CODE>
<PRE>
$ # questo comando crea una directory di nome "I miei file vecchi"
$ mkdir "I miei file vecchi"
$ ls
I miei file vecchi bin tmp
</PRE>
</CODE></BLOCKQUOTE>
Alcuni caratteri non dovrebbero ma possono essere usati; tra gli altri,
<CODE>!*$&</CODE>. Non vi spiego come.
</LI>
<LI> 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 <CODE>'*'</CODE> alla fine del loro nome quando si da' il comando
<CODE>ls -F</CODE>. Per esempio:
<BLOCKQUOTE><CODE>
<PRE>
$ ls -F
Direttorio/ cindy.jpg cjpg* lettera.txt script* vecchio~
</PRE>
</CODE></BLOCKQUOTE>
I files <CODE>cjpg*</CODE> e <CODE>script*</CODE> sono eseguibili---``programmi''.
Sotto DOS, i file di backup hanno il nome che finisce in .BAK, sotto Linux
finiscono con una tilde '<CODE>~</CODE>'. Inoltre, un file il cui nome inizia
con un punto viene considerato un file nascosto. Per esempio, il file
<CODE>.io.sono.nascosto</CODE> non apparira' dopo il comando <CODE>ls</CODE>.
</LI>
<LI> gli switch dei programmi DOS si ottengono con <CODE>/switch</CODE>, con i
programmi Linux si ottengono con <CODE>-switch</CODE> or <CODE>--switch</CODE>. Esempio:
<CODE>dir /s</CODE> diventa <CODE>ls -R</CODE>. Notare che molti programmi DOS, come
PKZIP o ARJ, hanno gli switch in stile Unix.
</LI>
</UL>
<P>Ora potete saltare alla sezione
<A HREF="#Files">Tradurre i comandi dal DOS a Linux</A>, ma se fossi in voi continuerei a leggere.
<P>
<H2><A NAME="ss2.2">2.2 Link simbolici</A>
</H2>
<P>
<P>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 <CODE>/usr/X11</CODE>, che punta a <CODE>/usr/X11R6</CODE>;
<CODE>/dev/modem</CODE>, che punta a <CODE>/dev/cua0</CODE> o <CODE>/dev/cua1</CODE>.
<P>Per fare un link simbolico:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ ln -s <file_o_dir> <nomelink>
</PRE>
</CODE></BLOCKQUOTE>
<P>Esempio:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ ln -s /usr/doc/g77/DOC g77manual.txt
</PRE>
</CODE></BLOCKQUOTE>
<P>Ora potete riferirvi a <CODE>g77manual.txt</CODE> al posto di
<CODE>/usr/doc/g77/DOC</CODE>. Ecco come appaiono i link quando date <CODE>ls</CODE>:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ ls -F
g77manual.txt@
$ ls -l
(various things...) g77manual.txt -> /usr/doc/g77/DOC
</PRE>
</CODE></BLOCKQUOTE>
<P>
<P>
<H2><A NAME="Permessi"></A> <A NAME="ss2.3">2.3 Permessi e Proprieta' </A>
</H2>
<P>
<P>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.
<P>Sotto Unix un file ha dei ``permessi'' e un proprietario, che appartiene ad
un ``gruppo''. Guardate questo esempio:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ ls -l /bin/ls
-rwxr-xr-x 1 root bin 27281 Aug 15 1995 /bin/ls*
</PRE>
</CODE></BLOCKQUOTE>
<P>Il primo campo contiene i permessi del file <CODE>/bin/ls</CODE>,
che appartiene a root, gruppo bin. Tralasciando le altre informazioni (il
libro di Matt Welsh e' li' per quello), ricordate che <CODE>-rwxr-xr-x</CODE>
significa (da sinistra a destra):
<P><CODE>-</CODE> e' il tipo di file (- = file normale, d = directory, l = link,
etc.); <CODE>rwx</CODE> sono i permessi per il proprietario del file (read, write,
execute); <CODE>r-x</CODE> 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 ;-) <CODE>r-x</CODE> sono i permessi per tutti gli altri
utenti (read, execute).
<P>Anche la directory <CODE>/bin</CODE> ha dei permessi: vedi la sezione
<A HREF="DOS-to-Linux-HOWTO-3.html#Permessi delle directory">Permessi delle directory</A> per ulteriori
dettagli. Ecco perché non potete cancellare il file <CODE>/bin/ls</CODE>, a
meno che non siate root: non avete i permessi necessari. Per cambiare i
permessi di un file, il comando e':
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod <whoXperm> <file>
</PRE>
</CODE></BLOCKQUOTE>
<P>dove who e' <CODE>u</CODE> (user, cioe' proprietario), <CODE>g</CODE> (group, gruppo), <CODE>o</CODE>
(other, altri), X e' <CODE>+</CODE> o <CODE>-</CODE>, perm e' <CODE>r</CODE> (read, lettura), <CODE>w</CODE>
(write, scrittura), o <CODE>x</CODE> (execute, esecuzione). Esempi:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod u+x file
</PRE>
</CODE></BLOCKQUOTE>
<P>setta il permesso di esecuzione per il proprietario. Scorciatoia:
<CODE>chmod +x file</CODE>.
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod go-rw file
</PRE>
</CODE></BLOCKQUOTE>
<P>toglie i permessi di lettura e scrittura per tutti tranne il proprietario.
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod ugo+rwx file
</PRE>
</CODE></BLOCKQUOTE>
<P>da' a tutti i permessi di lettura, scrittura ed esecuzione.
<P>
<BLOCKQUOTE><CODE>
<PRE>
# chmod +s file
</PRE>
</CODE></BLOCKQUOTE>
<P>rende un file ``setuid'' o ``suid'': ciascuno lo puo' eseguire con i
permessi del proprietario. Di solito si incontrano file ``suid root''.
<P>Una maniera piu' breve di riferirsi ai permessi e' con i numeri:
<CODE>rwxr-xr-x</CODE> puo' essere espresso con 755 (ogni lettera corrisponde a un
bit: <CODE>---</CODE> e' 0, <CODE>--x</CODE> e' 1, <CODE>-w-</CODE> e' 2, <CODE>-wx</CODE> e' 3...). Sembra
difficile, ma con un po' di pratica capirete il concetto.
<P>root, essendo il cossiddetto superutente, puo' cambiare i permessi di ogni
file. C'e' molto di piu' sull'argomento---LMP.
<P>
<H2><A NAME="Files"></A> <A NAME="ss2.4">2.4 Convertire i comandi dal DOS a Linux </A>
</H2>
<P>
<P>Alla sinistra, i comandi DOS; a destra, i corrispondenti comandi Linux.
<P>
<BLOCKQUOTE><CODE>
<PRE>
COPY: cp
DEL: rm
MOVE: mv
REN: mv
TYPE: more, less, cat
</PRE>
</CODE></BLOCKQUOTE>
<P>Operatori per la redirezione e il plumbing: <CODE> < > >> |</CODE>
<P>Wildcards: <CODE>* ?</CODE>
<P><CODE>nul: /dev/null</CODE>
<P><CODE>prn, lpt1: /dev/lp0 or /dev/lp1; lpr</CODE>
<P>- ESEMPI -
<P>
<BLOCKQUOTE><CODE>
<PRE>
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
</PRE>
</CODE></BLOCKQUOTE>
<P>Note:
<P>
<UL>
<LI> * e' migliore sotto Linux: * prende tutti i file tranne quelli
nascosti; .* tutti i file nascosti (ma anche la directory corrente `<CODE>.</CODE>'
e la directory genitrice `<CODE>..</CODE>'); *.* 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';
</LI>
<LI> usando <CODE>more</CODE>, premere SPAZIO per leggere il file,
`q' o CTRL-C per uscire. <CODE>less</CODE> e' piu' intuitivo, si possono usare i tasti
freccia;
</LI>
<LI> non c'e' <CODE>UNDELETE</CODE>, quindi <EM>pensarci bene</EM> prima di cancellare
un file;
</LI>
<LI> oltre a <CODE>< > >></CODE> del DOS, Linux ha <CODE>2></CODE> per
redirigere i messaggi di errore (stderr); inoltre, <CODE>2>&1</CODE> redirige
stderr su stdout, mentre <CODE>1>&2</CODE> redirige stdout su stderr;
</LI>
<LI> Linux ha un altro wildcard: la coppia <CODE>[]</CODE>. Uso: <CODE>[abc]*</CODE>
prende i file che cominciano con a, b, c; <CODE>*[I-N,1,2,3]</CODE> prende i file
che finiscono con I, J, K, L, M, N, 1, 2, 3;
</LI>
<LI> non c'e' un <CODE>RENAME</CODE> alla DOS; cioe', <CODE>mv</CODE> *.xxx *.yyy
non funziona. Potete usare questo script; dettagli alla sezione
<A HREF="DOS-to-Linux-HOWTO-7.html#Shell Scripts">Shell Scripts</A>.
<HR>
<PRE>
#!/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
</PRE>
<HR>
Attenti pero': non e' equivalente al <CODE>REN</CODE> del DOS, poiché usa le
``regular expressions'' che non conoscete ancora. In breve, se volete
cambiare le estensioni dei file, scrivete: <CODE>ren ``htm$'' ``html''
*htm</CODE>. Non dimenticate il <CODE>$</CODE>.
</LI>
<LI> usare <CODE>cp -i</CODE> e <CODE>mv -i</CODE> per essere avvisati se un file sta per
essere sovrascritto.
</LI>
</UL>
<P>
<H2><A NAME="ss2.5">2.5 Programmi: Multitasking e Sessioni</A>
</H2>
<P>
<P>Per far partire un programma, si scrive il suo nome come col DOS. Se la
directory (Sezione
<A HREF="DOS-to-Linux-HOWTO-3.html#Directories">Directories</A>) dove il
programma risiede e' nel PATH (Sezione
<A HREF="DOS-to-Linux-HOWTO-6.html#Files di inizializzazione">Files di inizializzazione</A>), 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 <CODE>prog</CODE> e' il programma,
scrivere <CODE>./prog</CODE>.
<P>Questa e' una tipica linea di comando:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ command -s1 -s2 ... -sn par1 par2 ... parn < input > output
</PRE>
</CODE></BLOCKQUOTE>
<P>dove <CODE>-s1</CODE>, ..., <CODE>-sn</CODE> sono gli switch del programma,
<CODE>par1</CODE>, ..., <CODE>parn</CODE> sono gli argomenti del programma. Si possono dare
piu' comandi sulla stessa linea:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ command1 ; command2 ; ... ; commandn
</PRE>
</CODE></BLOCKQUOTE>
<P>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!
<P>
<UL>
<LI> Per passare di sessione in sessione (1..6) nelle console virtuali:
<BLOCKQUOTE><CODE>
<PRE>
$ ALT-F1 ... ALT-F6
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> Per far partire un'altra sessione nella stessa console virtuale
senza lasciare quella corrente:
<BLOCKQUOTE><CODE>
<PRE>
$ su - <loginname>
</PRE>
</CODE></BLOCKQUOTE>
Esempio:
<BLOCKQUOTE><CODE>
<PRE>
$ su - root
</PRE>
</CODE></BLOCKQUOTE>
Questo e' utile, tra l'altro, per usare i floppy (Sezione
<A HREF="DOS-to-Linux-HOWTO-4.html#Floppies">Floppies</A>): normalmente, solo root lo puo' fare.
</LI>
<LI> Per chiudere una sessione:
<BLOCKQUOTE><CODE>
<PRE>
$ exit
</PRE>
</CODE></BLOCKQUOTE>
Se ci sono dei job sospesi (vedi piu' avanti) si viene avvisati.
</LI>
<LI> Per lanciare normalmente un processo in primo piano:
<BLOCKQUOTE><CODE>
<PRE>
$ progname [-switches] [parameters] [< input] [> output]
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> Per lanciare un processo in background, aggiungere una `e commerciale'
'<CODE>&</CODE>' alla fine della linea di comando:
<BLOCKQUOTE><CODE>
<PRE>
$ progname [-switches] [parameters] [< input] [> output] &
[1] 123
</PRE>
</CODE></BLOCKQUOTE>
la shell identifica i processi dando loro un numero (es. <CODE>[1]</CODE>; vedi
sotto) e un PID (123 nel nostro esempio).
</LI>
<LI> Per vedere quanti processi ci sono:
<BLOCKQUOTE><CODE>
<PRE>
$ ps -a
</PRE>
</CODE></BLOCKQUOTE>
Questo comando da' una lista dei processi attualmente in esecuzione.
</LI>
<LI> Per uccidere (terminare) un processo:
<BLOCKQUOTE><CODE>
<PRE>
$ kill <PID>
</PRE>
</CODE></BLOCKQUOTE>
Potreste dover uccidere un processo se non sapete come uscirne normalmente...
;-). A volte, un processo si puo' uccidere solo con:
<BLOCKQUOTE><CODE>
<PRE>
$ kill -SIGKILL <PID>
</PRE>
</CODE></BLOCKQUOTE>
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'.
</LI>
<LI> Per vedere quanti job ci sono:
<BLOCKQUOTE><CODE>
<PRE>
$ jobs
</PRE>
</CODE></BLOCKQUOTE>
qui i job sono identificati dal loro numero, non dal PID.
</LI>
<LI> Per fermare un job che gira in primo piano (non sempre funziona):
<BLOCKQUOTE><CODE>
<PRE>
$ CTRL-C
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> Per sospendere un processo che gira in primo piano (idem):
<BLOCKQUOTE><CODE>
<PRE>
$ CTRL-Z
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> Per mandare in background un processo sospeso:
<BLOCKQUOTE><CODE>
<PRE>
$ bg <job>
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> Per portare un job in primo piano:
<BLOCKQUOTE><CODE>
<PRE>
$ fg <job>
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> Per uccidere un job:
<BLOCKQUOTE><CODE>
<PRE>
$ kill <%job>
</PRE>
</CODE></BLOCKQUOTE>
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.
</LI>
</UL>
<P>
<H2><A NAME="ss2.6">2.6 Eseguire programmi su computer remoti</A>
</H2>
<P>
<P>Per eseguire un programma su un computer remoto il cui indirizzo IP e'
<CODE>remote.bigone.edu</CODE>, si fa:
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ telnet remote.bigone.edu
</PRE>
</CODE></BLOCKQUOTE>
<P>Dopo il login, si fa partire il programma. Ovviamente, bisogna avere uno
shell account sul computer remoto.
<P>Se avete X11, si possono far girare anche applicazioni X sul computer
remoto, e queste verranno visualizzate sul vostro schermo. Siano
<CODE>remote.bigone.edu</CODE> il computer remoto e <CODE>local.linux.box</CODE> il vostro
PC. Per far girare da <CODE>local.linux.box</CODE> un programma X che sta su
<CODE>remote.bigone.edu</CODE>, si fa:
<P>
<UL>
<LI> far partire X11 ed un <CODE>xterm</CODE> o equivalente emulatore di
terminale, poi digitare:
<BLOCKQUOTE><CODE>
<PRE>
$ xhost +remote.bigone.edu
$ telnet remote.bigone.edu
</PRE>
</CODE></BLOCKQUOTE>
</LI>
<LI> dopo il login, digitare:
<BLOCKQUOTE><CODE>
<PRE>
remote:$ DISPLAY=local.linux.box:0.0
remote:$ progname &
</PRE>
</CODE></BLOCKQUOTE>
(invece di <CODE>DISPLAY...</CODE>, potreste dover scrivere: <CODE>setenv DISPLAY local.linux.box:0.0</CODE>. Dipende dalla shell remota.)
</LI>
</UL>
<P>Et voila! Ora <CODE>progname</CODE> parte su <CODE>remote.bigone.edu</CODE> e viene
visualizzato sulla vostra macchina. È pero' meglio non provarci tramite modem,
perché e' assolutamente troppo lento.
<P>
<P>
<HR>
<A HREF="DOS-to-Linux-HOWTO-3.html">Avanti</A>
<A HREF="DOS-to-Linux-HOWTO-1.html">Indietro</A>
<A HREF="DOS-to-Linux-HOWTO.html#toc2">Indice</A>
</BODY>
</HTML>
