## page was renamed from OroroMunroe/Prove
#format wiki
#LANGUAGE it
<<BR>>
<<Indice>>
In questa pagina c'è un ''prontuario'' dei comandi più comuni.
Tutti i comandi sono nella stessa pagina, quindi si può usare una funzione di ricerca del browser, oppure i link qui a fianco.
Poi se necessario usare l' ''help''.<<BR>>
Per i principianti: indico con * i comandi che è opportuno imparare subito.
Indico con b i comandi builtin (mi riferisco alla shell `bash`).
Questo file deriva, alla lontana, da una lista di comandi di FreeBSD: [[http://www.freebsd.org/doc/it_IT.ISO8859-15/books/unix-introduction/command-summary.html]].
= Link esterni =
Rimando anche al sito [[http://www.coresis.com/extra/linuxcorsobase/programma.htm|www.coresis.com]], c'è un bel corso introduttivo a Linux,
e a AmministrazioneSistema/ComandiBase dove sono descritti più in dettaglio i comandi di base.
Per i principianti di Ubuntu c'è un topic qui [[http://forum.ubuntu-it.org/viewtopic.php?t=57229]].
[[http://www.manualinux.com/|Qui]] sta il manualinux.
Un'altra lista di comandi è su [[http://www.perpetualpc.net/srtd_commands_rev.html|www.perpetualpc.net]].
= Lista comandi =
== Sistema ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> ||'''Cosa fa'''||
||`alias` ''newname''= "stringa" ||b||Crea un nuovo comando, che però esiste soltanto in memoria volatile. D'altra parte è più veloce di uno script.||
||`bg %` ''job-number''||b||esegue in background un processo della lista dei job. Ossia, tale processo non blocca la shell. Si veda anche `jobs`.||
||`chsh (passwd -e/-s) `''username<<BR>>login_shell''|| ||cambia la shell di login dell'utente (spesso solamente attraverso il super-user)||
||`command `''comando''||b||Esegue il comando ''comando'', ignorando tutti i possibili ''alias'' che sono stati definiti. Confronta `builtin`.||
||`date [`''opzioni''`]`|| ||riporta data e ora corrente||
||`disown `''%job''||b||elimina un certo ''%job'' dalla lista dei job, ma senza chiuderlo. Confronta `kill`.||
||`echo [`''stringa di testo''`]`||b||riporta la stringa di testo specificata in standard output||
||`eject [-t]`|| ||espelle / richiude il vassoio CD||
||`exit`||b||chiude la shell||
||`fg %`''job-number''||b||esegue in foreground un processo interrotto. Ossia, la shell è bloccata finchè il processo non termina. Si veda anche `jobs`.||
||`free`|| ||Visualizza quanta memoria (RAM e swap) è attualmente usata e quanta è libera. Confronta invece `df, du`||
||`grub-install --root-directory=`''floppy-già-montato''` `''device''<<BR>>`grub-install --root-directory=/media/floppy fd0`|| ||Installa GRUB su floppy (disco d'avvio). Poi sarà necessario copiare anche il `menu.lst` su `/media/floppy/boot/grub`.||
||`help `''comando''||b||visualizza una breve schermata d'aiuto, per le funzioni built-in. Confrontare `man` e `info`.||
||`hostname`|| ||visualizza o setta (solamente super-user) il nome della macchina attuale||
||`jobs`||b||Elenca i ''jobs'' attuali, ossia i programmi che sono stati ''sospesi'' durante la sessione (tipicamente sono stati sospesi usando CTRL+Z) ma anche quelli che sono stati lanciati con &. Si veda anche `kill`.||
||`kill [`''opzioni''`] [-`''SEGNALE''`] [`''pid''`|%`''job''`]`||b||manda un segnale al processo specificato dall'identificatore di processo (''pid'') o dall'identificatore di job (%''job''). Il segnale di default è SEGKILL, che termina il processo. NB. il processo deve essere attivo: se è stato bloccato e.g. con CTRL+Z, bisogna poi riattivarlo con `fg`, e solo allora riceverà il segnale. Confronta `disown`.||
||`lpq [`''opzioni''`]`|| ||<|2(>visualizza lo stato dei job di stampa||
||`lpstat [`''opzioni''`]`|| ||
||`lpr [`''opzioni''`] `''file''|| ||<|2(>stampa sulla stampante specificata||
||`lp [`''opzioni''`] `''file''|| ||
||`lprm [`''opzioni''`]`|| ||<|2(>rimuove un job di stampa dalla coda di stampa||
||`cancel [`''opzioni''`]`|| ||
||`ps [`''opzioni''`]`|| ||Visualizza lo stato e il ''pid'' dei processi attivi, aperti dalla finestra attuale. Usare l'opzione `-adef` o `-ax` per avere tutti i processi e più dettagli. Confronta `top`.||
||`pushd `''newdir'' || ||<|3(>Per cambiare directory salvando la precendente in uno stack usare `pushd`. `popd` recupera la prima dello stack, `dirs` mostra il contenuto dello stack.||
||`popd`|| ||
||`dirs`|| ||
||`pstree`|| ||visualizza tutti i processi attivi con un diagramma ad albero. I processi dovrebbero generarsi tutti da `init`.||
||`pwd`||b*||visualizza la directory di lavoro (corrente)||
||`reboot`|| ||<|4(>Riavvia / Spegne il sistema. Confronta `shutdown`.||
||`halt`|| ||
||`poweroff` || ||
||`init 6`|| ||
||`script `''file'' || ||memorizza ogni cosa che appare sullo schermo in un file fino a quando si esegue `exit`||
||`set`<<BR>>`set `''varname''`=`''content''<<BR>>`PATH=/usr/lib:$PATH`|| ||visualizza/setta le variabili d'ambiente||
||`shutdown -r` ''time''<<BR>>`shutdown -h` ''time''|| ||Riavvia / spegne il sistema dopo un tempo presfissato. ''time'' può essere: numero minuti, oppure `hh:mm`, oppure `now`. Se non specifichi `-r / -h` fa casino... (arresta, ma non spegne né riavvia)||
||`source `''file''||b||<|3(>legge i comandi dal file specificato e li esegue nella shell corrente. `source` per la shell C, `.` per la shell Bourne. Usare solo il punto significa che lo script è "incluso" anzichè "richiamato".||
||`./`''file''||*||
||`. `''file''||
||`stty [`''opzioni''`]` || ||setta o visualizza le opzioni del terminale di controllo||
||`suspend` ||b||blocca la shell fino alla ricezione di un segnale `SIGCONT`.||
||`unset `''varname'' ||b||Elimina la variabile d'ambiente ''varname''.||
||`unalias `''aliasname'' ||b||Elimina ''aliasname'' dalla lista degli alias.||
||`uname`<<BR>>`uname -a` || ||Ottiene il nome del sistema operativo, la versione del kernel e altro.||
||`wait `''job-or-pid'' ||b ||Aspetta la terminazione del ''job'' o del processo ''PID'' indicato.||
||`which `''comando'' || ||riporta il percorso del comando o l'alias di shell in uso||
||`X`|| ||(da console) avvia il server X||
<<BR>>
== Pipeline, Redirezionamenti e simili ==
Potrebbero essere messi tra i comandi di sistema, oppure tra i comandi per la gestione dei files di testo.
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> ||'''Cosa fa'''||
||''comando''` > `''filename''|| || Redireziona l'output di ''comando'' verso il ''filename''. Il file viene cancellato e sostituito dal nuovo testo.||
||''comando''` >> `''filename''|| || Redireziona l'output di ''comando'' verso il ''filename''. Il testo viene ''appeso'' in coda al file.||
||''comando''` < `''filename''|| || Usa il ''filename'' come input di ''comando''||
||''comando''` < `''filename-in''` > `''filename-out''<<BR>>''comando''` < `''filename-in''` >> `''filename-out''|| || Combinazione delle precedenti.||
||''comando1''` | `''comando2''|| || Pipeline. L'output di ''comando2'' verrà usato come input di ''comando1''. I due programi sono avviati in parallelo.||
||''comando1''` && `''comando2''|| || Esegue i due comandi uno dopo l'altro.||
||''comando''` & `|| || Esegue il ''comando'' in background. È come usare `bg`.||
<<BR>>
== Accounts ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`adduser `''opzioni''|| ||crea un nuovo utente, o un nuovo gruppo (di utenti), o aggiunge un utente ad un gruppo esistente.||
||`addgroup `''group'' || ||crea un nuovo gruppo (di utenti). Per modificare i gruppi non ho trovato comandi, ma si può modificare direttamente i file `/etc/group`||
||`chgrp [`''opzioni''`] `''gruppo file'' || ||cambia il gruppo di appartenenza di un file||
||`chmod `''permessi''` `''file''<<BR>>`chmod a+rw `''file''<<BR>>`chmod +x `''script''<<BR>> `chmod 755 /` || ||cambia i permessi di accesso a file o directory. Confronta `chown`.<<BR>> I permessi possono essere specificati con `a/u/g/o` (all/user/group/others) seguito da `+/-` seguito da `r/w/x` (read/write/execute). Se si vogliono settare ''tutti'' i possibili permessi, conviene specificarli come triple ottali di numeri per user, group, others:<<BR>> 4 -> r<<BR>> 2 -> w<<BR>> 1 -> x<<BR>> esempio: `chmod 741 `''file''<<BR>> corrisponde a: `chmod u+rwx,g+r-wx,o+x-wr`<<BR>> dà al proprietario di ''file'' il permesso di lettura, scrittura e esecuzione, al gruppo solo di lettura e agli altri solo di esecuzione (paradossale lo so è un esempio...).<<BR>> (`-r` per cambiare i permessi ricorsivamente di tutte le sottodirectory)||
||`chown [`''opzioni''`] `''proprietario ''`[:`''gruppo''`]`'' file''<<BR>>`chown -r `''utente''`:`''utente''` /home/`''utente''|| ||cambia il proprietario di un file (`-r` per cambiare i permessi ricorsivamente di tutte le sottodirectory)||
||`groupadd `''gruppo''|| ||Analogo ad `addgroup`, ma è di più basso livello. Di preferenza usare l'altro (almeno in Debian).||
||`id`|| ||visualizza i dati dell'utente attualmente loggato||
||`login`|| ||<|2(>comandi tradizionali per il login/logout; ma sono inutili, servono solamente da console (cosiddetta ''login shell''). Confronta `exit`||
||`logout`||b||
||`last`|| ||dice chi si è loggato, quando e da dove (utile su server).||
||`passwd [`''opzioni''`]`||*||setta o modifica la propria password||
||`su [`''nomeutente''`]`||*||Login del super-user. MA in Kubuntu tale super-user potrebbe anche non esistere (è il mio caso),quindi ignorare questo comando.||
||`sudo [-u `''nomeutente''`] `''comando''||*||Comando eseguito in modalità super-user. Verrà richiesta la password. Vedere `kdesudo`.||
||`sudo [-u `''nomeutente''`] -i`||*||Passa alla modalità super-user.||
||`ulimit [`''opzioni''`]`||b||Visualizza/modifica i limiti di utilizzo di alcune risorse del sistema da parte dell'utente. (A rigore, sono i limiti ''della shell'').||
||`useradd `''opzioni''|| ||Analogo ad `adduser`, ma è di più basso livello. Di preferenza usare l'altro (almeno in Debian).||
||`who` o `w`|| ||riporta chi è “loggato” e quali processi ha in esecuzione||
||`whoami`|| ||visualizza il nome dell'utente attuale||
<<BR>>
== Gestione dei Filesystem ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`df`|| ||riporta il sommario dei blocchi del disco e degli ''inode'' liberi e usati. Confronta invece `free,du`.||
||`du [`''directory''` o `''file''`]`|| ||Riassume l'uso del disco di ogni file, ricorsivamente per le directory. Confronta invece `free,df`.||
||`fsck [`''opzioni''`] `''device''<<BR>>`fsck.ext2 [`''opzioni''`] `''device''<<BR>>...|| ||File system Check: verifica l'integrità, ripara il filesystem||
||`fdisk -l`<<BR>>`fdisk [`''opzioni''`] `''device''|| ||Visualizza / modifica la tabella delle partizioni di un'unità disco. (occorre essere super-user anche solo per visualizzare).||
||`fdformat [`''opzioni''`] `''device'' || ||Formattazione "a basso livello" (???) in generaele quello che serve è `mkfs`.||
||`mkfs `''device''<<BR>>`mkfs.ext2 `''device''<<BR>>...||*||Make file system: formatta un disco||
||`mount [-t `''filesystem''`] `''something somewhere''<<BR>>`sudo mount -t ext2 /dev/fd0 /media/floppy` ||*||Monta una periferica. ''somewhere'' sarà il suo nuovo indirizzo (da usare come ''device'')... deve essere una cartella già esistente!!! Per smontare vedere `umount`||
||`sync || ||Sincronizza un filesystem con la sua cache, ossia scrive su disco gli eventuali dati "in attesa".||
||`umount `''device''||*||Smonta una periferica. `Confronta mount.`||
||`vol_id -u `''nome_device''<<BR>>`vol_id -u /dev/sda1`|| ||Ottiene info (in particolare l'UUID) sulla device||
<<BR>>
== Gestione files ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`cd [`''directory''`]`||b*||cambia directory||
||`cmp [`''opzioni''`] `''file1 file2''|| ||confronta due file e visualizza dove avvengono le differenze (file di testo e file binari). Confronta `diff`.||
||`cp [`''opzioni''`] `''file1 file2''||*||copia ''file1'' in ''file2''. Questo comando crea o sovrascrive ''file2''.||
||`dd [if=`''infile''`] [of=`''outfile''`] [operando=`''valore''`]`|| ||copia un file, converte tra ASCII e EBCDIC o scambia l'ordine di byte, come specificato ||
||`file [`''opzioni''`] `''filename''|| ||classifica il tipo di file||
||`find `''directory''` [`''opzioni''`] [`''azioni''`]`<<BR>>`find / -xdev -iname "`''filename.ext''"<<BR>>`find . -name '*.tmp' -exec rm {} \;`<<BR>>`sudo grep -lir ``'`''testo''`'` ||*||cerca file basandosi sul tipo o su uno schema. Può anche effettuare una prefissata operazione su tutti i files trovati. Per visualizzare file contenenti un certo testo invece usare `grep`.||
||`locate `''filename-pattern''||*||cerca file basandosi sul ''filename-pattern''. A differenza di `find`, cerca i files solamente all'interno di un suo database, che deve essere aggiornato con `updatedb`.||
||`ln `''sorgente destinazione'' <<BR>>`ln -s `''sorgente destinazione''|| || Crea un hard-link di nome ''destinazione'' a ''sorgente''. '''Non è''' un nuovo file! La struttura della directory UNIX non è ad albero, ma piuttosto a grafo aciclico, quindi lo stesso file può essere raggiunto da più cartelle. Si pu&ogtrave; linkare soltanto un file, e sullo stesso volume.<<BR>> Invece con l'opzione `-s` crea un sotf-link di nome ''destinazione'' a ''sorgente''. Ossia, un nuovo file che punta all'altro.||
||`ls [`''opzioni''`] [`''directory''` o `''file''`]` ||*||elenca il contenuto della directory specificata o i permessi del file specificato (`-l` visualizza i dettagli; `-r` le sottodirectory)||
||`mkdir [`''opzioni''`] `''directory''||*||crea una directory||
||`mv [`''opzioni''`] `''file1 file2''||*||muove ''file1'' in ''file2''. Il file è semplicemente rinominato.||
||`pwd`||b*||stampa la directory di lavoro (corrente)||
||`rm [`''opzioni''`] `''file''<<BR>>`rm -r `''file''||*||rimuove (elimina) un file o una directory '''senza chiedere conferma''' (`-r` elimina ricorsivamente la directory ed il suo contenuto) (`-1` chiede conferma prima di eliminare i file)||
||`rmdir [`''opzioni''`] `''directory''||*||rimuove una directory '''vuota'''||
||`touch [`''opzioni''`] [`''data/ora''`] `''file''|| ||"tocca" un file senza modificarlo, ossia aggiorna l'ora di ultima modifica. Se il file non esiste, di default lo crea.||
||`tree [`''directory''`] || ||visualizza il contenuto di una directory e delle sotto-directory||
||`sudo updatedb`||*||aggiorna il database per la ricerca di files (cfr. `locate`).||
||`uudecode [`''file''`]`|| ||decodifica un file codificato con `uuencode`, riportandolo al file originale||
||`uuencode [`''file''`] `''nuovo_nome''|| ||codifica un file binario in codice ASCII 7-bit; utile quando lo si trasmette via email, per essere poi decodificato come ''nuovo_nome'' alla destinazione||
||`whatis [`''opzioni''`] `''filename''|| ||dice (se riesce) che tipo di oggetto è filename. Per i comandi ne dà la descrizione.||
||`whereis [`''opzioni''`] `''comando''||* ||riporta le locazioni del binario, del sorgente e della pagina `man` per il comando specificato||
<<BR>>
== Archivi ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`bzip2 [`''opzioni''`] `''files'' ||<|2(>||<|2(>comprime / decomprime un archivio `.bz2`||
||`bunzip2 `''file.bz2'' ||
||`bzcat `''file.bz2'' || ||concatena (lista) il file decompresso a video, lasciando il file compresso su disco||
||`compress [`''opzioni''`] `''file'' ||<|2(> ||<|2(>comprime / decomprime un archivio `.Z` (che contiene un singolo file).||
||`uncompress `''file.Z'' ||
||`gzip [`''opzioni''`] `''file'' ||<|2(>*||<|2(>comprime / decomprime un archivio `.gz` (che contiene un singolo file)||
||`gunzip [`''opzioni''`] `''file'' ||
||`zcat` ''file.Z'' || ||concatena (lista) il file decompresso a video, lasciando il file compresso su disco||
||`tar [`''opzioni''`] [`''files''`]`<<BR>>`tar -xvf `''nomearchivio''`.tar`<<BR>>`tar -cvf `''nomearchivio''`.tar` ''files''<<BR>>`tar -zxvf` ''nomearchivio''`.tgz`<<BR>>`tar -zcvf `''nomearchivio''`.tgz` ''files'' ||*||De/comprime archivi `.tar` ("archivio a nastro", non compresso)<<BR>> Estrae un archivio<<BR>> Crea un nuovo archivio<<BR>> Estrae un archivio compresso `.tar.gz` (o `.tgz`).<<BR>> Crea un nuovo archivio compresso `.tar.gz` (o `.tgz`).||
||`zip `[options] ''filename''||<|2(> ||<|2(>Comprime / decomprime archivi `.zip`.||
||`unzip `''filename''||
<<BR>>
== Files testuali ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`awk/nawk [`''opzioni''`] `''file''|| ||esamina schemi in un file e processa i risultati||
||`cat [`''opzioni''`] `''file''|| ||concatena (lista) un file||
||`cut (`''opzioni''`) [`''file''`]`|| ||taglia specifici campi/caratteri dalle linee del file specificato||
||`diff [`''opzioni''`] `''file1 file2''|| ||confronta i due file e visualizza le differenze (solamente file di testo). Confronta `cmp`.||
||`ed [`''opzioni''`] `''file''|| ||editor a linea di comando. Confronta `vi`.||
||`grep [`''opzioni''`] '`''stringa''`' `''argomento''<<BR>>''comando''` | grep [`''opzioni''`] '`''stringa''`'`||<|3(> ||<|3(> ricerca nell'argomento (in questo caso probabilmente un file) tutte le occorrenze della `'`''stringa''`'` specificata e visualizza le righe in cui compare. Con il pipeline, prende come input l'output del ''comando''.||
||`egrep [`''opzioni''`] '`''stringa''`' `''argomento''||
||`fgrep [`''opzioni''`] '`''stringa''`' `''argomento''||
||`head [-`''numero''`] `''file''|| ||visualizza le prime 10 (o ''numero'') linee di un file||
||`md5sum `''file''<<BR>>`md5sum `''file''` && echo `''md5atteso''|| ||restituisce una certa funzione hash di un dato file. Utile per verificarne l'integrità.||
||`more `''file''||* ||<|3(>impaginatore di un file testuale||
||`less `''file''|| ||
||`pg `''file''|| ||
||`patch [`''options''`] [`''originalfile'' `[`''patchfile''`]]`<<BR>>`patch -p`''num'' `<`''patchfile'' || ||Applica una patch a ''originalfile''||
||`paste [`''opzioni''`] `''file''|| ||incolla campi nelle linee del file specificato||
||`pr [`''opzioni''`] `''file''|| ||filtra il file e lo stampa su un terminale||
||`sed [`''opzioni''`] `''file''|| ||editor di flusso per editare file da uno script o da linea di comando||
||`sort [`''opzioni''`] `''file''|| ||ordina le linee del file specificato basandosi sulle opzioni scelte||
||`strings [`''opzioni''`] `''file''|| ||riporta sequenze di 4 o più caratteri stampabili terminanti in <NL> o <NULL>. Generalmente viene usato per ricercare in file binari stringhe ASCII||
||`tail [-`''numero''`] `''file''|| ||visualizza le ultime 10 (o ''numero'') linee di un file||
||`tee [`''opzioni''`] `''file''|| ||copia standard output in uno o più file||
||`tr [`''opzioni''`] `''stringa1 stringa2'' || ||traduce i caratteri di ''stringa1'' provenienti da standard input in quelli di ''stringa2'' per standard output||
||`uniq [`''opzioni''`] `''file''|| ||rimuove le linee ripetute in un file||
||`wc [`''opzioni''`] [`''file''`]`|| ||visualizza il numero di parole (o di caratteri o di linee) del file specificato||
<<BR>>
== Gestione pacchetti ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`rpm [`''opzioni''`]`<<BR>>`rpm -i `''file''<<BR>>`rpm -a|grep `''name''|| ||Gestione pacchetti `.rpm`. Non funziona in ambiente Debian! usare `alien`.<<BR>> Installa un `.rpm` già scaricato.<<BR>> Cerca i pacchetti installati con un certo nome.` <<BR>>||
||`alien `''file''|| ||Converte pacchetti `.rpm` in `.deb`.||
||`apt-get [`''opzioni''`]`<<BR>> `apt-get install `''package-name''<<BR>> `apt-get remove `''package-name''<<BR>> `apt-get purge `''package-name''<<BR>> `apt-get upgrade [`''package-name''`]`<<BR>> `apt-get autoclean`<<BR>> `apt-get autoremove` ||*||Gestione pacchetti `.deb`. Analogo della versione grafica Adept.<<BR>> Installa<<BR>> Rimuove ''ma'' non cancella i file di configurazione<<BR>> Rimuove<<BR>> Aggiorna<<BR>> Cancella file `.deb` temporanei.<<BR>> Rimuove pachetti installati automaticamente e non più necessari||
||`dpkg -i `''file''|| ||Installa un pacchetto `.deb||
||`dpkg -l|grep `''name''|| ||Cerca i pacchetti installati con un dato nome`||
||`dpkg --force-help`|| ||Lista delle opzioni di forzatura ... da usare con cautela...||
||`gdebi `''file''|| ||Installa un pacchetto `.deb`... richiamando `dpkg`...||
||`./configure`<<BR>>`make`<<BR>> `sudo make install`<<BR>> `make clean`|| ||Tipica sequenza per installare un pacchetto dal codice sorgente. Ma in Debian è preferibile la prossima.||
||`./configure`<<BR>> `make`<<BR>> `sudo checkinstall`<<BR>> `make clean `|| ||Sequenza per compilare e installare un pacchetto dal codice sogente in Debian.||
<<BR>>
== Rete ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`ifconfig [`''opzioni''`] || ||visualizza/setta impostazioni delle schede di rete||
||`finger [`''opzioni''`] `''user''` [`''@nomehost''`]`|| ||riporta informazioni circa gli utenti di macchine locali e remote||
||`ftp [`''opzioni''`] `''host''|| ||trasferisce file utilizzando il protocollo di trasferimento di file (FTP)||
||`ping `''nomehost''|| ||verifica la connettività verso un certo indirizzo||
||`rcp [`''opzioni''`] `''nomehost''|| ||copia file in remoto dalla macchina corrente in un'altra macchina||
||`rlogin [`''opzioni''`] `''nomehost''|| ||effettua il login in remoto su un'altra macchina||
||`route [`''opzioni''`]|| ||Visualizza / modifica la tabella degli indirizzi IP per raggiungere il gateway. Tra l'altro, mostra l'indirizzo del gateway.||
||`rsh [`''opzioni''`] `''nomehost''|| ||shell remota da eseguire su un'altra macchina||
||`telnet [`''host''` [`''porta''`]]`|| ||comunica con un altro host usando il protocollo telnet||
||`wget -r -l `''numero_livelli'' ''URL''|| ||scarica un intero sito (in realtà ci sono molte altre opzioni)||
<<BR>>
== Alcune (vecchie) applicazioni testuali ==
L'unica interessante è il manuale, e magari `od`.
||<tablestyle="border:2" :35%>'''Comando/Sintassi'''||<2%> || '''Cosa fa'''||
||`emacs [`''opzioni''`] `''file''|| ||editor testuale||
||`ex` ''file'' || ||editor testuale, tipo `vi`. Confronta anche `ed`.||
||`info `''comando''|| ||visualizza la pagina di info (che è tipo un manuale...) del comando specificato. Confronta `man` e `help`.||
||`mail [`''opzioni''`] [`''user''`]` ||<|3(> ||<|3(> semplice utility per la posta elettronica disponibile su un sistema Unix. Si digita un punto come primo carattere su una nuova linea per trasmettere il messaggio, un punto interrogativo per richiamare l'help||
||`mailx [`''opzioni''`] [`''user''`]`||
||`Mail [`''opzioni''`] [`''user''`]`||
||`man [`''opzioni''`] `''comando''|| ||visualizza la pagina di manuale del comando specificato||
||`od [`''opzioni''`] `''file'' ||<|2(> ||<|2(>dump su un file binario, in ottale, in ASCII, in esadecimale, in decimale o in modalità carattere.||
||`od -txz -Ax `''file''||
||`top` || ||versione sofisticata di `ps`||
||`vi` ''file'' || ||editor testuale. Leggere bene il manuale, esempio [[http://www.science.unitn.it/~fiorella/guidavi/guidavi.html|qui]]||
||`editor `''file''|| ||editor testuale più intuitivo||
<<BR>>
== Alcune applicazioni KDE (GUI): ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi''' || '''Cosa fa'''||
||`adept_manager`||per dis/installare pacchetti (almeno in Kubuntu). È più completo di `adept_installer`.||
||`adept_installer`||per dis/installare applicazioni (almeno in Kubuntu)||
||`amarok`||per ascoltare musica||
||`kaffeine`||lettore CD/DVD||
||`konqueror`||navigazione files; navigazione web; apre i documenti più comuni.||
||`kwrite, kate `''filename''||editor di testo||
||`kdesudo `''applicazione''||Alternativa grafica a `sudo`. È consigliato quando si devono lanciare applicazioni grafiche.||
||`kmail`||client email (fa parte del pacchetto `kontact`)||
||`kontact`||In un unico applicativo sono racchiusi: client email (`kmail`), calendario e agenda (`korganizer`), rubrica (`kaddressbook`), notes (`knote`), ...||
||`kwalletmanager`||Gestore del Portafogli KDE (appare nel vassoio di sistema). Il portafogli conserva le password.||
||`karm`||Demone per far partire un programma ad un istante prefissato.||
||`k3b`||masterizzazione CD (molto completo)||
||`kfind`||Cerca files su disco. NON MI FUNZIONA! probabilmente è come `find` ma non supporta -xdev||
||`kghostwiew, kpdf`||Lettori `.ps`, `.eps`, `.pdf`||
||`kdvi`||Lettore `.dvi`||
||`kile, TexMaker`||Interfacce La/Tex. (MA il compilatore latex come si chiama? TeTex? o TexLive?)||
||`gucharmap, kcharselect`||Tabella dei caratteri.||
== Altre applicazioni GUI: ==
||<tablestyle="border:2" :35%>'''Comando/Sintassi''' || '''Cosa fa'''||
||`oowriter`||<|5(> OpenOffice||
||`oomath`||
||`oocalc`||
||`ooimpress`||
||`oodraw`||
||`acroread`||Adobe Reader (ex Acrobat Reader)||
<<BR>>
== Alcuni files di configurazione ==
||<tablestyle="border:2" :35%>'''File''' || '''Descrizione'''||
||`/boot/grub/menu.lst`||Menu' del bootloader||
||`/home/username/.bashrc`||Eseguito all'ingresso in una ''non-login shell'' di `bash`||
||`/home/username/.bash_logout`||Eseguito all'uscita della ''login shell'' di `bash`||
||`/etc/issue`||Conserva nome e versione della distribuzione Linux||
||`/etc/fstab`||Static filesystem information: ''dovrebbe'' dire quali dischi montare all'avvio||
||`/home/username/.kde/Autostart/`||Cartella che contiene file di configurazione del desktop eseguiti automaticamente all'avvio||
||`/etc/init.d`||Avvio dei processi di Linux, richiamati subito dopo `init`. Fra questi, kdm....||
||`/etc/rc*.d`||Avvio dei processi di Linux, divisi per errorlevel. Richiamati subito dopo `init`. Fra questi, kdm....||
||`/etc/X11/xorg.conf`||File di configurazione del server X (almeno nelle vecchie versioni...)||
||`/etc/group`||File che conserva le associazioni numeri gruppi / gruppi / utenti / numeri utenti||
<<BR>>
== Script di Shell (bash) ==
||<tablestyle="border:2" :35%>'''Comando / Struttura''' ||<2%>|| '''Descrizione'''||
||`#!/bin/sh`<<BR>>`echo "Numero parametri = "`$#<<BR>>`echo "Nome del Programma = "`$0<<BR>> `echo "Parametri introdotti = "`$*|| ||Esempio di script.||
||#!`/bin/bash `|| ||Prima riga di una script (si specifica la shell che deve essere richiamata)||
||$|| ||Se `pippo` è il nome di una variabile, il suo valore è restituito usando `$pippo`.||
||#<<BR>> ?<<BR>> 0<<BR>> *<<BR>> !<<BR>> - || ||Le variabili di shell sono composte di un singolo carattere. Ne seguono alcune.<<BR>> # memorizza il numero di argomenti della linea di comando, che sono stati passati allo shell script<<BR>> ? memorizza il valore numerico di uscita dell'ultimo comando che è stato eseguito<<BR>> 0 memorizza il nome dello shell-script, che è stato introdotto<<BR>> * memorizza tutti gli argomenti che sono stati introdotti sulla linea di comando<<BR>> ! contiene il numero dell'ultimo processo che è stato mandato in background con la &<<BR>> - contiene i flag con cui è stata eseguita la shell||
||`PATH`<<BR>> `HOME`|| ||Le più note variabili di ambiente.||
||`export `''var''`=`''value''||b||La modifica alle variabili d'ambiente in genere è solo locale. Con `export` le variabili vengono esportate anche fuori.||
||`if`''comandi''`;`<<BR>>`then`<<BR>>''comandi1''`;`<<BR>>`else`<<BR>>''comandi2''`;`<<BR>>`fi` ||b||Struttura `if`.||
||`for `''var''` in `''valore1'' ''valore2''`;`<<BR>> `do`<<BR>> ''comandi''`;`<<BR>>`done`||b ||Struttura `for`.||
||`while` ''comandi''`;`<<BR>>`do`<<BR>>''comandi''`;`<<BR>>`done`||b ||Struttura `while`.||
||`case `''stringa''` in`<<BR>> ''pattern1''`)`''comando1''`;`<<BR>> ''pattern2''`)`''comando2''`;`<<BR>>...<<BR>> `esac` ||b ||Struttura `switch`.||
||''nomefunzione'' () {<<BR>> ''codice''<<BR>> [`return `''value'']<<BR>> } ||b||Dichiarazione di funzioni||
||`builtin `''command''||b||Esegue il comando originale builtin `''command''`, anche se tale comando fosse stato ridefinito. Confronta `command`.||
||`break` ||b||Interrompe un ciclo `for, while, until`.||
||`continue`||b||In un ciclo `for, while, until` termina il ciclo corrente e passa al prossimo.||
||`eval `''comando''||b||esegue il `''comando''`, il quale tipicamente è una stringa costruita nelle maniere più diverse.||
||`local `''varname''`[=`''value''`]`||b||Crea una variabile locale (dentro una funzione).||
||`expr `''argomenti''|| ||valuta gli argomenti. Usato per l'aritmetica, ecc. in shell||
||`exit [`''n''`]`|| ||termina lo script (in effetti termina la shell) con exit status ''n''.||
||`shift [`''n''`]`||b||Cambia la numerazione dei parametri. I parametri $1...$''n'' spariscono, gli altri vengono scalati di ''n''. Di default ''n''=1.||
||`read [-u `''file''`] `''varnames''||b||Legge una o più variabili da tastiera, oppure da file se un file è specificato.||
||`readonly `''varname''`[=`''value''`]`||b||Imposta come ''read-only'' una certa variabile.||
||`test `''opzioni''<<BR>>`test -n $1`<<BR>>`test ($1 -eq $2)-a($1 -le $3)`||b||tipico operatore booleano<<BR>>true se l'argomento è una stringa non vuota<<BR>>true se $1 รจ un intero uguale a $2 e minore o uguale a $3||
||`trap `''function signal''||b||Esegue la funzione specificata solo quando la shell riceve il segnale ''signal''.||
<<BR>>
== La/Tex ==
||<tablestyle="border:2" :35%>'''Comando''' || '''Cosa fa'''||
||`latex `''filename''||Compila ''filename''`.tex` in ''filename''`.dvi`.||
||`pdflatex `''filename''||Compila ''filename''`.tex` in ''filename''`.pdf`.||
||`dvips `''filename''||Converte ''filename''`.dvi` in ''filename''`.ps`.||
||`sudo texhash`||Aggiorna la tabella (hash) dei package installati.||
||`fmtutil --all`||Ricrea tutti i ''format files''. Serve ad esempio se installi una nuova lingua. Prima però bisogna modificare il `language.dat`; e in Debian non puoi farlo direttamente (vedi `language-update`).||
||`sudo language-update`||In Debian, costruisce `language.dat` a partire dai files in `/etc/texmf/language.d`. Dopo occorerà richiamare `fmtutil --all`.||
||`texconfig`||Utility di configurazione la/tex (in Debian limitata ma comunque utile)||
----
CategoryHomepage