ushchestvlyaet
vyzov funkcii <i>main</i>, nahodyashchejsya v drugoj programme, peredavaya  ej  svoi  argumenty  v
kachestve vhodnyh.
     Sistemnyj vyzov <i>exec</i> mozhet ne udat'sya, esli ukazannyj fajl path  ne  sushchestvuet,
libo  vy  ne  imeete  prava  ego  vypolnyat' (takie kody dostupa), libo on ne yavlyaetsya
vypolnyaemoj programmoj (nevernoe magicheskoe chislo), libo  slishkom  velik  dlya  dannoj
mashiny  (sistemy), libo fajl otkryt kakim-nibud' processom (naprimer eshche zapisyvaetsya
kompilyatorom).  V etom sluchae prodolzhitsya  vypolnenie  prezhnej  programmy.   Esli  zhe
vyzov  uspeshen  - vozvrata iz <i>exec</i> ne proishodit voobshche (poskol'ku upravlenie pereda-
etsya v druguyu programmu).
     Argument argv[0] obychno polagayut ravnym path.  Po nemu programma,  imeyushchaya  nes-
kol'ko  imen (v fajlovoj sisteme), mozhet vybrat' CHTO ona dolzhna delat'. Tak programma
<i>/bin/ls</i> imeet al'ternativnye imena <i>lr</i>, <i>lf</i>, <i>lx</i>, <i>ll</i>.  Zapuskaetsya odna i  ta  zhe  prog-
ramma, no v zavisimosti ot argv[0] ona dalee delaet raznuyu rabotu.
     Argument envp - eto "okruzhenie" programmy (sm.  nachalo etoj glavy).  Esli on  ne
zadan  -  peredaetsya  okruzhenie tekushchej programmy (nasleduetsya soderzhimoe massiva, na
kotoryj ukazyvaet peremennaya <i>environ</i>); esli zhe zadan yavno (naprimer, okruzhenie skopi-
rovano  v kakoj-to massiv i chast' peremennyh podpravlena ili dobavleny novye peremen-
nye) - novaya programma poluchit novoe okruzhenie.  Napomnim, chto okruzhenie  mozhno  pro-
chest' iz predopredelennoj peremennoj char **<i>environ</i>, libo iz tret'ego argumenta funk-
cii <i>main</i> (sm. nachalo glavy), libo funkciej <i>getenv</i>().




<i>A. Bogatyrev, 1992-95                  - 224 -                              Si v UNIX</i>

     Sistemnye vyzovy <i>fork</i> i <i>exec</i> ne skleeny v odin vyzov potomu, chto  mezhdu  <i>fork</i>  i
<i>exec</i>  v  processe-syne  mogut  proishodit'  nekotorye  dejstviya, narushayushchie simmetriyu
processa-otca i porozhdennogo processa: ustanovka reakcij na signaly,  perenapravlenie
vvoda/vyvoda, i.t.p. Smotri primer "interpretator komand" v prilozhenii.  V <i>MS DOS</i>, ne
imeyushchej parallel'nyh processov, vyzovy <i>fork</i>, <i>exec</i> i <i>wait</i> skleeny v odin vyzov  <i>spawn</i>.
Zato  pri  etom prihoditsya delat' perenapravleniya vvoda-vyvoda v porozhdayushchem processe
pered <i>spawn</i>, a posle nego - vosstanavlivat' vse kak bylo.

<i>6.5.4.</i>  Zavershit' process mozhno sistemnym vyzovom

    void <i>exit</i>( unsigned char retcode );

Iz etogo vyzova ne byvaet vozvrata. Process zavershaetsya: segmenty <i>stack</i>, <i>data</i>,  <i>text</i>,
<i>user</i>  unichtozhayutsya (pri etom vse otkrytye processom fajly zakryvayutsya); pamyat', koto-
ruyu oni zanimali, schitaetsya svobodnoj i v nee  mozhet  byt'  pomeshchen  drugoj  process.
Prichina  smerti otmechaetsya v pasporte processa - v strukture <i>proc</i> v tablice processov
vnutri yadra. No pasport  eshche  ne  unichtozhaetsya!  |to  sostoyanie  processa  nazyvaetsya
"zombi" - zhivoj mertvec.
     V pasport processa zanositsya kod otveta retcode.  |tot kod mozhet  byt'  prochitan
processom-roditelem  (tem, kto sozdal etot process vyzovom <i>fork</i>).  Prinyato, chto kod 0
oznachaet uspeshnoe zavershenie processa, a lyuboe polozhitel'noe znachenie 1..255 oznachaet
neudachnoe  zavershenie  s  takim kodom oshibki.  Kody oshibok zaranee ne predopredeleny:
eto lichnoe delo processov otca i syna - ustanovit' mezhdu soboj kakie-to soglasheniya po
etomu  povodu.   V  staryh programmah inogda pisalos' <i>exit</i>(-1); |to nekorrektno - kod
otveta dolzhen byt' neotricatelen; kod -1 prevrashchaetsya v kod 255.  CHasto  ispol'zuetsya
konstrukciya <i>exit</i>(errno);
     Programma mozhet zavershit'sya ne tol'ko yavno vyzyvaya <i>exit</i>, no i eshche  dvumya  sposo-
bami:
-    esli proishodit vozvrat upravleniya iz funkcii <i>main</i>(), t.e. ona  konchilas'  -  to
     vyzov <i>exit</i>() delaetsya neyavno, no s nepredskazuemym znacheniem retcode;
-    process mozhet byt' ubit signalom. V etom  sluchae  on  ne  vydaet  nikakogo  koda
     otveta v process-roditel', a vydaet priznak "process ubit".

<i>6.5.5.</i>  V dejstvitel'nosti <i>exit</i>() - eto eshche ne  sam  sistemnyj  vyzov  zaversheniya,  a
standartnaya  funkciya.   Sam sistemnyj vyzov nazyvaetsya _<i>exit</i>().  My mozhem pereoprede-
lit' funkciyu <i>exit</i>() tak, chtoby po okonchanii programmy proishodili nekotorye dejstviya:

    void <i>exit</i>(unsigned code){
      /* Dobavlennyj mnoj dopolnitel'nyj operator: */
      printf("Zakonchit' rabotu, "
             "kod otveta=%u\n", code);

      /* Standartnye operatory: */
      _<i>cleanup</i>();  /* zakryt' vse otkrytye fajly.
                    * |to standartnaya funkciya <i>|</i>= */
      _<i>exit</i>(code); /* sobstvenno sisvyzov */
    }

    int <i>f</i>(){ return 17; }
    void <i>main</i>(){
      printf("aaaa\n"); printf("bbbb\n"); <i>f</i>();
      /* potom otkommentirujte eto:  exit(77); */
    }

