IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Linux Professional Institute Certificate. LPIC-1

Lpic1 large.gif
Certificat LPIC-1
Examen: 102 (torneu a la resta de temes)
Fitxers: LPI105.1_ConfiguracioMidaShell.pdf (LPI105.1_ConfiguracioMidaShell.odp), UD_8_8_shell_bash.pdf,UD_8_9_program_bash.pdf (Apunts Eva Dominguez)
Objectius: http://www.lpi.org/eng/certification/the_lpic_program/lpic_1/exam_102_detailed_objectives
Dipòsit SVN: https://svn.projectes.lafarga.cat/svn/lpi/Materials/Examen_102/105.1
Usuari: anonymous
Paraula de pas: qualsevol paraula de pas

Objectius del tema

105.1. Configuració a mida i ús de l'entorn shell
Objective.jpg
  • Objectiu: Els candidats han de ser capaços de configurar el entorn shell per tal d'acomplir els requeriments dels usuaris. Els candidats han de ser capaços de modificar perfils d'usuaris globals i d'usuari.
  • Pes: 4
060317 Icon - Theory of Knowledge v01 pdc.jpg

Àrees Clau de Coneixement:

Icon list.jpg

La següent és una llista parcial de fitxers, termes i utilitats utilitzades:

Text-editor.svg

Apunts: LPI 105.1. Configuració a mida i ús de l'entorn shell

Plantilla per prendre apunts

Configuració de la shell

Com s'invoca l'interpret d'ordres bash

Per comprendre com s'invoca cal diferenciar els tipus d'intèrprets d'ordres segons com s'executin:

Els intèrprets d'ordres interactius poden ser de dos tipus:

  • Login shell: La traducció seria interpret d'ordres de login. és el interpret d'ordres que s'executa amb els paràmetres - (cap paràmetre) o --login. Normalment només s'executa durant el procés de login, per exemple al iniciar un interpret d'ordres des d'una consola virtual (p.ex. Ctrl+Alt+F1) o al iniciar una sessió gràfica amb un gestor de pantalla (Display Manager)
  • Non-login shells: La traducció seria interpret d'ordres de no-login. Són la resta d'execucions d'intèrprets d'ordres. És el tipus d'intèrpret d'ordre que s'executa al executar una eina de terminal com xterm o gnome-terminal.

Vegem alguns exemples. Les següents ordres inicien una login shell:

Iniciar un sessió de root:

$ sudo su -

Executar una login bash:

$ bash --login
$ bash -

Executar una sessió remota amb SSH:

$ ssh user@host

Les següents ordres inicien intèrprets d'ordres interactius i no-login:

$ bash

O executant qualsevol eina de terminal com xterm o gnome-terminal.

Els següents exemples executen intèrprets d'ordres no interactius:

$ su user -c /path/to/command
$ bash -c /path/to/command

