  Linux from DOS to Linux HOWTO
  di Guido Gonzato <guido@ibogfs.df.unibo.it>
  v1.0, 11 dicembre 1996

  Questo HOWTO  dedicato a tutti gli utenti DOS che hanno deciso di
  passare a Linux, il clone Unix per PC 386 e superiori. Date le analo
  gie tra DOS e Unix, lo scopo di questo lavoro  di aiutare il lettore
  a trasportare le sue conoscenze di DOS nell'ambiente Linux, cos da
  poter lavorare da subito.

  1.  Introduzione

  1.1.  Linux fa per te?

  Volete passare dal DOS a Linux? Benissimo, ma attenzione: potrebbe non
  esservi utile. Credo che ``il computer migliore'' o ``il migliore
  sistema operativo'' non esistano: dipende dall'uso che se ne fa. Ecco
  perch non credo che Linux sia la soluzione migliore per tutti,
  nonostante sia tecnicamente superiore a molti sistemi operativi
  commerciali. Avrete grandi benefici da Linux se vi serve sw per la
  programmazione, Internet, TeX... sw tecnico in generale, ma se vi
  serve soprattutto sw commerciale, o se non vi piace l'idea di studiare
  i comandi,  meglio lasciare perdere.

  Linux non  (per ora) facile da usare o da configurare come Windows o
  il Mac, quindi siate preparati a smanettare un po'. Nonstante questi
  avvertimenti, sono sicuro al 100% che se appartienete alla giusta
  categoria di utenti troverete in Linux il vostro Nirvana informatico.
  E comunque Linux e DOS/Windows possono convivere sulla stessa
  macchina.

  Prerequisiti per questo howto: dar per scontato che

    conoscete i principali comandi e concetti del DOS;

    Linux, e magari anche X Window System,  correttamente installato;

    la vostra shell---l'equivalente di COMMAND.COM--- bash;

    capite che questo lavoro  solo un inizio. Pe maggiori
     informazioni, guardatevi ``Linux Installation and Getting Started''
     di Matt Welsh e/o ``Linux User Guide'' di Larry Greenfield
     (sunsite.unc.edu:/pub/Linux/docs/LDP).

  Questo howto sostituisce il vecchio mini-howto di uguale titolo.

  1.2.  S, fa per me. Spiegami

  Avete installato Linux e i programmi che vi servono. Vi siete fatti un
  account (se non l'avete fatto, scrivete adduser subito!) e Linux sta
  girando. Havete inserito nome e password e ora state guardando lo
  schermo e pensate: ``Beh, e adesso?''

  Adesso, non disperate. Siete quasi pronti per fare le stesse cose che
  facevate col DOS, e molte altre in pi. Se steste lavorando col DOS
  anzich con Linux, ora fareste una di queste cose:

    eseguire programmi e creare, copiare, visualizzare, cancellare,
     stampare e rinominare files;
    spostarsi tra directories, crearne di nuove, cancellarle, elencarne
     i contenuti;

    formattare floppies e copiarci file su/da;

    sistemare AUTOEXEC.BAT e CONFIG.SYS;

    scrivere i vostri .BAT files e/o programmi in QBasic o altro
     linguaggio;

    il rimanente 1%.

  Sarete contenti di sapere che queste cose si fanno con Linux in un
  modo molto simile al DOS. Sotto DOS, l'utente medio usa solo pochi tra
  i 100 e passa comandi disponibili; lo stesso vale per Linux, almeno
  fino ad un certo punto.

  Alcune cose da aver chiare prima di proseguire:

    primo, come uscire da Linux. Se si vede una schermata non grafica,
     premere CTRL-ALT-DEL, aspettare che il sistema ti dica che tutto 
     a posto, poi spegnere pure. Se si sta lavorando sotto X Window
     System, prima premere CTRL-ALT-BACKSPACE, poi CTRL-ALT-DEL. Non
     spegnere mai il PC direttamente: si potrebbe danneggiare il
     filesystem;

    a differenza del DOS, Linux ha meccanismi di sicurezza, a causa
     della sua natura multiutente. I file e le directory hanno dei
     permessi, e quindi ad alcuni l'utente normale non pu accedere
     (vedi la sezione ``Permessi''). Solo l'utente il cui nome di login
      ``root'' pu fare ci che vuole (root  l'amministratore di
     sistema. Se usate Linux sul vostro PC, sarete anche root). Il DOS,
     al contrario, vi lascia cancellare tutto l'hard disk per sbaglio;

    siete incoraggiati a sperimentare, giocare, provare: di certo male
     non fa. Potete ottenere aiuto scrivendo al prompt ($  il prompt
     normale, #  quello per root):

       $ help

  (questo d aiuto su bash), od ottenere informazioni su un comando
  scrivendo

       $ man comando

  che, se avete installato le man pages (manuale in linea), richiama la
  man page di comando. Potete inoltre provare:

       $ apropos command
       $ whatis command

  e premere 'q' per uscire.

    buona parte della potenza e flessibilit di Unix vengono dai
     semplici concetti di redirezione e piping, pi potenti che non
     sotto DOS. Semplici comandi possono essere combinati per eseguire
     operazioni complesse. Usate questa caratteristica!

    convenzioni: <...> indica qualcosa che deve essere specificato,
     mentre [...] indica qualcosa di opzionale. Esempio:

       $ tar -tf <file.tar> [> redir_file]

  file.tar deve essere specificato, mentre la redirezione su redir_file
   opzionale.

    d'ora in avanti ``LMP'' significa ``leggere la man page per
     ulteriori informazioni''.

  1.3.  Per l'impaziente

  Volete partire subito? Date un'occhiata a questa tabella:

       DOS                     Linux                   Note
       ------------------------------------------------------------------------------

       BACKUP                  tar -Mcvf device dir/   totalmente diversi
       CD dirname\             cd dirname/             quasi la stessa sintassi
       COPY file1 file2        cp file1 file2          idem
       DEL file                rm file                 attenzione - niente undelete
       DELTREE dirname         rm -R dirname/          idem
       DIR                     ls                      non proprio la stessa sintassi
       EDIT file               vi file                 credo che non ti piacer
                               emacs file              questo  migliore
                               jstar file              quasi come l'editor del DOS
       FORMAT                  fdformat,
                               mount, umount           sintassi molto diversa
       HELP command            man command             stessa filosofia
       MD dirname              mkdir dirname/          quasi la stessa sintassi
       MOVE file1 file2        mv file1 file2          idem
       NUL                     /dev/null               idem
       PRINT file              lpr file                idem
       PRN                     /dev/lp0,
                               /dev/lp1                idem
       RD dirname              rmdir dirname/          quasi la stessa sintassi
       REN file1 file2         mv file1 file2          non per file multipli
       RESTORE                 tar -Mxpvf device       sintassi diversa
       TYPE file               less file               molto migliore
       WIN                     startx                  un mondo a parte!

  Se vi serve di pi che una tabella di comandi, leggetevi le prossime
  sezioni.

  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 pu fare meglio. Se avete installato
     Linux con un filesystem come ext2 o umsdos, potete usare nomi pi
     lunghi, e con pi 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  un
     comando, LS  un errore;

    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 d il comando ls -F. Per esempio:

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

  I files  cjpg* e script* sono eseguibili---``programmi''.  Sotto DOS,
  i file di backup hanno il nome che finisce in .BAK, sotto Linux finis
  cono con una tilde '~'. Inoltre, un file il cui nome inizia con un
  punto viene considerato un file nascosto. Per esempio, il file

    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 
  un puntatore ad un file o directory, e pu essere usato al posto del
  file o directory a cui punta;  molto simile a XXXXX 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.

  2.3.  Permessi e Propriet

  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  l per quello), ricordate che -rwxr-xr-x significa (da
  sinistra a destra):

  -  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 spiegher il concetto di gruppo, ne potete fare a
  meno finch siete principianti ;-) r-x sono i permessi per tutti gli
  altri utenti (read, execute).

  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 :

       $ chmod <whoXperm> <file>

  dove who  u (user, cio proprietario), g (group, gruppo), o (other,
  altri), X  + o -, perm  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-wx file

  toglie i permessi di scrittura ed esecuzione per tutti tranne il
  proprietario.

       $ chmod ugo+rwx file

  d a tutti i permessi di lettura, scrittura ed esecuzione.

       # chmod +s file

  rende un file ``setuid'' o ``suid'': ciascuno lo pu eseguire con i
  permessi di root.

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

  root, essendo il cossiddetto superutente, pu cambiare i permessi di
  ogni file. C' molto di pi 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

  - EXAMPLES -

       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:

    *  migliore sotto Linux: * prende tutti i file tranne quelli
     nascosti; .* tutti i file nascosti; *.* prende tutti i file che
     hanno un `.' nel mezzo, seguito da altri caratteri; 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  pi intuitivo, si possono usare i tasti freccia;

    non c' UNDELETE, quindi pensarci bene prima di cancellare;

    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' un RENAME alla DOS; cio, mv *.xxx *.yyy non funziona;

    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  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  inclusa nel PATH. Scappatoia: se prog
   il programma, scrivere ./prog.
  Questa  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 pi comandi sulla stessa
  linea:

       $ command1 ; command2 ; ... ; commandn

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

    Per passare di sessione in sessione (1..6):

       $ ALT-F1 ... ALT-F6

    Per far partire un'altra sessione senza lasciare quella corrente:

        $ su - <loginname>

  Esempio:

        $ su - root

  Questo  utile, tra l'altro, per usare i floppy (Sezione ``Flop
  pies''): normalmente, solo root lo pu fare.

    Per chiudere una sessione:

       $ exit

  Se ci sono dei job sospesi (vedi pi avanti) si viene avvisati.

    Per lanciare un processo in primo piano:

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

    Per lanciare un processo in background, aggiungere una `e
     commerciale'

       $ 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 d una lista dei processi attualmente in esecuzione.

    Per uccidere (terminare) un processo:

       $ kill <PID>

  Potreste dover uccidere un processo se non sapete come uscire normal
  mente...  ;-). A volte, un processo si pu uccidere solo con uno dei
  comandi seguenti:

       $ kill -15 <PID>
       $ kill -9 <PID>

  Oltre a questo, la shell consente di fermare o sospendere un processo,
  mandare un processo in background, e portare un processo dal back
  ground 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> pu essere 1, 2, 3, ...  Usando questi comandi si pu for
  mattare un disco, zippare dei files, compilare un programma e decom
  pattare 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 
  remote.bigone.edu, si fa:

       $ telnet remote.bigone.edu

  Dopo il login, si fa partire il programma. Ovviamente, bisogna avere
  un 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.  per meglio non provarci tramite PPP.

  3.  Usare le directory

  3.1.  Directory: nozioni preliminari

  Abbiamo visto le differenze tra i file sotto DOS e sotto Linux. Per
  quanto riguarda le directory, sotto DOS la directory principale 
  sotto Linux  /. In maniera analoga, le directory sono separate da
   sotto DOS e da / sotto Linux. Esempio:

       DOS:    C:\PAPERS\GEOLOGY\MID_EOC.TEX
       Linux:  /home/guido/papers/geology/mid_eocene.tex

  Come al solito, ..  la directory genitrice, .  la directory
  corrente. Ricordate che il sistema non vi lascia fare cd, rd o md
  ovunque si vuole. Ogni utente ``risiede'' in una sua directory
  chiamata 'home', che viene assegnata dall'amministratore di sistema.
  Per esempio, sul mio PC la mia home directory  /home/guido.

  3.2.  Permessi delle directory

  Anche le directory hanno i permessi. Quanto visto in Sezione
  ``Permessi'' vale anche per le directory (user, group, e other). Per
  una directory, rx significa che potete fare cd nella directory, e w
  significa che potete cancellare i file nella directory, o la directory
  stessa. Per esempio, per impedire ad altri utenti di curiosare in
  /home/guido/text:

       $ chmod o-rwx /home/guido/text

  3.3.  Tradurre i comandi dal DOS a Linux

       DIR:            ls, find, du
       CD:             cd, pwd
       MD:             mkdir
       RD:             rmdir
       DELTREE:        rm -R
       MOVE:           mv

  - ESEMPI -

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

       C:\GUIDO>dir                            $ ls
       C:\GUIDO>dir file.txt                   $ ls file.txt
       C:\GUIDO>dir *.h *.c                    $ ls *.h *.c
       C:\GUIDO>dir/p                          $ ls | more
       C:\GUIDO>dir/a                          $ ls -l
       C:\GUIDO>dir *.tmp /s                   $ find / -name "*.tmp"
       C:\GUIDO>cd                             $ pwd
               n/a - vedi nota                 $ cd
               idem                            $ cd ~
               idem                            $ cd ~/temp
       C:\GUIDO>cd \other                      $ cd /other
       C:\GUIDO>cd ..\temp\trash               $ cd ../temp/trash
       C:\GUIDO>md newprogs                    $ mkdir newprogs
       C:\GUIDO>move prog ..                   $ mv prog ..
       C:\GUIDO>md \progs\turbo                $ mkdir /progs/turbo
       C:\GUIDO>deltree temp\trash             $ rm -R temp/trash
       C:\GUIDO>rd newprogs                    $ rmdir newprogs
       C:\GUIDO>rd \progs\turbo                $ rmdir /progs/turbo

  Note:

  1. quando usate rmdir, la directory da cancellare deve essere vuota.
     Per cancellare una directory e tutto il suo contenuto, usate rm -R
     (a vostro rischio e pericolo).

  2. il carattere '~'  una scorciatoia per il nome della home
     directory. I commandi cd o cd ~ portano nella home directory
     ovunque voi siate; il comando cd ~/tmp vi porta in
     /home/your_home/tmp.

  3. cd - ``annulla'' l'ultimo cd.

  4.  Floppy, hard disk, e cos via

  4.1.  Gestire i dispositivi

  Forse non ci avete mai pensato, ma il comando DOS FORMAT A: fa molte
  pi cose di quanto sembri. Infatti, quando date il comando FORMAT
  quello 1) formatta fisicamente il disco; 2) crea la directory A:
  (crea un filesystem); 3) rende il disco accessibile all'utente (= fa
  il cosiddetto ``mount'').

  Questi tre passaggi si fanno separatamente con Linux. Si possono usare
  floppy formattati da DOS, ma ci sono altri formati che di solito 
  meglio usare (il filesistem DOS non consente di usare i nomi lunghi
  per i file.)

  Ecco come si prepara un floppy (bisogna essere root):

    per formattare un floppy standard da 1.44: (A:):

       # fdformat /dev/fd0H1440

    per creare un filesystem:

       # mkfs -t ext2 -c /dev/fd0H1440

  oppure

       # mformat a:

  per creare un filesystem MS-DOS. Prima di usare il disco, bisogna
  ``montarlo''.

    per montare il floppy:

       # mount -t ext2 /dev/fd0 /mnt

  oppure

       # mount -t msdos /dev/fd0 /mnt

  Ora si pu accedere ai file del floppy. Quando si ha finito, prima di
  estrarre il floppy bisogna ``smontarlo''.

    per smontare il floppy:

       # umount /mnt

  Ora potete estrarre il disco. Ovviamente, eseguire fdformat e mkfs
  solo per floppy nuovi, non per quelli gi preparati. Se volete usare
  il floppy B:, basta sostituire fd1H1440 e fd1 al posto di fd0H1440 e
  fd0 negli esempi visti sopra.

  Tutto quello che facevate con A: o B: si fa ora usando /mnt.  Esempi:

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

       C:\GUIDO>dir a:                         $ ls /mnt
       C:\GUIDO>copy a:*.*                     $ cp /mnt/* /docs/temp
       C:\GUIDO>copy *.zip a:                  $ cp *.zip /mnt/zip
       C:\GUIDO>a:                             $ cd /mnt
       A:>_                                    /mnt/$ _

  Inutile dire che quanto visto per i floppy vale anche per altri
  dispositivi; per esempio, si possono montare un altro disco fisso o un
  lettore di CD-ROM.  Ecco come si monta il CD-ROM:

       # mount -t iso9660 /dev/cdrom /mnt

  Questa era la maniera ``ufficiale'' di montare i dischi, ma c' un
  trucchetto. Dover essere root per usare un floppy  una scocciatura,
  quindi per consentire ad ogni utente di accedervi si pu fare cos:

    come root, creare le directory /mnt/a, /mnt/a: e /mnt/cdrom

    aggiungere in /etc/fstab le linee seguenti:

  /dev/cdrom      /mnt/cdrom  iso9660 ro,user,noauto          0       0
  /dev/fd0        /mnt/a:     msdos   user,noauto             0       0
  /dev/fd0        /mnt/a      ext2    user,noauto             0       0

  Ora per montare un floppy DOS, uno in formato ext2 e un CD-ROM si fa
  semplicemente:

       $ mount /mnt/a:
       $ mount /mnt/a
       $ mount /mnt/cdrom

  /mnt/a, /mnt/a: e /mnt/cdrom sono accessibili da tutti. Mi sono
  accorto che per scrivere file su /mnt/a senza essere root, subito dopo
  aver formattato e scritto il filesistem sul floppy bisogna fare:

       # mount /mnt/a
       # chmod 777 /mnt/a
       # umount /mnt/a

  Ricordate che consentire a tutti di montare dischi in questo modo  un
  grosso problema di sicurezza, se la cosa vi pu interessare.

  4.2.  Fare il backup

  Ora che sapete come gestire i dispositivi, due righe per vedere come
  si fa il backup. Ci sono molti progammi per questo scopo, ma il minimo
  necessario che si pu fare per un backup multivolume su floppy 
  quanto segue (diventate root):

       # tar -M -cvf /dev/fd0H1440 /dir_to_backup

  Assicuratevi di avere un floppy formattato nel drive, e altri pronti a
  disposizione. Per fare il restore, inserite il primo floppy nel drive
  e immettete:

       # tar -M -xpvf /dev/fd0H1440

  5.  Configurare il sistema

  5.1.  File di inizializzazione

  Due file importanti sotto DOS sono AUTOEXEC.BAT e CONFIG.SYS, e
  vengono usati al momento del boot per inizializzare il sistema,
  settare le variabili d'ambiente come PATH e FILES, e magari lanciare
  un programma o batch file. Sotto Linux ci sono tanti file di
  inizializzazione, e con molti di questi  meglio non pasticciare
  finch non si sa esattamente cosa si sta facendo. Vi dir comunque
  quali sono i pi importanti:

       FILES                           NOTES

       /etc/inittab                    non toccare!
       /etc/rc.d/*                     idem

  Se tutto quello che vi serve  settare il PATH o qualche altra
  variabile, o se volete cambiare i messaggi di login o lanciare un
  programma subito dopo il login, date un'occhiata ai seguenti:

       FILES                           NOTES

       /etc/issue                      setta i messaggi pre-login
       /etc/motd                       setta i messaggi post-login
       /etc/profile                    setta PATH e altre variabili, etc.
       /etc/bashrc                     setta alias e funzioni globali (vedi sotto)
       /home/your_home/.bashrc         setta i vostri alias e funzioni
       /home/your_home/.bash_profile   setta il vostro environment, etc.
       /home/your_home/.profile        idem

  Se l'ultimo file esiste (notare che  un file nascosto), verr letto
  dopo il login e i suoi comandi vengono eseguiti.

  Esempio: date un occhio a questo .profile:

  ______________________________________________________________________
  # Io sono un commento
  echo Environment:
  printenv | less   # equivalente del comando SET sotto DOS
  alias d='ls -l'   # facile capire cos'e' un alias
  alias up='cd ..'
  echo "Ti ricordo che il path e' " $PATH
  echo "Oggi e' `date`"  # usa l'output del comando 'date'
  echo "Buongiorno " $LOGNAME
  # Questa e' una "funzione della shell":
  ctgz() # Lista i contenuti di un archivio .tar.gz.
  {
    for file in $*
    do
      gzip -dc ${file} | tar tf -
    done
  }
  # fine di .profile
  ______________________________________________________________________

  PATH e LOGNAME, avete indovinato, sono variabili d'ambiente. Ce ne
  sono molte altre con cui giochicchiare; LMP di programmi come less.

  5.2.  File di inizializzazione dei programmi

  Sotto Linux, praticamente tutto pu essere personalizzato. Molti
  programmi hanno uno o pi file di inizializzazione che potete
  modificare, spesso sotto forma di  .nome_del_programmarc nella vostra
  home. I primi che vorrete modificare sono:

  /usr/lib/X11/fvwm/system.fvwmrc

  programmi.

  Per tutti questi e gli altri che prima o poi incontrerete, LMP.

  6.  Un po' di programmazione

  6.1.  Shell script: super file .BAT

  Se usavate i file .BAT per creare diminutivi di lunghe linee di
  comando (io lo facevo spesso), questo si pu ottenere inserendo degli
  alias in profile o .profile. Ma se i vostri .BAT erano pi complessi,
  vi piacer il linguaggio di scripting della shell:  potente come il
  QBasic, se non di pi. Ha variabili, strutture come while, for, case,
  if... then... else, e molte altre caratteristiche: pu essere una
  buona alternativa ad un ``vero'' linguaggio di programmazione.

  Per scrivere un file script---l'equivalente di un .BAT file sotto
  DOS---non si fa altro che scrivere un file ASCII contenente le
  istruzioni, lo si salva e poi lo si rende eseguibile col comando
  chgmod +x <scriptfile>. Per eseguirlo si scrive il suo nome.

  Attenzione per. L'editor di sistema si chiama vi, e ho visto che
  molti nuovi utenti lo trovano molto difficile da usare. Non spiegher
  come usarlo perch non mi piace e non lo uso; consultate ``Linux
  installation...'' di Matt Welsh, a pag. 109. (Fareste meglio a
  procurarvi un altro editor come joe o emacs per X.) Basti dire che:

    per inserire del testo, premete 'i' e poi il testo;

    per uscire da vi senza salvare, premete ESC e poi :q!

    per salvare e uscire, premete ESC e poi :wq

  Scrivere script sotto bash  un argomento cos vasto che richiederebbe
  un libro per conto suo, e non dar spiegazioni ma solo un esempio
  piuttosto completo di shell script, dal quale potrete intuire le
  regole di base:

  ______________________________________________________________________

  #!/bin/sh
  # esempio.sh
  # Io sono un commento
  # non cambiate la prima linea, deve restare cosi' com'e'
  echo "Questa macchina e': `uname -a`" # usa l'output del comando
  echo "Il mio noem e' $0" # variabile interna
  echo "Mi hai dato i seguenti $# argomenti: " $*
  echo "Il primo argomento e': " $1
  echo -n "Come ti chiami? " ; read nome
  echo guarda la differenza: "ciao $nome" # meccanismo di quoting con "
  echo guarda la differenza: 'ciao $nome' # meccanismo di quoting con '
  DIRS=0 ; FILES=0
  for file in `ls .` ; do
    if [ -d ${file} ] ; then # se file  una directory
      DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1
    elif [ -f ${file} ] ; then
      FILES=`expr $FILES + 1`
    fi
    case ${file} in
      *.gif|*jpg) echo "${file}: file grafico" ;;
      *.txt|*.tex) echo "${file}: file di testo" ;;
      *.c|*.f|*.for) echo "${file}: file sorgente" ;;
      *) echo "${file}: file generico" ;;
    esac
  done
  echo "ci sono ${DIRS} directories e ${FILES} files"
  ls | grep "ZxY--!!!WKW"
  if [ $? != 0 ] ; then # exit code dell'ultimo comando
    echo "non ho trovato ZxY--!!!WKW"
  fi
  echo "basta cosi'... scrivi 'man bash' se vuoi altre informazioni."
  ______________________________________________________________________

  6.2.  Programmare in C

  Sotto Unix, il linguaggio di programmazione per eccellenza  il C, vi
  piaccia o no. Ci sono anche molti altri linguaggi a disposizione
  (FORTRAN, Pascal, Lisp, Basic, Perl, awk...).

  Dato per scontato che conosciate il C, ecco qui un paio di linee guida
  per quelli di voi che sono stati viziati dal Turbo C++ o analogo
  compilatore. Il compilatore C di Linux si chiama gcc e non ha tutte
  quelle cose che di solito accompagnano un compilatore per DOS: niente
  IDE, aiuto in linea, debugger integrato e cos via.  solo un
  compilatore a linea di comando, molto potente ed efficiente. Per
  compilare il classico hello.c si fa cos:

       $ gcc hello.c

  che produce di default un eseguibile chiamato a.out. Per dargli un
  nome diverso:

       $ gcc -o ciao hello.c

  Per linkare una libreria al programma, si aggiunge lo switch
  -l<libname>. Per esempio, per linkare la libreria matematica:

       $ gcc -o mathprog mathprog.c -lm

  (Lo switch -l<libname> fa linkare a gcc la libreria
  /usr/lib/lib<libname>.a; quindi -lm linka /usr/lib/libm.a).

  Finora, tutto bene. Ma se il vostro programma  composto da molti file
  sorgenti, vi servir l'utility make. Supponiamo che avete scritto un
  parser per espressioni: il sorgente si chiama parser.c e #include due
  file header, parser.h e xy.h. Volete usare le routine di parser.c in
  un programma, diciamo calc.c, che a sua volta #include parser.h. Che
  casino! Cosa bisogna fare per compilare calc.c?

  Dovrete scrivere un cosiddetto makefile, che insegna al compilatore
  quali sono le dipendenze tra sorgenti e files oggetto. Nel nostro
  caso:

  ______________________________________________________________________

  # Questo e' makefile, usato per compilare calc.c
  # Premere il tasto <TAB> dove indicato

  calc: calc.o parser.o
  <TAB>gcc -o calc calc.o parser.o -lm
  # calc dipende da due files oggetto: calc.o e parser.o

  calc.o: calc.c parser.h
  <TAB>gcc -c calc.c
  # calc.o dipende da due files sorgenti

  parser.o:  parser.c parser.h xy.h
  <TAB>gcc -c parser.c
  # parser.o dipende da tre files sorgenti

  # end of makefile.
  ______________________________________________________________________

  Salvate questo file come makefile e scrivete

       $ make

  per compilare il programma; in alternativa, salvatelo come calc.mak e
  scrivete

       $ make -f calc.mak

  Ovviamente, LMP.

  Potete ottenere aiuto sulle funzioni del C, che sono illustrate da
  pagine man, sezione 3; per esempio,

       $ man 3 printf

  Ci sono tantissime librerie disponibili; tra le prime che vorrete
  usare ci sono ncurses, per gestire effetti in modo testo, e svgalib,
  per fare grafica. Se vi sentite abbastanza coraggiosi da affrontare la
  programmazione sotto X, procuratevi XForms (
  bloch.phys.uwm.edu/pub/xforms) e/o MGUI (
  www.volftp.vol.it/IT/IT/ITALIANI/MORELLO/index.htm), due magnifiche
  librerie che rendono facile la programmazione sotto X. Inoltre, se non
  potete fare a meno di una IDE alla Borland, procuratevi xwpe da
  sunsite.unc.edu:/pub/Linux/apps/editors/.  probabile che vi piacer.

  7.  Il rimanente 1%

  7.1.  Memoria virtuale

  Sebbene Linux possa in teoria girare con soli 2 mega di RAM, pi ce
  n' e meglio . X Window System non gira se non si hanno almeno 8
  mega. Per creare altri 8 mega di memoria virtuale, scrivete (come
  root):

       # dd if=/dev/zero of=/swapfile bs=1024 count=8192
       # mkswap /swapfile 8192
       # sync
       # swapon /swapfile

  Aggiungete l'ultima linea in /etc/rc.d/rc.local per rendere il file di
  swap accessibile al boot successivo, o aggiungete questa linea in
  /etc/fstab:

       /swapfile   swap   swap   defaults

  7.2.  Usare tar & gzip

  Sotto Unix ci sono alcune applicazioni usatissime per archiviare e
  comprimere file. tar  usato per fare archivi--- come PKZIP ma non
  comprime, archivia soltanto. Per fare un nuovo archivio:

       $ tar -cvf <archive_name.tar> <file> [file...]

  Per estrarre files da un arhivio:

       $ tar -xpvf <archive_name.tar> [file...]

  Per listare il contenuto di un archivio:

       $ tar -tf <archive_name.tar> | less

  I file si comprimono con compress, che  obsoleto e non dovrebbe
  essere pi usato, o con gzip:

       $ compress <file>
       $ gzip <file>

  che crea un file file compresso con estensione .Z (compress) o .gz
  (gzip). Questi programmi comprimono solo un file alla volta. Per
  decomprimere, scrivete

       $ compress -d <file.Z>
       $ gzip -d <file.gz>

  LMP.

  Ci sono anche unarj, zip e unzip (PK??ZIP compatibile). I files con
  estensione .tar.gz o .tgz (archivi fatti con tar e compressi con gzip)
  sono comuni nel mondo Unix come i files .ZIP sotto DOS. Per listare i
  contenuti di un file .tar.gz:

       $ gzip -dc <file.tar.gz> | tar tf - | less

  7.3.  Installare le applicazioni

  Prima di tutto: installare nuove applicazioni  compito di root.
  Alcune applicazioni Linux sono distribuite come archivi .tar.gz o
  .tgz, fatti in modo da poter essere scompattati dalla directory / col
  seguente comando:

       # gzip -dc <file.tar.gz> | tar xvf -

  I file vengono decompressi nella directory giusta, che viene creata
  sul momento. Gli utenti della distribuzione Slackware hanno il
  programmino pkgtool; un altro  rpm, disponibile per tutte le
  distribuzioni grazie a Red Hat.

  Altri package non possono essere installati da /; tipicamente,
  l'archivio contiene una directory chiamata nome_programma/ e tanti
  files e/o sottodirectories sotto nome_programma/. Una regola  quella
  di installare questi programmi da /usr/local. Inoltre, altri programmi
  sono distribuiti come sorgenti in C o C++ che vanno compilati per fare
  gli eseguibili. In molti casi, basta dare make; ovviamente vi servir
  il compilatore gcc.

  7.4.  Trucchi indispensabili

  Command completion: premere <TAB> mentre si scrive un comando al
  prompt completa la linea di comando. Esempio: dovete scrivere gcc
  nome_file_molto_lungo.c; scrivento gcc nome<TAB>  sufficiente. (Se
  avete altri file che cominciano con gli stessi caratteri, scrivete
  altre lettere per risolvere l'ambiguit).

  Backscrolling: premendo SHIFT + PAG UP (tasto grigio) consente di fare
  lo scroll all'indietro dello schermo, a seconda di quanta memoria
  video avete;

  Resettare lo schermo: pu capitare di fare more o cat di un file
  binario, e come conseguenza lo schermo potrebbe riempirsi di
  schifezze.  Per rimettere a posto, battere alla cieca reset o questa
  sequenza di caratteri: echo CTRL-V ESC c RETURN;

  Incollare il testo: per la console, vedete sotto; in X, fate click e
  trascinate per selezionare il testo in una finestra xterm, poi premete
  il tasto di mezzo (o i due bottoni insieme se non avete tre tasti) per
  incollare il testo selezionato altrove. C' anche il programma
  xclipboard (purtroppo solo per il testo); non fatevi confondere dal
  suo lentissimo tempo di risposta;

  Usare il mouse: installate gpm, un mouse driver per la console.  Fate
  click e trascinate per selezionare il testo, poi fate click col tasto
  destro per incollare il testo selezionato. Funziona anche tra diverse
  VC.

  Messaggi dal kernel: date un occhio a /var/adm/messages o
  /var/log/messages come root per vedere i messaggi del kernel, compresi
  i messaggi in fase di boot.

  7.5.  Programmi e comandi utili

  Ovviamente, questa lista riflette i miei gusti e le mie necessit
  personali.  Prima di tutto, dove trovarli: sapete tutti come usare la
  rete, archie ed ftp, quindi vi dar solo gli indirizzi pi importanti
  che riguardano Linux: sunsite.unc.edu, tsx-11.mit.edu, e nic.funet.fi.
  Usate il vostro mirror pi vicino.

    at serve per eseguire comandi e programmi ad un'ora o data
     specifica;

    awk  un linguaggio di programmazione, semplice ma potente, per
     manipolare file di dati (e non solo). Per esempio, se avete un file
     di dati a pi campi chiamato data.dat,

       $ awk '$2 ~ "abc" {print $1, "\t", $4}' data.dat

  scrive i campi 1 e 4 di ogni linea in data.dat il cui secondo campo
  contiene ``abc''.

    delete-undelete fanno quello che il loro nome suggerisce;

    df d informazioni sui dischi montati;

    dosemu consente di far girare molte (anche se non tutte)
     applicazioni DOS, incluso Windows 3.x se ci smanettate un bel po';

    file <filename> dice che cos' filename (file ASCII, eseguibile,
     archivio, etc.);

    find (vedi anche Sezione ``Directories'')  uno dei comandi pi
     utili e potenti. Si usa per trovare file che rispondono a certi
     criteri ed eseguire azioni su si essi.  Uso generale di find:

       $ find <directory> <espressione>

  dove <espressione> include criteri di ricerca ed azioni da eseguire.
  Esempi:

       $ find . -type l -exec ls -l {} \;

  trova i file che sono link simbolici e mostra a cosa puntano.

       $ find / -name "*.old" -ok rm {} \;

  trova i files che corrispondono al pattern e li cancella, chiedendo
  prima il permesso di farlo.

       $ find . -perm +111

  trova i file i cui permessi corrispondono con 111 (eseguibile).

       $ find . -user root

  trova i files che appartengono a root. Ci sono molte altre possi
  bilit, LMP.

    gnuplot  un bel programma per il plotting scientifico;

    grep trova pattern in file di testo. Per esempio,

        $ grep -l "geology" *.tex

  lista tutti i files *.tex che contengono la parola ``geology''. La
  variante zgrep agisce su file gzippati. LMP;

    gzexe comprime files eseguibili mantenendoli eseguibili;

    joe  un buon editor. Lanciandolo come jstar si ottengono le stesse
     combinazioni di tasti di WordStar e dei suoi discendenti, compresi
     l'editor del DOS e quello dei linguaggi Borland;

    less  probabilmente il migliore visualizzatore di file di testo, e
     se configurato consente di visualizzare archivi gzip, tar e zip;

    lpr <file> stampa un file in background. Per controllare lo stato
     della coda di stampa, usate lpq; per cancellare un file dalla coda
     di stampa, usate lprm;

    mc  un bellissimo file manager;

    pine  un buon programma per la posta elettronica;

    script <script_file> copia su script_file tutto quello che appare
     sullo schermo fino a quando non date il comando exit.  Utile per il
     debugging;

    sudo permette di eseguire alcuni dei compiti solitamente concessi
     solo a root (es. formattare e montare dischi; LMP);

    uname -a d informazioni sul sistema;

    zcat e zless sono utili per visualizzare file gzippati senza
     decomprimerli. Per esempio:

       $ zless textfile.gz
       $ zcat textfile.gz | lpr

    I seguenti comandi risultano spesso utili: bc, cal, chsh, cmp, cut,
     fmt, head, hexdump, nl, passwd, printf, sort, split, strings, tac,
     tail, tee, touch, uniq, w, wall, wc, whereis, write, xargs, znew.
     LMP.

  7.6.  Estensioni di file e programmi collegati

  Potrete incontrare tantissime estensioni di file. A parte le pi
  esotiche (ad es. fonts, etc.), ecco una lista:

  

    file.

    visualizzare; dvips per convertire in un file .ps (postscript)

  

  

    Procuratevi info.

  

    contenente la descrizione di un package.

    e, opzionalmente, ghostview.

    gzip.

    impaginazione. Procurarsi tex, disponibile in molte distribuzioni;
     attenti alla distribuzione NTeX, che ha dei font corrotti ed 
     parte di Slackware fino alla versione 96.

  

  

  

    unzip.

  8.  La fine, per ora

  Congratulazioni! Ora avete un po' di conoscenza di Unix e siete pronti
  per iniziare a lavorare. Ricordate che la vostra conoscenza del
  sistema  ancora limitata, e che dovreste fare pratica per usare Linux
  senza problemi. Ma se tutto quello che dovete fare  prendere un po'
  di programmi e darci sotto, sono sicuro che quanto ho incluso 
  sufficiente.

  Sono certo che usare Linux vi piacer e continuerete ad imparare cose
  nuove---lo fanno tutti. Scommetto, inoltre, che non ritornerete al
  DOS!  Spero di essere stato chiaro e di aver reso un buon servizio ai
  miei 3 o 4 lettori.

  8.1.  Copyright

  Unless otherwise stated, Linux HOWTO documents are copyrighted by
  their respective authors. Linux HOWTO documents may be reproduced and
  distributed in whole or in part, in any medium physical or electronic,
  as long as this copyright notice is retained on all copies. Commercial
  redistribution is allowed and encouraged; however, the author would
  like to be notified of any such distributions.

  All translations, derivative works, or aggregate works incorporating
  any Linux HOWTO documents must be covered under this copyright notice.
  That is, you may not produce a derivative work from a HOWTO and impose
  additional restrictions on its distribution. Exceptions to these rules
  may be granted under certain conditions; please contact the Linux
  HOWTO coordinator at the address given below.

  In short, we wish to promote dissemination of this information through
  as many channels as possible. However, we do wish to retain copyright
  on the HOWTO documents, and would like to be notified of any plans to
  redistribute the HOWTOs.

  If you have questions, please contact Greg Hankins, the Linux HOWTO
  coordinator, at gregh@sunsite.unc.edu via email.

  8.2.  Disclaimer

  ``Dal DOS a Linux HOWTO''  stato scritto da Guido Gonzato,
  guido@ibogfs.df.unibo.it. Ringraziamenti vanno a Matt Welsh, autore di
  ``Linux Installation e Getting Started'', a Ian Jackson, autore di
  ``Linux frequently asked questions with answers'', a Giuseppe Zanetti,
  autore di ``Linux'', a tutti quelli che mi hanno mandato mail di
  suggerimenti, e specialmente a Linus Torvalds e GNU che ci hanno dato
  Linux.

  Questo documento viene fornito ``as is''. Mi sono sforzato di
  scriverlo con la massima accuratezza, ma usate le informazioni qui
  contenute a vostro rischio. Non sar responsabile in alcun caso di
  danni provocati da questo documento.

  Ogni forma di feedback  benvenuta. Per richieste, suggerimenti,
  flames etc.  contattatemi pure.

  Divertitevi con Linux e godetevi la vita,

  Guido   =8-)