Zdes' funkciya <i>exit</i> vyzyvaetsya neyavno po okonchanii <i>main</i>, ee  podstavlyaet  v  programmu
kompilyator.  Delo  v  tom,  chto pri zapuske programmy <i>exec</i>-om, pervym nachinaet vypol-
nyat'sya kod tak nazyvaemogo "startera", podkleennogo pri  sborke  programmy  iz  fajla
<i>/lib/crt0.o</i>. On vyglyadit primerno tak (v dejstvitel'nosti on napisan na assemblere):

    ... // vychislit' argc, nastroit' nekotorye parametry.
    <i>main</i>(argc, argv, envp);
    <i>exit</i>();


<i>A. Bogatyrev, 1992-95                  - 225 -                              Si v UNIX</i>

ili tak (vzyato iz proekta <i>GNU|</i>-<i>|</i>-):

    int errno = 0;
    char **environ;
    _<i>start</i>(int argc, int arga)
    {
    /* OS and Compiler dependent!!!! */
    char **argv = (char **) &arga;
    char **envp = environ = argv + argc + 1;
    /* ... vozmozhno eshche kakie-to inicializacii,
     * napodobie <i>setlocale</i>( <i>LC</i>_<i>ALL</i>, "" ); v <i>SCO UNIX</i> */
    <i>exit</i> (<i>main</i>(argc, argv, envp));
    }

Gde dolzhno byt'

    <i>int main</i>(int argc, char *argv[], char *envp[]){
              ...
            <i>return</i> 0;  /* vmesto exit(0); */
    }

Adres funkcii _<i>start</i>() pomechaetsya v odnom iz polej zagolovka fajla formata <i>a.out</i>  kak
adres,  na  kotoryj  sistema  dolzhna  peredat'  upravlenie posle zagruzki programmy v
pamyat' (tochka vhoda).
     Kakoj kod otveta popadet v <i>exit</i>() v etih primerah (esli otsutstvuet yavnyj  vyzov
<i>exit</i> ili <i>return</i>) - nepredskazuemo.  Na <i>IBM PC</i> v vyshenapisannom primere etot kod raven
17, to est' znacheniyu, vozvrashchennomu poslednej vyzyvavshejsya funkciej.  Odnako  eto  ne
kakoe-to  special'noe soglashenie, a sluchajnyj effekt (tak uzh ustroen kod, sozdavaemyj
etim kompilyatorom).

<i>6.5.6.</i>  Process-otec mozhet dozhdat'sya okonchaniya svoego potomka.  |to delaetsya  sistem-
nym vyzovom <i>wait</i> i nuzhno po sleduyushchej prichine: pust' otec - eto interpretator komand.
Esli on zapustil process i prodolzhil svoyu rabotu, to oba processa budut predprinimat'
popytki  chitat' vvod s klaviatury terminala - interpretator zhdet komand, a zapushchennaya
programma zhdet dannyh.  Komu iz nih budet postupat' nabiraemyj nami tekst -  nepreds-
kazuemo!   Vyvod:  interpretator  komand  dolzhen "zasnut'" na to vremya, poka rabotaet
porozhdennyj im process:

    int pid;  unsigned short status;
             ...
    if((pid = <i>fork</i>()) == 0 ){
            /* porozhdennyj process */
             ...  // perenapravleniya vvoda-vyvoda.
             ...  // nastrojka signalov.
            <i>exec</i>(....);
            perror("exec ne udalsya"); exit(1);
    }
    /* inache eto porodivshij process */
    while((pid = <i>wait</i>(&status)) > 0 )
      printf("Okonchilsya syn pid=%d s kodom %d\n",
              pid, status >> 8);
    printf( "Bol'she net synovej\n");


____________________
   <i>|</i>= _<i>cleanup</i>() zakryvaet fajly, otkrytye <i>fopen</i>()om, "vytryahaya" pri etom dannye,  na-
koplennye v buferah, v fajl.  Pri avarijnom zavershenii programmy fajly vse ravno zak-
ryvayutsya, no uzhe ne yavno, a operacionnoj sistemoj (v vyzove _<i>exit</i>).  Pri etom  soder-
zhimoe nedosbroshennyh buferov budet uteryano.
____________________
   <i>|</i>-<i>|</i>- <i>GNU</i> - programmy, rasprostranyaemye v ishodnyh tekstah iz <i>Free  Software  Founda-</i>



<i>A. Bogatyrev, 1992-95                  - 226 -                              Si v UNIX</i>