L'ordre en que es llegeixen els fitxers de configuració és:

  1. /etc/profile. Pot no existir aleshores es passa al següent fitxer
  2. Es llegeix un dels següents fitxers (el primer que existeixi en l'ordre que estan indicats):

Es pot evitar aquest comportament amb l'opció:

--noprofile

NOTA: Tot i que no aparegui implícitament el fitxer ~/.bashrc cal tenir en compte que la majoria de fitxers ~/.bash_profile executen ~/.bashrc.

En canvi quan s'executa un interpret d'ordres interactiu que no és de login, bash llegeix i executa les comandes dels fitxers:

  1. /etc/bash.bashrc
  2. ~/.bashrc

Es pot evitar aquest comportament amb l'opció:

--norc

L'opció:

--rcfile cami_a_un_fitxer

Forçarà a l'interpret d'ordres bash a llegir els fitxers especificat en comptes dels habituals que acabem d'indicar.

NOTA: Si qualsevol dels fitxers de configuració existeix però no és llegible per l'usuari, aleshores bash mostra un error

Configuració de sistema (per-system basis)

Segons l'estàndard FHS els fitxers de configuració que afecten a tot el sistema (per-system basis) s'han de trobar a la carpeta:

/etc

NOTA: Es poden veure els fitxers de configuració globals com fitxers que contenen les configuracions per defecte per a tots els usuaris del sistema. Cal però, tenir en compte que les configuracions de cada usuari poden sobreescriure les configuracions globals (a l'estil del que succeïx en llenguatges de programació amb les variables locals i les variables globals)

Lo habitual és que els fitxers de configuració globals només els puguin editar l'administrador del sistema (usuari root) o aquells usuaris que tinguin permisos per administrar el sistema (vegeu l'ordre sudo).

En aquest objectiu objectiu LPI ens centrarem en els fitxers de configuració globals que configuren els intèrprets d'ordres (shell), concretament l'interpret d'ordres bash. Els fitxers són:

  • /etc/profile: Fitxer de configuració de la bash a nivell de sistema. Només s'utilitza amb les bash que siguin de login.
  • /etc/bash.bashrc: Fitxer de configuració de la bash a nivell de sistema. Només s'utilitza amb les bash que NO siguin de login.

Aquest fitxers permeten configurar diverses opcions de bash com per exemple les variables d'entorn, executar ordres cada cop que s'executi l'interpret d'ordres, etc. Bàsicament com s'executen abans de començar a utilitzar l'interpret d'ordres el que fan es permetre configurar l'entorn de treball d'aquest interpret.

Consulteu els següents apartats per tal d'obtenir més informació.

Configuració d'usuari (per-user basis)

També segons l'estàndard FHS els fitxers que són propietat dels usuaris del sistema es troben a la carpeta:

/home

Dins d'aquesta carpeta cada usuari sol ser el propietari de la carpeta:

/home/nom_usuari

Per exemple, l'usuari sergi és propietari de la carpeta:

/home/sergi

Com que els fitxers de la carpeta HOME d'un usuari són propietat seva, l'usuari pot llegir, modificar o inclús eliminar els fitxers de la seva HOME.

Per raons de seguretat els fitxers de configuració solen ser fitxers ocults, és a dir comencen per "." (punt). Recordeu que per veure aquesta fitxers cal utilitzar el paràmetre -a de l'ordre ls:

$ ls -la /home/sergi
...
drwxr-xr-x 81 sergi sergi 212992 2010-03-06 17:33 .
drwxr-xr-x  6 root  root    4096 2010-02-10 08:55 ..
drwx------  3 sergi sergi   4096 2009-08-11 16:26 .adobe
drwxr-xr-x  3 sergi sergi   4096 2010-03-04 11:14 Baixades
-rw-------  1 sergi sergi  11494 2010-03-04 23:47 .bash_history
-rw-r--r--  1 sergi sergi    220 2009-07-27 09:33 .bash_logout
-rw-r--r--  1 sergi sergi   3233 2009-08-05 13:29 .bashrc
drwx------ 16 sergi sergi   4096 2010-02-21 12:22 .cache
drwx------  3 sergi sergi   4096 2009-08-29 16:59 .compiz
drwxr-xr-x 14 sergi sergi   4096 2010-02-25 09:23 .config
drwx------  3 sergi sergi   4096 2009-07-27 10:46 .dbus
drwx------  2 sergi sergi   4096 2009-08-05 12:18 Desktop
-rw-r--r--  1 sergi sergi     63 2010-03-06 17:32 .dmrc
drwxr-xr-x 10 sergi sergi   4096 2010-01-14 14:22 Documents
...
drwx------  2 sergi sergi   4096 2010-02-21 22:48 .filezilla
drwxr-xr-x  2 sergi sergi   4096 2009-11-02 11:37 .fontconfig
drwx------  5 sergi sergi   4096 2010-03-07 07:35 .gconf
...

NOTA: Cal tenir en compte que els sistemes Linux són altament configurables (de fet el fet de disposar del codi font permet una configuració/adaptació a mida sense límits) i per tant és possible, que hi hagi sistemes que tinguin les HOME dels usuaris en altres carpetes del sistema

Els fitxers de configuració de bash a nivell d'usuari (per-user basis) són:

Recordeu que la HOME és sovint referenciada amb el símbol ~ i per tant sovint parlem dels fitxers ~ /.bashrc i ~/.bash_logout

NOTA: Observeu que bash no és l'única aplicació que utilitza fitxers ocults per a la seva configuració. A la sortida de l'ordre ls de més amunt podeu veure altres fitxers i carpetes ocults que contenen la configuració d'aplicacions com filezilla, la configuració de Gnome (fitxer .gconf), etc. Utilitzar fitxers ocults té dos objectius: primer amagar fitxers que normalment l'usuari no modifica directament, ja que són les aplicacions qui directament modifiquen aquests fitxers. Segon, fa més difícil que aquests fitxers siguin modificats per error per l'usuari. Se suposa que només l'usuari que sàpiga el que està fent hauria de modificar directament aquests fitxers...

Com podeu veure a LPI_107.1, els fitxers per defecte que es troben a les carpetes HOME dels usuaris s'indiquen a la carpeta:

/etc/skel

I per tant si dins d'aquesta carpeta creeu uns fitxers .bashrc i .bash_logout esteu indicant quines són les configuracions per defecte per als nous usuaris:

NOTA: Cal tenir en compte que com els usuaris poden modificar els fitxers de la seva HOME, no podeu fer "configuracions obligatòries" mitjançant aquests fitxers. També cal tenir en compte que aquests fitxers normalment s'executen després del fitxers de configuració de sistema i per tant poden sobreescriure les configuracions de sistema. Finalment tingueu en compte que els canvis fets als fitxers de la carpeta /etc/skel només s'apliquen als nous usuaris i no pas als usuaris ja existents

Taula resum

Tipus de fitxer Fitxer de configuració amb login Fitxer de configuració sense login
Sistema /etc/profile i els fitxers de la carpeta /etc/profile.d /etc/bash.bashrc o /etc/bashrc
Usuari ~/.bash_login, ~/.profile, o ~/.bash_profile ~/.bashrc

L'ordre d'execució dels fitxers és:

Login SHELL:

Els fitxers es llegeixen i s'executen en el següent ordre (en el cas de bash):

NOTA: Recordeu que el fet de que s'executin els fitxers de configuració de no login és pel fet de que són executats implícitament als fitxers de configuració de login

NO LOGIN SHELL:

Com se surt de l'interpret d'ordres bash

Quan s'atura l'execució d'un interpret d'ordres, bash llegeix i executa les comandes del fitxer:

~/.bash_logout, if it exists.

NOTA: Només s'executa el fitxer si existeix. Si no existeix no es surt normalment

Manual de bash

Al manual de bash, concretament a la secció INVOCATION podeu trobar més informació sobre la configuració de la bash.

$ man bash
...
INVOCATION
  A login shell is one whose first character of argument zero is a -, or one started with the --login option.
  An  interactive shell is one started without non-option arguments and without the -c option whose standard input and error are both connected to terminals (as deter‐
  mined by isatty(3)), or one started with the -i option.  PS1 is set and $- includes i if bash is interactive, allowing a shell script or a startup file to test  this
  state.

  The  following paragraphs describe how bash executes its startup files.  If any of the files exist but cannot be read, bash reports an error.  Tildes are expanded in
  file names as described below under Tilde Expansion in the EXPANSION section.

  When bash is invoked as an interactive login shell, or as a non-interactive shell with the --login option, it  first  reads  and  executes  commands  from  the  file
  /etc/profile,  if that file exists.  After reading that file, it looks for ~/.bash_profile, ~/.bash_login, and ~/.profile, in that order, and reads and 
  executes commands from the first one that exists and is readable.  The --noprofile option may be used when the shell is started to inhibit this behavior.

  When a login shell exits, bash reads and executes commands from the file ~/.bash_logout, if it exists.
  When an interactive shell that is not a login shell is started, bash reads and executes commands from /etc/bash.bashrc and ~/.bashrc, if these files exist.  This may
  be inhibited by using the --norc option.  The --rcfile file option will force bash to read and execute commands from file instead of /etc/bash.bashrc and ~/.bashrc.

  When  bash  is  started non-interactively, to run a shell script, for example, it looks for the variable BASH_ENV in the environment, expands its value if it appears
  there, and uses the expanded value as the name of a file to read and execute.  Bash behaves as if the following command were executed:
         if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
  but the value of the PATH variable is not used to search for the file name.

  If bash is invoked with the name sh, it tries to mimic the startup behavior of historical versions of sh as closely as possible, while conforming to the POSIX  stan‐
  dard  as  well.   When invoked as an interactive login shell, or a non-interactive shell with the --login option, it first attempts to read and execute commands from
  /etc/profile and ~/.profile, in that order.  The --noprofile option may be used to inhibit this behavior.  When invoked as an interactive shell  with  the  name  sh,
  bash looks for the variable ENV, expands its value if it is defined, and uses the expanded value as the name of a file to read and execute.  Since a shell invoked as
  sh does not attempt to read and execute commands from any other startup files, the --rcfile option has no effect.  A non-interactive shell invoked with the  name  sh
  does not attempt to read any other startup files.  When invoked as sh, bash enters posix mode after the startup files are read.

  When  bash  is  started  in  posix  mode, as with the --posix command line option, it follows the POSIX standard for startup files.  In this mode, interactive shells
  expand the ENV variable and commands are read and executed from the file whose name is the expanded value.  No other startup files are read.

  Bash attempts to determine when it is being run with its standard input connected to a a network connection, as if by the remote shell daemon, usually rshd,  or  the
  secure  shell daemon sshd.  If bash determines it is being run in this fashion, it reads and executes commands from ~/.bashrc and ~/.bashrc, if these files exist and
  are readable.  It will not do this if invoked as sh.  The --norc option may be used to inhibit this behavior, and the --rcfile option may be used  to  force  another
  file to be read, but rshd does not generally invoke the shell with those options or allow them to be specified.

  If the shell is started with the effective user (group) id not equal to the real user (group) id, and the -p option is not supplied, no startup files are read, shell
  functions are not inherited from the environment, the SHELLOPTS variable, if it appears in the environment, is ignored, and the effective user id is set to the  real
  user id.  If the -p option is supplied at invocation, the startup behavior is the same, but the effective user id is not reset.

Opcions d'execució de bash

rbash

Si bash s'executa amb:

$ rbash

o

$ bash --restricted

Aleshores s'inicia un interpret d'ordres restringit que és com el normal però sense poder fer les següents operacions:

  • No es pot modificar el directori de treball amb l'ordre cd
  • No es poden establir ni modificar les variables d'entorn SHELL, PATH, ENV, o BASH_ENV
  • No es poden executar ordres que continguin /
  • No es poden utilitzar que continguin / per a fer includes (amb . nom_fitxer_amb_slashes) o amb l'opció -p
  • Importar definicions de funcions
  • Modificar els SHELLOPTS durant l'inici de l'interpret d'ordres
  • No es poden utilitzar els operadors de redirecció `>', `>|', `<>', `>&', `&>', i `>>'.
  • No es pot utilitzar exec
  • No es poden afegir builtin commands amb l'opció `-f' o `-d'
  • No es pot utilitzar l'opció -p
  • No es pot apagar el mode restrictiu amb `set +r' o `set +o restricted'

Documentació de bash

A sistemes de la família Debian hi ha un paquet anomenat bash-doc que proporciona documentació i exemples de bash:

$ sudo apt-get install bash-doc

els fitxers instal·lats són:

$ dpkg -L bash-doc
/.
/usr
/usr/share
/usr/share/doc
/usr/share/doc/bash
/usr/share/doc/bash/examples
/usr/share/doc/bash/examples/INDEX.html
...

Si us fixeu hi ha un index dels exemples en HTML i podeu accedir-hi amb:

$ firefox  /usr/share/doc/bash/examples/INDEX.html

si no teniu entorn gràfics podeu utilitzar lynx:

$ lynx /usr/share/doc/bash/examples/INDEX.html

també hi ha un manual de referència de bash en format PDF:

$ evince /usr/share/doc/bash/bashref.pdf

Variables d'entorn

Consulteu l'apartat Variables d'entorn de l'objectiu LPI_103.1._Treballar_a_la_línia_d'ordres.

Establir variables d'entorn al iniciar sessió (login)

Es poden utilitzar els fitxers de configuració de bash per establir variables d'entorn. Per exemple a ~/.bashrc podeu afegir:

export EMPRESA="ICE UPC"

Per definir la variable d'entorn EMPRESA per al vostre usuari. Si voleu que sigui de sistema l'hauríeu d'afegir a /etc/bash.bashrc

Establir el PATH del sistema

Consulteu PATH.

Desactivar temporalment variables d'entorn

Consulteu unset.

Gramàtica de bash

En aquest apartat intentarem resumir les formes en que es poden executar ordres amb bash. Primer cal definir el que s'anomenen operadors de control (control operators), que són:

|| & && ; ;; ( ) | |& <newline>

Ordre simple

$ ordre argument1 argument2 argument3 ... <control_operator>

Quan a bash és parla de paraules es refereix als conjunts de caràcters que estan junts. Les paraules es separen per espais. En una ordre simple la primera paraula és la comanda i la resta de paraules són els arguments. Normalment les ordres simples s'acaben amb el operador de control "salt de línia" o amb ";". És el mateix:

$ ls <salt de línia>

que

$ ls;

NOTA: En una bash interactiva cal fer un salt de línia amb Enter per tal de executar una ordre simple o conjunt d'ordres.

Canonades (pipelines)

És una seqüència d'ordres simples separades per "|" o "|&". La sintaxi és:

$ ordre1 | ordre2

o

$ ordre1 |& ordre2

El que fa un conducte és enllaçar la sortida estàndard de l'ordre n-1 amb l'entrada estàndard de l'ordre n. Si s'indica |& s'enllaça la sortida estàndard i la sortida estàndard d'error.

Vegem un exemple:

$ ls -l | wc

El que fa es comptar les línies, paraules i caracters de la sortida de l'ordre ls -l.

NOTA: Cada ordre del conducte és executada en un procés diferent i de forma concurrent. Per exemple:

$ sleep 100 | wc -l

Executa tots dos processos:

$ ps aux
...
sergi    12731  0.0  0.0   2956   628 pts/6    S+   20:09   0:00 sleep 100
sergi    12732  0.0  0.0   3276   700 pts/6    S+   20:09   0:00 wc -l

Llistes

Son un conjunt d'ordres simples o conductes que s'executen en ordre. Les llistes es poden fer amb algun dels següents operadors de control:

; & && ||

I opcionalment acaben amb:

; o & o <nova_línia>

Per fer una llista seqüencial només cal separar les ordres amb ";"

$ ordre1 ; ordre2; ordre3

És a dir primer s'executa ordre1 i quan acaba s'executa ordre 2 i així successivament. Si alguna ordre acaba amb "&" aleshores s'executa en segon terme i retorna 0 immediatament executant-se la següent ordre de la llista seqüencial. El codi de sortida (exit status) d'una llista és el codi de sortida de l'última ordre executada.

En cas de combinacions d'operador de control primer s'executen els || i && (mateixa prioritat) i després & i ; (mateixa prioritat).

Les llistes AND es fan amb &&

ordre1 && ordre2

L'ordre 2 només s'executa sí i només si l'ordre 1 s'executa correctament (codi de sortida 0). Per exemple:

$ mkdir carpeta && cd carpeta

Només entrem a la carpeta si la podem crear correctament.

Les llistes OR es fan amb l'operador ||:

ordre1 ⎪⎪ ordre2

L'ordre 2 només s'executa sí i només si l'ordre 1 retorna un error (codi de sortida diferent de 0). Per exemple:

$ mkdir carpeta || exit

Sortim de l'script si i només si no podem crear correctament la carpeta.

Comandes compostes (Compound commands)

Hi ha les següents opcions:

(list)

S'executa una llista de comandes en un procés apart.

{ list; }

S'executa un conjunt d'ordres en primer terme i de forma seqüencial. Si us fixeu són els caràcters utilitzats per indicar l'inici i fi d'una funció:

function nom {
 list;
}

La llista també pot acabar amb un salt de línia.

Expressions

Les expressions es consideren comandes compostes.

Poden ser aritmètiques:

((expression))

Per exemple:

$ x=1
$ y=$((x+1))
$ echo $y;
2

També es pot fer una expressió aritmètica amb l'ordre interna let:

$ i=1
$ let i+=1
$ echo i
2

Vegeu també l'ordre interna expr.

o condicionals:

[[ expression ]]

Per exemple:

$ if [[ "text" != "text2" ]]; then echo "diferents"; fi
 diferents

En canvi:

$ if [[ "text" == "text" ]]; then echo "iguals"; fi
 iguals 

IMPORTANT: Noteu els espai en l'expressió condicional! Sense aquests espais podeu tenir errors de sintaxi

expr

L'ordre interna expr pot ser utilitzada per a avaluar expressions aritmètiques. Alguns exemples:

$ expr 1 + 1
2
$ expr 3 \* 2
6
$ expr 6 / 3
2
$ expr 6 % 3
0
$ expr 3 / 2
1
$ expr 3 / 6
0
$ expr 6 \* 3.5
expr: non-numeric argument

Paraules reservades

A bash són les següents:

! case  do done elif else esac fi for function if in select then until while { } time [[ ]]

Carpetes HOME per defecte per als nous usuaris. /etc/skel

La carpeta /etc/skel és la carpeta HOME per defecte que s'assigna als nous usuaris quan aquests usuaris es generen amb l'ordre useradd. Si s'utilitzin altres ordres com adduser (només en sistemes de la família Debian) es crea automàticament la carpeta home també a partir d'skel.

Tingueu en compte que es pot configurar useradd per tal d'utilitzar un altre carpeta:

# cat /etc/default/useradd | grep skel
# The SKEL variable specifies the directory containing "skeletal" user
# SKEL=/etc/skel

Per obtenir més informació sobre la gestió d'usuaris consulteu l'objectiu LPI_105.2 Adaptar o escriure guions d'intèrpret d'ordres simples.

El següent és un exemple de fitxer /etc/skel a Ubuntu Karmic Koala (9.10):

$ ls -la /etc/skel/
total 32
drwxr-xr-x   2 root root  4096 2009-12-22 11:45 .
drwxr-xr-x 174 root root 12288 2010-03-08 10:18 ..
-rw-r--r--   1 root root   220 2009-09-14 07:09 .bash_logout
-rw-r--r--   1 root root  3180 2009-09-14 07:09 .bashrc
-rw-r--r--   1 root root   167 2009-10-02 22:40 examples.desktop
-rw-r--r--   1 root root   675 2009-09-14 07:09 .profile

NOTA: Cal tenir en compte que qualsevol canvi que feu a la carpeta /etc/skel no s'aplicarà als usuaris ja existents

Funcions bash

Una funció de shell és un objecte que és cridat com una ordre simple i executa una ordre composta (conjunt d'ordres).

La sintaxi d'una funció és:

[ function ] name () compound-command [redirection]

L'anterior defineix una funció amb el nom "name". La paraula reservada function és opcional. Si no s'utilitza aleshores els parèntesi també són opcionals. El cos de la funció és una ordre composta, normalment un conjunt de ordres tipus llista, com per exemple:

{
ordre 1
ordre 2; ordre 3; ordre4
ordre5
}

Però pot ser qualsevol altre de les comandes compostes. Al final de la funció es pot especificar una redirecció.

El codi de sortida (exit status) d'una funció és el codi de sortida de l'última ordre executada.

Per exemple:

$ function prova { echo "Fitxers de la carpeta a la que estem"; ls; };
$ prova
Fitxers de la carpeta a la que estem
102.3     Documents               eclipses    gmote               initgz_fog          loop1      network                Plantilles   provesnmil      
webmin    Baixades                Document    sense desar 1       Escriptori          gmotedata  JDBCMysqlConnector     LPI          pr
...

IMPORTANT: Els espais s'ha de respectar. El següent us retorna un error de sintaxi:

$ function prova {echo "Fitxers de la carpeta a la que estem"; ls;};
-su: hi ha un error inesperat de sintaxi prop del senyal '{echo'

Cal tenir en compte que les comandes de la funció s'executen al mateix procés que la bash que estem utilitzant (no es crea cap nou procés) i amb el mateix context i configuració.

Es poden utilitzar paràmetres posicionals:

$ function holamon { echo "hola $1"; }
$ holamon
hola 
$ holamon Sergi
hola Sergi

Cal tenir en compte però que no es modifica el paràmetre posicional $0:

$ function holamon { echo $0;}
$ holamon
bash

També cal tenir en compte que les variables són compartides (o globals) entre funcions i codi principal. Per declarar una variable local cal utilitzar l'ordre interna:

$ local i=1
bash: local: can only be used in a function
$ i=1
$ function prova { local i=2; echo $i;}
$ echo $i
1
$ prova
2
$ echo $i
1

Per sortir d'una funció abans del final s'utilitza l'ordre interna return.

Es poden consultar totes les funcions declarades amb l'ordre interna:

$ declare -f

Apareixen en ordre alfabètic. També es pot utilitzar l'ordre interna:

$ typeset -f

Per mostrar només els noms:

$ typeset -F
$ declare -F

Les funcions poden ser recursives, es a dit, una funció es pot cridar a si mateixa o fins i tot a un altre funció.

Consulteu el manual les seccions:

$ man bash

FUNCTIONS:

i

SHELL GRAMMAR

lists

Consulteu:

Comandes

env

Consulteu env.

export

Consulteu export.

set

Consulteu set.

No sobrescriure un fitxer al utilitzar > ?

unset

Consulteu unset.

function

Paraula reservada que serveix per definir funcions de bash. Consulteu Funcions de bash.

alias

Consulteu alias.

shopt

Comanda interna de bash que permet establir les opcions de la shell (shell options). Si l'executeu sense paràmetres us mostrarà l'estat de les opcions a l'interpret d'ordres actual:

$ shopt
autocd         	off
cdable_vars    	off
cdspell        	off
checkhash      	off
checkjobs      	off
checkwinsize   	on
cmdhist        	on
compat31       	off
compat32       	off
dirspell       	off
dotglob        	off
execfail       	off 
expand_aliases 	on
extdebug       	off
extglob        	on
extquote       	on
failglob       	off
force_fignore  	on
globstar       	off
gnu_errfmt     	off
histappend     	on
histreedit     	off
histverify     	off
hostcomplete   	off
huponexit      	off
interactive_comments	on
lithist        	off
login_shell    	off
mailwarn       	off
no_empty_cmd_completion	off
nocaseglob     	off
nocasematch    	off
nullglob       	off
progcomp       	on
promptvars     	on
restricted_shell	off
shift_verbose  	off
sourcepath     	on
xpg_echo       	off

Amb l'opció -p ens ensenya amb quina ordre establiríem les opcions que hi ha actualment:

& shopt -p
shopt -u autocd
shopt -u cdable_vars
shopt -u cdspell
shopt -u checkhash
shopt -u checkjobs
shopt -s checkwinsize
shopt -s cmdhist
...

Com podeu veure per desactivar una opció cal utilitzar -u (unset):

$ shopt -u opcio

I per activar-la cal utilitzar -s (set):

$ shopt -s cmdhist

Per mostrar les opcions que estan establertes:

$ shopt -s
checkwinsize   	on
cmdhist        	on
expand_aliases 	on
extglob        	on
extquote       	on
force_fignore  	on
histappend     	on
interactive_comments	on
progcomp       	on
promptvars     	on
sourcepath     	on

I les no establertes:

$ shopt -u

Vegem algunes de les opcions:

  • checkwinsize: Després de cada ordre es comprova la mida de la finestra i si és necessari s'actualitzen els valors LINES i COLUMNS.
  • interactive_comments: Activa els comentaris de bash (línies començades amb #)

Com moltes altres ordres internes de bash no té manual propi i cal consultar la secció SHELL BUILTIN COMMANDS del manual de bash:

$ man bash
...
SHELL BUILTIN COMMANDS
...

Fitxers

/etc/profile

Exemple de fitxer (extret d'una Ubuntu Karmic Koala 9.10):

$ cat /etc/profile
# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))
# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).

if [ -d /etc/profile.d ]; then
  for i in /etc/profile.d/*.sh; do
    if [ -r $i ]; then
      . $i
    fi
  done
  unset i
fi

if [ "$PS1" ]; then
  if [ "$BASH" ]; then
    PS1='\u@\h:\w\$ '
    if [ -f /etc/bash.bashrc ]; then
	. /etc/bash.bashrc
    fi
  else
    if [ "`id -u`" -eq 0 ]; then
      PS1='# '
    else
      PS1='$ '
    fi
  fi
fi

umask 022

Podeu observar que és un fitxer genèric per a múltiples intèrprets d'ordres (sh i compatibles amb bash). Fitxeu-vos com s'executen (s'inclouen am . nom_fitxer) tots els fitxers de la carpeta:

/etc/profile.d

I després es configura el PROMPT de l'interpret amb la variable d'entorn PS1. Si es bash a més s'executa:

. /etc/bash.bashrc

Finalment es configura umask:

umask 0222

Vegeu també:

/etc/profile.d

Aquesta carpeta permet posar scripts independents que s'executaran al executar el fitxer /etc/profile. Això permet fer més ordenat el procés de configuració de la bash i també facilita les actualitzacions i canvis de configuració per part de aplicacions de tercers (les aplicacions de tercers que vulguin fer canvi en la configuració han de crear un fitxer a aquesta carpeta i així s'evita que hi hagi diverses aplicacions modificant el mateix fitxer /etc/profile).

Vegem un exemple de carpeta:

$ ls -la /etc/profile.d/
total 24
drwxr-xr-x   2 root root  4096 2009-12-22 11:45 .
drwxr-xr-x 174 root root 12288 2010-03-06 06:25 ..
-rw-r--r--   1 root root  2516 2009-10-20 05:57 gvfs-bash-completion.sh
-rw-r--r--   1 root root    74 2009-10-13 07:27 speechd-user-port.sh

Vegeu també:

/etc/bash.bashrc

Exemple de fitxer (extret d'una Ubuntu Karmic Koala 9.10):

$ cat /etc/bash.bashrc
# System-wide .bashrc file for interactive bash(1) shells.

# To enable the settings / commands in this file for login shells as well,
# this file has to be sourced in /etc/profile.

# If not running interactively, don't do anything
[ -z "$PS1" ] && return

# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
 shopt -s checkwinsize

# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# set a fancy prompt (non-color, overwrite the one in /etc/profile)
PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '

# Commented out, don't overwrite xterm -T "title" -n "icontitle" by default.
# If this is an xterm set the title to user@host:dir
#case "$TERM" in
#xterm*|rxvt*)
#    PROMPT_COMMAND='echo -ne "\033]0;${USER}@${HOSTNAME}: ${PWD}\007"'
#    ;;
#*)
#    ;;
#esac

# enable bash completion in interactive shells
#if [ -f /etc/bash_completion ] && ! shopt -oq posix; then
#    . /etc/bash_completion
#fi

# sudo hint
if [ ! -e $HOME/.sudo_as_admin_successful ]; then
    case " $(groups) " in *\ admin\ *)
    if [ -x /usr/bin/sudo ]; then
	cat <<-EOF
	To run a command as administrator (user "root"), use "sudo <command>".
	See "man sudo_root" for details.
	
	EOF
    fi
    esac
fi

# if the command-not-found package is installed, use it
if [ -x /usr/lib/command-not-found ]; then
	function command_not_found_handle {
	        # check because c-n-f could've been removed in the meantime
               if [ -x /usr/lib/command-not-found ]; then
		   /usr/bin/python /usr/lib/command-not-found -- $1
                  return $?
		else
		   return 127
		fi
	}
fi

Fixeu-vos en les últimes línies, com afegeixen el suport per a command-not-found (les noves versions d'Ubuntu si s'escriu una comanda no vàlida mostren alternatives). Pexer exemple:

$ suco ls
No command 'suco' found, did you mean:
 Command 'syco' from package 'emboss' (universe)
 Command 'sudo' from package 'sudo' (main)
 Command 'sudo' from package 'sudo-ldap' (universe)
 Command 'suck' from package 'suck' (universe)
suco: command not found

Vegeu també:

~/.bash_profile

Aquest és el fitxer de configuració de bash a nivell d'usuari per a les shell que s'iniciïn com a part d'un login (consulteu l'apartat Com s'invoca l'interpret d'ordres bash ). És molt possible que no el tingueu. Proveu de crear-lo amb:

$ cd
$ joe . ~/.bash_profile

I afegiu una línia amb un echo:

echo "Nova shell de login"

Si ara inicieu una nova shell de no-login:

$ su sergi
Contrasenya: 
$

Com vegeu no s'executa l'echo. També podeu provar amb el mateix resultat:

$ bash
$

En canvi si executeu una shell de login:

$ su - sergi
Contrasenya: 
Nova shell de login
$

En canvi si modifiqueu el fitxer ~/.bashrc:

$ cd
$ joe ~/.bashrc

I afegiu la línia:

echo "Executant .bashrc"

al principi del fitxer, ara si executeu una bash de no-login:

$ su sergi
Contrasenya: 
Executant .bashrc

Sí us mostrarà el missatge. I si executeu una bash de login:

$ su - sergi

Només executarà el fitxer de bash de login! Normalment quan aquest fitxer s'utilitza, s'executa el fitxer de configuració de bash de no login amb:

$ joe .bash_profile
echo "Nova shell de login"

. .bashrc

I aleshores s'executen tots dos scripts:

$ su - sergi
Contrasenya: 
Nova shell de login
Executant .bashrc

NOTA: Noteu que és el que s'ha fet amb la configuració a nivell de sistema

Vegeu també:

~/.bash_login

És un nom alternatiu per al fitxer ~/.bash_profile.

Vegeu també:

~/.profile

És un nom alternatiu per al fitxer ~/.bash_profile. En sistemes com Ubuntu és el nom que s'utilitza, vegem un exemple de fitxer a Ubuntu Karmic Koala (9.10):

$ cat .profile 
# ~/.profile: executed by the command interpreter for login shells.
# This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login
# exists.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package.

# the default umask is set in /etc/profile; for setting the umask
# for ssh logins, install and configure the libpam-umask package.
#umask 022

# if running bash
if [ -n "$BASH_VERSION" ]; then
    # include .bashrc if it exists
    if [ -f "$HOME/.bashrc" ]; then
	. "$HOME/.bashrc"
    fi
fi

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
    PATH="$HOME/bin:$PATH"
fi

Si us fixeu executa .bashrc i afegeix la carpeta $HOME/bin a la variable d'entorn PATH (si existeix).

Vegeu també:

~/.bashrc

Exemple de fitxer (extret d'una Ubuntu Karmic Koala 9.10):

$ cat .bashrc 
# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples

# If not running interactively, don't do anything
[ -z "$PS1" ] && return

# don't put duplicate lines in the history. See bash(1) for more options
# don't overwrite GNU Midnight Commander's setting of `ignorespace'.
export HISTCONTROL=$HISTCONTROL${HISTCONTROL+,}ignoredups
# ... or force ignoredups and ignorespace
export HISTCONTROL=ignoreboth

# append to the history file, don't overwrite it
shopt -s histappend

# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)

# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
shopt -s checkwinsize

# make less more friendly for non-text input files, see lesspipe(1)
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"

# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# set a fancy prompt (non-color, unless we know we "want" color)
case "$TERM" in
    xterm-color) color_prompt=yes;;
esac

# uncomment for a colored prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the prompt
#force_color_prompt=yes

if [ -n "$force_color_prompt" ]; then
    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
	# We have color support; assume it's compliant with Ecma-48 
	# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
	# a case would tend to support setf rather than setaf.) 
	color_prompt=yes
    else 
	color_prompt=
   fi
fi

if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi
unset color_prompt force_color_prompt

# If this is an xterm set the title to user@host:dir
case "$TERM" in
xterm*|rxvt*)
    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
    ;;
*)
    ;;
esac

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

#if [ -f ~/.bash_aliases ]; then
#    . ~/.bash_aliases
#fi

# enable color support of ls and also add handy aliases
if [ -x /usr/bin/dircolors ]; then
    eval "`dircolors -b`"
    alias ls='ls --color=auto'
    #alias dir='dir --color=auto'
    #alias vdir='vdir --color=auto'  
 
    #alias grep='grep --color=auto'
    #alias fgrep='fgrep --color=auto'
    #alias egrep='egrep --color=auto'
fi 

# some more ls aliases
#alias ll='ls -l'
#alias la='ls -A'
#alias l='ls -CF'

# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

Vegeu també:

~/.bash_logout

Aquest fitxer s'executa al finalitzar una sessió. Tingueu que només s'aplica al finalitzar correctament una sessió amb l'ordre logout (o amb l'ordre exit en un interpret d'ordres de login). Vegeu un exemple:

$ cd
$ joe ~/.bash_logout

Afegiu al principi la línia:


echo "sortint..."

Inicieu un nou interpret d'ordres de no-login:

$ bash 
$ logout
bash: logout: not login shell: use `exit'
$ exit
exit

Com podeu veure no es mostra el missatge "sortint..."

Ara inicieu un interpret d'ordres de login:

$ bash --login
$ logout
sortint...

Vegeu també:

/etc/shells

Conté una llista de shells de login vàlides:

$ cat /etc/shells 
# /etc/shells: valid login shells
/bin/csh
/usr/bin/es
/usr/bin/ksh
/bin/ksh
/usr/bin/rc
/usr/bin/tcsh
/bin/tcsh
/usr/bin/esh
/usr/bin/screen
/bin/sh
/bin/dash
/bin/bash
/bin/rbash
/bin/false

Consulteu:

$ man shells

I l'article login

Vegeu també

  • LPI_103.1. Treballar a la línia d'ordres
  • LPI_105.2. Adaptar o escriure guions de shell simples

Enllaços externs