<i>wait</i> priostanavlivaet<i>|</i>- vypolnenie vyzvavshego processa do momenta okonchaniya lyubogo  iz
porozhdennyh  im  processov  (ved'  mozhno  bylo zapustit' i neskol'kih synovej!).  Kak
tol'ko kakoj-to potomok okonchitsya  -  <i>wait</i>  prosnetsya  i  vydast  nomer  (pid)  etogo
potomka.   Kogda  nikogo  iz zhivyh "synovej" ne ostalos' - on vydast (-1).  YAsno, chto
processy mogut okanchivat'sya ne v tom poryadke, v kotorom ih porozhdali.   V  peremennuyu
status  zanositsya  v  special'nom  vide kod otveta okonchivshegosya processa, libo nomer
signala, kotorym on byl ubit.

    #include &lt;sys/types.h>
    #include &lt;sys/wait.h>
            ...
    int status, pid;
            ...
    while((pid = <i>wait</i>(&status)) > 0){
        if( <i>WIFEXITED</i>(status)){
          printf( "Process %d umer s kodom %d\n",
                           pid,            <i>WEXITSTATUS</i>(status));
        } else if( <i>WIFSIGNALED</i>(status)){
          printf( "Process %d ubit signalom %d\n",
                           pid,             <i>WTERMSIG</i>(status));
          if(<i>WCOREDUMP</i>(status)) printf( "Obrazovalsya core\n" );
          /* core - obraz pamyati processa dlya otladchika adb */
        } else if( <i>WIFSTOPPED</i>(status)){
          printf( "Process %d ostanovlen signalom %d\n",
                           pid,            <i>WSTOPSIG</i>(status));
        } else if( <i>WIFCONTINUED</i>(status)){
          printf( "Process %d prodolzhen\n",
                           pid);
        }
    }
            ...

Esli kod otveta nas ne interesuet, my mozhem pisat' <i>wait</i>(NULL).
     Esli u nashego processa ne bylo ili bol'she net zhivyh synovej - vyzov <i>wait</i>  nichego
ne  zhdet, a vozvrashchaet znachenie (-1).  V napisannom primere cikl <i>while</i> pozvolyaet dozh-
dat'sya okonchaniya vseh potomkov.
     V tot moment, kogda process-otec poluchaet informaciyu o prichine  smerti  potomka,
pasport  umershego  processa  nakonec  vycherkivaetsya iz tablicy processov i mozhet byt'
pereispol'zovan novym processom.  Do togo, on hranitsya v tablice processov v  sostoya-
nii  "zombie"  - "zhivoj mertvec".  Tol'ko dlya togo, chtoby kto-nibud' mog uzat' status
ego zaversheniya.
     Esli process-otec zavershilsya ran'she svoih synovej, to  kto  zhe  sdelaet  <i>wait</i>  i
vycherknet  pasport?   |to  sdelaet process nomer 1: <i>/etc/init</i>.  Esli otec umer ran'she
processov-synovej, to sistema zastavlyaet process nomer 1  "usynovit'"  eti  processy.
<i>init</i>  obychno  nahoditsya  v  cikle,  soderzhashchem v nachale vyzov <i>wait</i>(), to est' ozhidaet
____________________
<i>tion</i>  (FSF).  Sredi nih - <i>C++</i> kompilyator <i>g++</i> i redaktor <i>emacs</i>. Smysl slov <i>GNU</i> - "gen-
erally not <i>UNIX</i>" - proekt byl osnovan kak protivodejstvie nachavshejsya kommercializacii
<i>UNIX</i> i zakrytiyu ego ishodnyh tekstov. "Sdelat' kak v <i>UNIX</i>, no luchshe".
   <i>|</i>- "ZHivoj" process mozhet prebyvat' v odnom iz neskol'kih sostoyanij: process ozhidaet
nastupleniya  kakogo-to sobytiya ("spit"), pri etom emu ne vydelyaetsya vremya processora,
t.k. on ne gotov k vypolneniyu; process gotov k vypolneniyu i stoit v ocheredi k proces-
soru (poskol'ku processor vypolnyaet drugoj process); process gotov i vypolnyaetsya pro-
cessorom v dannyj moment.  Poslednee sostoyanie mozhet proishodit'  v  dvuh  rezhimah  -
pol'zovatel'skom (vypolnyayutsya komandy segmenta <i>text</i>) i sistemnom (processom byl izdan
sistemnyj vyzov, i sejchas vypolnyaetsya funkciya v yadre). Ozhidanie sobytiya byvaet tol'ko
v  sistemnoj faze - vnutri sistemnogo vyzova (t.e.  eto "sinhronnoe" ozhidanie). Neak-
tivnye processy ("spyashchie" ili zhdushchie resursa processora) mogut byt' vremenno otkachany
na disk.





<i>A. Bogatyrev, 1992-95                  - 227 -                              Si v UNIX</i>

okonchaniya lyubogo iz svoih synovej (a oni u nego vsegda est', o chem my pogovorim  pod-
robnee  chut'  pogodya).  Takim obrazom <i>init</i> zanimaetsya chistkoj tablicy processov, hotya
eto ne edinstvennaya ego funkciya.
     Vot shema, poyasnyayushchaya zhiznennyj cikl lyubogo processa:

        |pid=719,<i>csh</i>
        |
    if(!<i>fork</i>())------->--------* pid=723,<i>csh</i>
        |                      |                  zagruzit'
     <i>wait</i>(&status)           <i>exec</i>("a.out",...) &lt;-- <i>a.out</i>
        :                    main(...){           s diska
        :                      |
        :pid=719,<i>csh</i>           | pid=723,<i>a.out</i>
      spit(zhdet)             rabotaet
        :                      |
        :                    <i>exit</i>(status) umer
        :                    }
     prosnulsya &lt;---prosnis'!--RIP
        |
        |pid=719,<i>csh</i>

Zamet'te, chto nomer porozhdennogo processa ne obyazan byt' sleduyushchim za  nomerom  rodi-
telya,  a  tol'ko  bol'she nego. |to svyazano s tem, chto drugie processy mogli sozdat' v
sisteme novye processy do togo, kak nash process izdal svoj vyzov <i>fork</i>.

<i>6.5.7.</i>  Krome togo, <i>wait</i> pozvolyaet otslezhivat'  ostanovku  processa.   Process  mozhet
byt'  priostanovlen  pri  pomoshchi  posylki  emu  signalov  <i>SIGSTOP</i>,  <i>SIGTTIN</i>, <i>SIGTTOU</i>,
<i>SIGTSTP</i>.  Poslednie tri signala posylaet  pri  opredelennyh  obstoyatel'stvah  drajver
terminala,  k  primeru  <i>SIGTSTP</i>  -  pri nazhatii klavishi <i>CTRL/Z</i>.  Prodolzhaetsya process
posylkoj emu signala <i>SIGCONT</i>.
     V dannom kontekste, odnako, nas interesuyut ne sami eti signaly, a  drugaya  shema
manipulyacii  s  otslezhivaniem statusa porozhdennyh processov.  Esli ukazano yavno, sis-
tema mozhet posylat' processu-roditelyu signal <i>SIGCLD</i> v moment izmeneniya statusa lyubogo
iz ego potomkov.  |to pozvolit processu-roditelyu nemedlenno sdelat' <i>wait</i> i nemedlenno
otrazit' izmenenie sostoyanie processa-potomka v  svoih  vnutrennih  spiskah.   Dannaya
shema programmiruetsya tak:

    void <i>pchild</i>(){
            int pid, status;

            <i>sighold</i>(<i>SIGCLD</i>);
            while((pid = <i>waitpid</i>((pid_t) -1, &status, <i>WNOHANG</i>|<i>WUNTRACED</i>)) > 0){
              dorecord:
                    zapisat'_informaciyu_ob_izmeneniyah;
            }
            <i>sigrelse</i>(<i>SIGCLD</i>);

            /* Reset */
            <i>signal</i>(<i>SIGCLD</i>, <i>pchild</i>);
    }
            ...
    <i>main</i>(){
            ...
            /* Po signalu <i>SIGCLD</i> vyzyvat' funkciyu <i>pchild</i> */
            <i>signal</i>(<i>SIGCLD</i>, <i>pchild</i>);
            ...
            glavnyj_cikl;
    }

Sekciya  s  vyzovom  <i>waitpid</i>  (raznovidnost'  vyzova  <i>wait</i>),  prikryta  paroj  funkcij
<i>sighold</i>-<i>sigrelse</i>,  zapreshchayushchih  prihod signala <i>SIGCLD</i> vnutri etoj kriticheskoj sekcii.



<i>A. Bogatyrev, 1992-95                  - 228 -                              Si v UNIX</i>

Sdelano eto vot dlya chego: esli process nachnet modificirovat'  tablicy  ili  spiski  v
rajone  metki  dorecord:,  a  v etot moment pridet eshche odin signal, to funkciya <i>pchild</i>
budet vyzvana rekursivno i tozhe popytaetsya modificirovat' tablicy i spiski, v kotoryh
eshche ostalis' nezavershennymi perestanovki ssylok, elementov, schetchikov. |to privedet k
razrusheniyu dannyh.
     Poetomu signaly dolzhny prihodit' posledovatel'no, i  funkcii  <i>pchild</i>  vyzyvat'sya
takzhe  posledovatel'no, a ne rekursivno. Funkciya <i>sighold</i> otkladyvaet dostavku signala
(esli on sluchitsya), a <i>sigrelse</i> - razreshaet dostavit' nakopivshiesya signaly (no esli ih
prishlo  neskol'ko  odnogo tipa - vse oni dostavlyayutsya kak odin takoj signal. Otsyuda -
cikl vokrug <i>waitpid</i>).
     Flag <i>WNOHANG</i> - oznachaet "ne zhdat' vnutri vyzova <i>wait</i>", esli ni odin iz  potomkov
ne  izmenil  svoego  sostoyaniya;  a  prosto vernut' kod (-1)".  |to pozvolyaet vyzyvat'
<i>pchild</i> dazhe bez polucheniya signala: nichego ne proizojdet.  Flag <i>WUNTRACED</i>  -  oznachaet
"vydavat' informaciyu takzhe ob ostanovlennyh processah".

<i>6.5.8.</i>  Kak uzhe bylo skazano, pri <i>exec</i> vse  otkrytye  fajly  dostayutsya  v  nasledstvo
novoj programme (v chastnosti, esli mezhdu <i>fork</i> i <i>exec</i> byli perenapravleny vyzovom <i>dup2</i>
standartnye vvod i vyvod, to oni ostanutsya perenapravlennymi i  u  novoj  programmy).
CHto  delat',  esli  my  ne  hotim,  chtoby  nasledovalis' vse otkrytye fajly? (Hotya by
potomu, chto bol'shinstvom iz nih novaya programma pol'zovat'sya ne budet  -  v  osnovnom
ona  budet ispol'zovat' lish' fd 0, 1 i 2; a yachejki v tablice otkrytyh fajlov processa
oni zanimayut).  Vo-pervyh, nenuzhnye deskriptory mozhno yavno zakryt' <i>close</i> v promezhutke
mezhdu  <i>fork</i>-om  i  <i>exec</i>-om.   Odnako ne vsegda my pomnim nomera deskriptorov dlya etoj
operacii.  Bolee radikal'noj meroj yavlyaetsya total'naya chistka:

    for(f = 3; f &lt; NOFILE; f++)
            close(f);

Est' bolee elegantnyj put'.  Mozhno  pometit'  deskriptor  fajla  special'nym  flagom,
oznachayushchim, chto vo vremya vyzova <i>exec</i> etot deskriptor dolzhen byt' avtomaticheski zakryt
(rezhim file-close-on-exec - <i>fclex</i>):

    #include &lt;fcntl.h>
    int fd = <i>open</i>(.....);
    <i>fcntl</i> (fd, <i>F</i>_<i>SETFD</i>, 1);

Otmenit' etot rezhim mozhno tak:

    <i>fcntl</i> (fd, <i>F</i>_<i>SETFD</i>, 0);

Zdes' est' odna tonkost': etot flag ustanavlivaetsya ne dlya struktury <i>file</i> - "otkrytyj
fajl",  a neposredstvenno dlya deskriptora v tablice otkrytyh processom fajlov (massiv
flagov: char u_pofile[NOFILE]).  On ne sbrasyvaetsya pri zakrytii fajla,  poetomu  nas
mozhet ozhidat' syurpriz:

     ... <i>fcntl</i> (fd, F_SETFD, 1); ... <i>close</i>(fd);
     ...
     int fd1 = <i>open</i>( ... );

Esli fd1 okazhetsya ravnym fd, to deskriptor fd1 budet pri <i>exec</i>-e zakryt, chego my  yavno
ne ozhidali! Poetomu pered <i>close</i>(fd) polezno bylo by otmenit' rezhim <i>fclex</i>.

<i>6.5.9.</i>  Kazhdyj process imeet upravlyayushchij terminal (short *u_ttyp).  On dostaetsya pro-
cessu  v  nasledstvo ot roditelya (pri <i>fork</i> i <i>exec</i>) i obychno sovpadaet s terminalom, s
na kotorom rabotaet dannyj pol'zovatel'.
     Kazhdyj process otnositsya k nekotoroj  gruppe  processov  (int  p_pgrp),  kotoraya
takzhe nasleduetsya. Mozhno poslat' signal vsem processam ukazannoj gruppy pgrp:
    <i>kill</i>( -pgrp, sig );
Vyzov
    <i>kill</i>( 0, sig );
posylaet signal sig vsem  processam,  ch'ya  gruppa  sovpadaet  s  gruppoj  posylayushchego



<i>A. Bogatyrev, 1992-95                  - 229 -                              Si v UNIX</i>

processa.  Process mozhet uznat' svoyu gruppu:
    int pgrp = <i>getpgrp</i>();
a mozhet stat' "liderom" novoj gruppy. Vyzov
    <i>setpgrp</i>();
delaet sleduyushchie operacii:

    /* U processa bol'she net upravl. terminala: */
    if(p_pgrp != p_pid) u_ttyp = NULL;
    /* Gruppa processa polagaetsya ravnoj ego id-u: */
    p_pgrp = p_pid;  /* new group */

V svoyu ochered', upravlyayushchij terminal tozhe imeet nekotoruyu gruppu (t_pgrp). |to znache-
nie ustanavlivaetsya ravnym gruppe processa, pervym otkryvshego etot terminal:

    /* chast' procedury otkrytiya terminala */
    if( p_pid == p_pgrp // lider gruppy
     && u_ttyp == NULL  // eshche net upr.term.
     && t_pgrp == 0 ){  // u terminala net gruppy
            u_ttyp = &t_pgrp;
            t_pgrp =  p_pgrp;
    }

Takim processom obychno yavlyaetsya process registracii pol'zovatelya v  sisteme  (kotoryj
sprashivaet  u vas imya i parol').  Pri zakrytii terminala vsemi processami (chto byvaet
pri vyhode pol'zovatelya iz sistemy) terminal teryaet gruppu: t_pgrp=0;
     Pri nazhatii na klaviature terminala nekotoryh klavish:

    c_cc[ <i>VINTR</i> ]     obychno DEL ili CTRL/C
    c_cc[ <i>VQUIT</i> ]     obychno CTRL/\

drajver terminala posylaet sootvetstvenno signaly <i>SIGINT</i>  i  <i>SIGQUIT</i>  vsem  processam
gruppy terminala, t.e. kak by delaet
    <i>kill</i>( -t_pgrp, sig );
Imenno poetomu my mozhem prervat' process nazhatiem klavishi <i>DEL</i>.  Poetomu, esli process
sdelal  <i>setpgrp</i>(),  to signal s klaviatury emu poslat' nevozmozhno (t.k. on imeet svoj
unikal'nyj nomer gruppy != gruppe terminala).
     Esli process eshche ne imeet upravlyayushchego terminala (ili uzhe  ego  ne  imeet  posle
<i>setpgrp</i>),  to on mozhet sdelat' lyuboj terminal (kotoryj on imeet pravo otkryt') uprav-
lyayushchim dlya sebya.  Pervyj zhe fajl-ustrojstvo, yavlyayushchijsya interfejsom drajvera termina-
lov, kotoryj budet otkryt etim processom, stanet dlya nego upravlyayushchim terminalom. Tak
process mozhet imet' kanaly 0, 1, 2 svyazannye s odnim terminalom, a  preryvaniya  polu-
chat' s klaviatury drugogo (kotoryj on sdelal upravlyayushchim dlya sebya).
     Process registracii pol'zovatelya v sisteme - <i>/etc/getty</i> (nazvanie proishodit  ot
"get  tty"  -  poluchit' terminal) - zapuskaetsya processom nomer 1 - <i>/etc/init</i>-om - na
kazhdom iz terminalov, zaregistrirovannyh v sisteme, kogda
-    sistema tol'ko chto byla zapushchena;
-    libo kogda pol'zovatel' na kakom-to terminale vyshel  iz  sistemy  (interpretator
     komand zavershilsya).
V sil'nom uproshchenii <i>getty</i> mozhet byt' opisan tak:

    void <i>main</i>(ac, av) char *av[];
    {   int f; struct termio tmodes;

        for(f=0; f &lt; NOFILE; f++) <i>close</i>(f);

        /* Otkaz ot upravlyayushchego terminala,
         * osnovanie novoj gruppy processov.
         */
        <i>setpgrp</i>();

        /* Pervonachal'noe yavnoe otkrytie terminala */



<i>A. Bogatyrev, 1992-95                  - 230 -                              Si v UNIX</i>

        /* Pri etom terminal av[1] stanet upr. terminalom */
            <i>open</i>( av[1], O_RDONLY ); /* fd = 0 */
            <i>open</i>( av[1], O_RDWR   ); /* fd = 1 */
         f = <i>open</i>( av[1], O_RDWR   ); /* fd = 2 */

        // ... Schityvanie parametrov terminala iz fajla
        // <i>/etc/gettydefs</i>. Tip trebuemyh parametrov linii
        // zadaetsya metkoj, ukazyvaemoj v av[2].
        // Zapolnenie struktury tmodes trebuemymi
        // znacheniyami ... i ustanovka mod terminala.
        <i>ioctl</i> (f, TCSETA, &tmodes);

        // ... zapros imeni i parolya ...

        <i>chdir</i> (domashnij_katalog_pol'zovatelya);

        <i>execl</i> ("/bin/csh", "-csh", NULL);
        /* Zapusk interpretatora komand. Gruppa processov,
         * upravl. terminal, deskriptory 0,1,2 nasleduyutsya.
         */
    }

Zdes' posledovatel'nye vyzovy <i>open</i> zanimayut posledovatel'nye yachejki v tablice  otkry-
tyh  processom fajlov (poisk kazhdoj novoj nezanyatoj yachejki proizvoditsya s nachala tab-
licy) - v itoge po deskriptoram 0,1,2 otkryvaetsya fajl-terminal.  Posle  etogo  desk-
riptory 0,1,2 nasleduyutsya vsemi potomkami interpretatora komand.  Process <i>init</i> zapus-
kaet po odnomu processu <i>getty</i> na kazhdyj terminal, kak by delaya

            <i>/etc/getty</i> /dev/tty01 m &
            <i>/etc/getty</i> /dev/tty02 m &
                    ...

i ozhidaet okonchaniya lyubogo iz nih.  Posle vhoda pol'zovatelya v  sistemu  na  kakom-to
terminale,  sootvetstvuyushchij  <i>getty</i>  prevrashchaetsya v interpretator komand (pid processa
sohranyaetsya).  Kak tol'ko kto-to iz nih umret - <i>init</i> perezapustit <i>getty</i> na sootvetst-
vuyushchem  terminale  (vse  oni - ego synov'ya, poetomu on znaet - na kakom imenno termi-
nale).

        6.6.  Truby i FIFO-fajly.
     Processy mogut obmenivat'sya mezhdu  soboj  informaciej  cherez  fajly.  Sushchestvuyut
fajly s neobychnym povedeniem - tak nazyvaemye <i>FIFO</i>-fajly (first in, first out), vedu-
shchie sebya podobno ocheredi. U nih ukazateli chteniya i zapisi razdeleny. Rabota  s  takim
fajlom napominaet protalkivanie sharov cherez trubu - s odnogo konca my vtalkivaem dan-
nye, s drugogo konca - vynimaem ih.  Operaciya chteniya iz pustoj "truby"  proiostanovit
vyzov  <i>read</i>  (i  izdavshij ego process) do teh por, poka kto-nibud' ne zapishet v FIFO-
fajl kakie-nibud' dannye.  Operaciya pozicionirovaniya ukazatelya - <i>lseek</i>()  -  neprime-
nima k FIFO-fajlam.  FIFO-fajl sozdaetsya sistemnym vyzovom

    #include &lt;sys/types.h>
    #include &lt;sys/stat.h>
       <i>mknod</i>( imyaFajla, <i>S</i>_<i>IFIFO</i> | 0666, 0 );

gde 0666 - kody dostupa k fajlu.  Pri pomoshchi FIFO-fajla mogut obshchat'sya dazhe  nerodst-
vennye processy.
     Raznovidnost'yu FIFO-fajla yavlyaetsya  bezymyannyj  FIFO-fajl,  prednaznachennyj  dlya
obmena informaciej mezhdu processom-otcom i processom-synom.  Takoj fajl - kanal svyazi
kak raz i nazyvaetsya terminom "truba" ili <i>pipe</i>.  On sozdaetsya vyzovom <i>pipe</i>:

    int conn[2];   <i>pipe</i>(conn);

Esli by fajl-truba imel imya PIPEFILE, to vyzov <i>pipe</i> mozhno bylo by opisat' kak



<i>A. Bogatyrev, 1992-95                  - 231 -                              Si v UNIX</i>

    <i>mknod</i>("PIPEFILE", <i>S</i>_<i>IFIFO</i> | 0600, 0);
    conn[0] = <i>open</i>("PIPEFILE", <i>O</i>_<i>RDONLY</i>);
    conn[1] = <i>open</i>("PIPEFILE", <i>O</i>_<i>WRONLY</i>);
    <i>unlink</i>("PIPEFILE");

Pri vyzove <i>fork</i> kazhdomu iz dvuh processov dostanetsya v nasledstvo para deskriptorov:

                 <i>pipe</i>(conn);
                   <i>fork</i>();

    conn[0]----&lt;----    ----&lt;-----conn[1]
                    FIFO
    conn[1]---->----    ---->-----conn[0]
     process A                 process B

Pust' process <i>A</i> budet posylat' informaciyu v process <i>B</i>.  Togda process <i>A</i> sdelaet:

    <i>close</i>(conn[0]);
    // t.k. ne sobiraetsya nichego chitat'
    <i>write</i>(conn[1], ... );

a process <i>B</i>

    <i>close</i>(conn[1]);
    // t.k. ne sobiraetsya nichego pisat'
    <i>read</i> (conn[0], ... );

Poluchaem v itoge:

    conn[1]---->----FIFO---->-----conn[0]
     process A                 process B

Obychno postupayut eshche bolee elegantno,  perenapravlyaya  standartnyj  vyvod  <i>A</i>  v  kanal
conn[1]

    <i>dup2</i> (conn[1], 1); <i>close</i>(conn[1]);
    <i>write</i>(1, ... );   /* ili printf */

a standartnyj vvod <i>B</i> - iz kanala conn[0]

    <i>dup2</i>(conn[0], 0); <i>close</i>(conn[0]);
    <i>read</i>(0, ... );    /* ili gets */

|to sootvetstvuet konstrukcii

         $   <i>A</i> | <i>B</i>

zapisannoj na yazyke SiSHell.
     Fajl, vydelyaemyj pod <i>pipe</i>, imeet ogranichennyj razmer (i poetomu  obychno  celikom
osedaet  v buferah v pamyati mashiny).  Kak tol'ko on zapolnen celikom - process, pishu-
shchij v trubu vyzovom <i>write</i>, priostanavlivaetsya do poyavleniya svobodnogo mesta v  trube.
|to  mozhet privesti k vozniknoveniyu tupikovoj situacii, esli pisat' programmu neakku-
ratno.  Pust' process <i>A</i> yavlyaetsya synom processa <i>B</i>, i pust'  process  <i>B</i>  izdaet  vyzov
<i>wait</i>,  ne  zakryv kanal conn[0].  Process zhe <i>A</i> ochen' mnogo pishet v trubu conn[1].  My
poluchaem situaciyu, kogda oba processa spyat:
<i>A</i>    potomu chto truba perepolnena, a process <i>B</i> nichego iz nee ne chitaet, tak kak  zhdet
     okonchaniya <i>A</i>;
<i>B</i>    potomu chto process-syn <i>A</i> ne okonchilsya, a on ne mozhet okonchit'sya poka ne  dopishet
     svoe soobshchenie.
Resheniem sluzhit zapret processu <i>B</i> delat' vyzov <i>wait</i> do teh por, poka on ne  prochitaet
VSYU  informaciyu  iz truby (ne poluchit EOF). Tol'ko sdelav posle etogo <i>close</i>(conn[0]);



<i>A. Bogatyrev, 1992-95                  - 232 -                              Si v UNIX</i>

process <i>B</i> imeet pravo sdelat' <i>wait</i>.
     Esli process <i>B</i> zakroet svoyu storonu truby <i>close</i>(conn[0]) prezhde, chem  process  <i>A</i>
zakonchit  zapis'  v nee, to pri vyzove <i>write</i> v processe <i>A</i>, sistema prishlet processu <i>A</i>
signal <i>SIGPIPE</i> - "zapis' v kanal, iz kotorogo nikto ne chitaet".

<i>6.6.1.</i>  Otkrytie <i>FIFO</i> fajla privedet k blokirovaniyu processa  ("zasypaniyu"),  esli  v
bufere  <i>FIFO</i> fajla pusto. Process zasnet vnutri vyzova <i>open</i> do teh por, poka v bufere
chto-nibud' ne poyavitsya.
     CHtoby izbezhat' takoj situacii, a, naprimer, sdelat' chto-nibud' inoe  poleznoe  v
eto  vremya,  nam  nado  bylo by oprosit' fajl na predmet togo - mozhno li ego otkryt'?
|to delaetsya pri pomoshchi flaga <i>O</i>_<i>NDELAY</i> u vyzova <i>open</i>.

    int fd = <i>open</i>(filename, <i>O</i>_<i>RDONLY</i>|<i>O</i>_<i>NDELAY</i>);

Esli <i>open</i> vedet k blokirovke processa vnutri vyzova, vmesto  etogo  budet  vozvrashcheno
znachenie  (-1).  Esli  zhe fajl mozhet byt' nemedlenno otkryt - vozvrashchaetsya normal'nyj
deskriptor so znacheniem >=0, i fajl otkryt.
     <i>O</i>_<i>NDELAY</i> yavlyaetsya zavisimym ot semantiki togo fajla, kotoryj  my  otkryvaem.   K
primeru,  mozhno  ispol'zovat'  ego  s fajlami ustrojstv, naprimer imenami, vedushchimi k
posledovatel'nym portam. |ti fajly ustrojstv  (porty)  obladayut  tem  svojstvom,  chto
odnovremenno  ih  mozhet  otkryt' tol'ko odin process (tak ustroena realizaciya funkcii
<i>open</i> vnutri drajvera etih ustrojstv). Poetomu, esli odin process uzhe rabotaet s  por-
tom,  a  v  eto  vremya vtoroj pytaetsya ego zhe otkryt', vtoroj "zasnet" vnutri <i>open</i>, i
budet dozhidat'sya osvobozhdeniya porta <i>close</i> pervym processom.  CHtoby ne zhdat' - sleduet
otkryvat' port s flagom <i>O</i>_<i>NDELAY</i>.

    #include &lt;stdio.h>
    #include &lt;fcntl.h>

    /* Ubrat' bol'she ne nuzhnyj O_NDELAY */
    void nondelay(int fd){
            fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NDELAY);
    }
    int main(int ac, char *av[]){
            int fd;
            char *port = ac > 1 ? "/dev/term/a" : "/dev/cua/a";


    retry:  if((fd = open(port, O_RDWR|O_NDELAY)) &lt; 0){
                    perror(port);
                    sleep(10);
                    goto retry;
            }
            printf("Port %s otkryt.\n", port);
            nondelay(fd);

            printf("Rabota s portom, vyzovi etu programmu eshche raz!\n");
            sleep(60);
            printf("Vse.\n");
            return 0;
    }

Vot protokol:











<i>A. Bogatyrev, 1992-95                  - 233 -                              Si v UNIX</i>

    su# a.out & a.out xxx
    [1] 22202
    Port /dev/term/a otkryt.
    Rabota s portom, vyzovi etu programmu eshche raz!
    /dev/cua/a: Device busy
    /dev/cua/a: Device busy
    /dev/cua/a: Device busy
    /dev/cua/a: Device busy
    /dev/cua/a: Device busy
    /dev/cua/a: Device busy
    Vse.
    Port /dev/cua/a otkryt.
    Rabota s portom, vyzovi etu programmu eshche raz!
    su#


        6.7.  Nelokal'nyj perehod.
     Teper' pogovorim pro nelokal'nyj perehod. Standartnaya funkciya  <i>setjmp</i>  pozvolyaet
ustanovit' v programme "kontrol'nuyu tochku"<i>|</i>-, a funkciya <i>longjmp</i> osushchestvlyaet pryzhok  v
etu  tochku,  vypolnyaya  za  odin raz vyhod srazu iz neskol'kih vyzvannyh funkcij (esli
nado)<i>|</i>=.  |ti funkcii ne yavlyayutsya sistemnymi vyzovami, no  poskol'ku  oni  realizuyutsya
mashinno-zavisimym obrazom, a ispol'zuyutsya chashche vsego kak reakciya na nekotoryj signal,
rech' o nih idet v etom razdele.  Vot kak, naprimer,  vyglyadit  restart  programmy  po
preryvaniyu s klaviatury:

    #include &lt;signal.h>
    #include &lt;setjmp.h>
    <i>jmp</i>_<i>buf</i> jmp;  /* kontrol'naya tochka */

    /* prygnut' v kontrol'nuyu tochku */
    void <i>onintr</i>(nsig){ <i>longjmp</i>(jmp, nsig); }

    main(){
       int n;
       n = <i>setjmp</i>(jmp);  /* ustanovit' kontrol'nuyu tochku */
       if( n ) printf( "Restart posle signala %d\n", n);
       <i>signal</i> (<i>SIGINT</i>, onintr);     /* reakciya na signal */
       printf("Nachali\n");
       ...
    }

<i>setjmp</i> vozvrashchaet 0 pri zapominanii kontrol'noj  tochki.   Pri  pryzhke  v  kontrol'nuyu
tochku  pri pomoshchi <i>longjmp</i>, my okazyvaemsya snova v funkcii <i>setjmp</i>, i eta funkciya vozv-
rashchaet nam znachenie vtorogo argumenta <i>longjmp</i>, v etom primere - nsig.
     Pryzhok v kontrol'nuyu tochku ochen' udobno ispol'zovat'  v  algoritmah  perebora  s
vozvratom  (backtracking): libo - esli otvet najden - pryzhok na pechat' otveta, libo -
esli vetv' perebora zashla v tupik - pryzhok v tochku vetvleniya i vybor drugoj al'terna-
tivy.  Pri etom mozhno delat' pryzhki i v rekursivnyh vyzovah odnoj i toj zhe funkcii: s
bolee vysokogo urovnya rekursii v vyzov bolee nizkogo urovnya (v  etom  sluchae  <i>jmp</i>_<i>buf</i>
luchshe delat' avtomaticheskoj peremennoj - svoej dlya kazhdogo urovnya vyzova funkcii).


____________________
   <i>|</i>- V nekotorom bufere zapominaetsya tekushchee sostoyanie  processa:  polozhenie  vershiny
steka  vyzovov  funkcij (stack pointer); sostoyanie vseh registrov processora, vklyuchaya
registr adresa tekushchej mashinnoj komandy (instruction pointer).
   <i>|</i>= |to dostigaetsya vosstanovleniem sostoyaniya processa iz bufera. Izmeneniya,  prois-
shedshie  za  vremya mezhdu <i>setjmp</i> i <i>longjmp</i> v staticheskih dannyh ne otmenyayutsya (t.k. oni
ne sohranyalis').





<i>A. Bogatyrev, 1992-95                  - 234 -                              Si v UNIX</i>

<i>6.7.1.</i>  Perepishite sleduyushchij algoritm pri pomoshchi <i>longjmp</i>.

    #define FOUND    1 /* otvet najden    */
    #define NOTFOUND 0 /* otvet ne najden */
    int value;         /* rezul'tat */
    main(){    int i;
      for(i=2; i &lt; 10; i++){
          printf( "probuem i=%d\n", i);
          if( test1(i) == FOUND ){
              printf("otvet %d\n", value); break;
          }
      }
    }
    test1(i){  int j;
      for(j=1; j &lt; 10 ; j++ ){
          printf( "probuem j=%d\n", j);
          if( test2(i,j) == FOUND ) return FOUND;
          /* "skvoznoj" return */
      }
      return NOTFOUND;
    }
    test2(i, j){
      printf( "probuem(%d,%d)\n", i, j);
      if( i * j == 21 ){
          printf( "  Godyatsya (%d,%d)\n", i,j);
          value = j; return FOUND;
      }
      return NOTFOUND;
    }

Vot otvet, ispol'zuyushchij nelokal'nyj perehod vmesto cepochki <i>return</i>-ov:

    #include &lt;setjmp.h>
    jmp_buf jmp;
    main(){   int i;
      if( i = setjmp(jmp))  /* posle pryzhka */
            printf("Otvet %d\n", --i);
      else  /* ustanovka tochki */
        for(i=2; i &lt; 10; i++)
          printf( "probuem i=%d\n", i), test1(i);
    }
    test1(i){ int j;
      for(j=1; j &lt; 10 ; j++ )
          printf( "probuem j=%d\n", j), test2(i,j);
    }
    test2(i, j){
      printf( "probuem(%d,%d)\n", i, j);
      if( i * j == 21 ){
         printf( "  Godyatsya (%d,%d)\n", i,j);
         longjmp(jmp, j + 1);
      }
    }

Obratite vnimanie, chto pri vozvrate otveta cherez vtoroj argument <i>longjmp</i> my pribavili
1,  a  pri  pechati  otveta  my etu edinicu otnyali. |to sdelano na sluchaj otveta j==0,
chtoby funkciya <i>setjmp</i> ne vernula by v etom sluchae znachenie 0 (priznak ustanovki  kont-
rol'noj tochki).

<i>6.7.2.</i>  V chem oshibka?

    #include &lt;setjmp.h>



<i>A. Bogatyrev, 1992-95                  - 235 -                              Si v UNIX</i>

    <i>jmp</i>_<i>buf</i> jmp;
    main(){
         g();
         <i>longjmp</i>(jmp,1);
    }
    g(){ printf("Vyzvana g\n");
         f();
         printf("Vyhozhu iz g\n");
    }
    f(){
         static n;
         printf( "Vyzvana f\n");
         <i>setjmp</i>(jmp);
         printf( "Vyhozhu iz f %d-yj raz\n", ++n);
    }

Otvet: <i>longjmp</i> delaet pryzhok v funkciyu <i>f</i>(), iz kotoroj uzhe proizoshel vozvrat upravle-
niya. Pri perehode v telo funkcii v obhod ee zagolovka ne vypolnyayutsya mashinnye komandy
"prologa" funkcii - funkciya ostaetsya "neaktivirovannoj". Pri  vozvrate  iz  vyzvannoj
takim  "nelegal'nym"  putem  funkcii  voznikaet oshibka, i programma padaet. Moral': v
funkciyu, kotoraya NIKEM NE VYZVANA, nel'zya peredavat' upravlenie.  Obratnyj  pryzhok  -
iz  <i>f</i>()  v <i>main</i>() - byl by zakonen, poskol'ku funkciya <i>main</i>() yavlyaetsya aktivnoj, kogda
upravlenie nahoditsya v tele funkcii <i>f</i>().  T.e. mozhno "prygat'" iz vyzvannoj funkcii v
vyzyvayushchuyu: iz <i>f</i>() v <i>main</i>() ili v <i>g</i>(); i iz <i>g</i>() v <i>main</i>();

    --        --
     |   <i>f</i>    |  stek      prygat'
     |   <i>g</i>    |  vyzovov   sverhu vniz
     |   <i>main</i> |  funkcij   mozhno - eto sootvetstvuet
     ----------            vykidyvaniyu neskol'kih
                           verhnih sloev steka

no nel'zya naoborot: iz <i>main</i>() v <i>g</i>() ili <i>f</i>(); a takzhe  iz  <i>g</i>()  v  <i>f</i>().   Mozhno  takzhe
sovershat' pryzhok v predelah odnoj i toj zhe funkcii:

    f(){ ...
            A:   <i>setjmp</i>(jmp);
                 ...
                 <i>longjmp</i>(jmp, ...); ...
                 /* eto kak by <i>goto</i> A; */
    }


        6.8.  Hozyain fajla, processa, i proverka privelegij.
     <i>UNIX</i> - mnogopol'zovatel'skaya sistema. |to znachit,  chto  odnovremenno  na  raznyh
terminalah, podklyuchennyh k mashine, mogut rabotat' raznye pol'zovateli (a mozhet i odin
na neskol'kih terminalah). Na kazhdom terminale rabotaet  svoj  interpretator  komand,
yavlyayushchijsya potomkom processa <i>/etc/init</i>.

<i>6.8.1.</i>  Teper' - pro funkcii, pozvolyayushchie uznat' nekotorye dannye pro lyubogo  pol'zo-
vatelya  sistemy.   Kazhdyj  pol'zovatel'  v <i>UNIX</i> imeet unikal'nyj nomer: identifikator
pol'zovatelya (user id), a takzhe unikal'noe imya: registracionnoe imya, kotoroe on nabi-
raet  dlya  vhoda  v  sistemu.   Vsya  informaciya  o  pol'zovatelyah  hranitsya  v  fajle
<i>/etc/passwd</i>. Sushchestvuyut funkcii, pozvolyayushchie po nomeru pol'zovatelya uznat'  registra-
cionnoe imya i naoborot, a zaodno poluchit' eshche nekotoruyu informaciyu iz <i>passwd</i>:









<i>A. Bogatyrev, 1992-95                  - 236 -                              Si v UNIX</i>

    #include &lt;stdio.h>
    #include &lt;pwd.h>
    struct <i>passwd</i> *p;
    int   uid;   /* nomer */
    char *uname; /* reg. imya */

    uid = <i>getuid</i>();
    p   = <i>getpwuid</i>( uid   );
            ...
    p   = <i>getpwnam</i>( uname );

|ti funkcii vozvrashchayut ukazateli na staticheskie struktury, skrytye vnutri etih  funk-
cij.  Struktury eti imeyut polya:

    p-><i>pw</i>_<i>uid</i>     identif. pol'zovatelya (int uid);
    p-><i>pw</i>_<i>gid</i>     identif. gruppy pol'zovatelya;

            i ryad polej tipa char[]
    p-><i>pw</i>_<i>name</i>    registracionnoe imya pol'zovatelya (uname);
    p-><i>pw</i>_<i>dir</i>     polnoe imya domashnego kataloga
      (kataloga, stanovyashchegosya tekushchim pri vhode v sistemu);
    p-><i>pw</i>_<i>shell</i>   interpretator komand
      (esli "", to imeetsya v vidu <i>/bin/sh</i>);
    p-><i>pw</i>_<i>comment</i> proizvol'naya uchetnaya informaciya (ne ispol'zuetsya);
    p-><i>pw</i>_<i>gecos</i>   proizvol'naya uchetnaya informaciya (obychno FIO);
    p-><i>pw</i>_<i>passwd</i>  zashifrovannyj parol' dlya vhoda v
       sistemu. Istinnyj parol' nigde ne hranitsya vovse!

Funkcii vozvrashchayut znachenie p==<i>NULL</i>, esli ukazannyj pol'zovatel' ne sushchestvuet  (nap-
rimer,  esli  zadan nevernyj uid).  uid hozyaina dannogo processa mozhno uznat' vyzovom
<i>getuid</i>, a uid vladel'ca fajla - iz polya st_uid struktury, zapolnyaemoj sistemnym vyzo-
vom <i>stat</i> (a identifikator gruppy vladel'ca - iz polya st_gid).  Zadanie: modificirujte
nash analog programmy <i>ls</i>, chtoby on vydaval v  tekstovom  vide  imya  vladel'ca  kazhdogo
fajla v kataloge.

<i>6.8.2.</i>  Vladelec fajla mozhet izmenit' svoemu fajlu identifikatory vladel'ca i  gruppy
vyzovom

    <i>chown</i>(char *imyaFajla, int uid, int gid);

t.e. "podarit'" fajl drugomu pol'zovatelyu.  Zabrat' chuzhoj fajl sebe nevozmozhno.   Pri
etoj operacii bity <i>S</i>_<i>ISUID</i> i <i>S</i>_<i>ISGID</i> v kodah dostupa k fajlu (sm. nizhe) sbrasyvayutsya,
poetomu sozdat' "Troyanskogo konya" i, sdelav ego hozyainom superpol'zovatelya,  poluchit'
neogranichennye privelegii - ne udastsya!

<i>6.8.3.</i>  Kazhdyj fajl imeet svoego vladel'ca (pole di_uid v I-uzle na  diske  ili  pole
i_uid v kopii I-uzla v pamyati yadra<i>|</i>-).  Kazhdyj process takzhe  imeet  svoego  vladel'ca
(polya u_uid i u_ruid v <i>u-area</i>).  Kak my vidim, process imeet dva parametra, oboznacha-
yushchie vladel'ca. Pole ruid nazyvaetsya "<i>real'nym identifikatorom</i>" pol'zovatelya, a uid -
"<i>effektivnym  identifikatorom</i>".   Pri vyzove <i>exec</i>() zamenyaetsya programma, vypolnyaemaya
dannym processom:

____________________
   <i>|</i>- Pri otkrytii fajla i voobshche pri lyuboj operacii s fajlom, v tablicah  yadra  zavo-
ditsya  kopiya  I-uzla  (dlya uskoreniya dostupa, chtoby postoyanno ne obrashchat'sya k disku).
Esli I-uzel v pamyati budet izmenen, to pri za