debconf 1.5.87 - en to ro translation catalogue (530 entries)

note: type: SH
en: NAME
ro: NUME

note: type: textblock
en: debconf - run a debconf-using program
ro: debconf - rulează un program care utilizează debconf

note: type: SH
en: SYNOPSIS
ro: SINOPSIS

note: type: verbatim
en:  debconf [options] command [args]
ro:  debconf [opțiuni] comandă [argumente]

note: type: SH
en: DESCRIPTION
ro: DESCRIERE

note: type: textblock
en: Debconf is a configuration system for Debian packages. For a debconf overview and documentation for sysadmins, see L<debconf(7)> (in the debconf-doc package).
ro: Debconf este un sistem de configurare pentru pachetele Debian. Pentru o prezentare generală a debconf și documentație pentru administratorii de sistem, consultați L<debconf(7)> (în pachetul debconf-doc).

note: type: textblock
en: The B<debconf> program runs a program under debconf's control, setting it up to talk with debconf on stdio. The program's output is expected to be debconf protocol commands, and it is expected to read result codes on stdin. See L<debconf-devel(7)> for details about the debconf protocol.
ro: Programul B<debconf> rulează un program sub controlul debconf, configurându-l pentru a comunica cu debconf prin intermediul intrării standard. Se așteaptă ca ieșirea programului să fie comenzile protocolului debconf și se așteaptă ca acesta să citească codurile de rezultate la intrarea standard. Consultați L<debconf-devel(7)> pentru detalii despre protocolul debconf.

note: type: textblock
en: The command to be run under debconf must be specified in a way that will let your PATH find it.
ro: Comanda care urmează să fie executată sub debconf trebuie specificată într-un mod care va permite variabilei de mediu $PATH să o găsească.

note: type: textblock
en: This command is not the usual way that debconf is used. It's more typical for debconf to be used via L<dpkg-preconfigure(8)> or L<dpkg-reconfigure(8)>.
ro: Această comandă nu este modul obișnuit în care este utilizat debconf. Este mai tipic ca debconf să fie utilizat prin L<dpkg-preconfigure(8)> sau L<dpkg-reconfigure(8)>.

note: type: =head1
en: OPTIONS
ro: OPȚIUNI

note: type: =item
en: B<-o>I<package>, B<--owner=>I<package>
ro: B<-o>I<pachet>, B<--owner=>I<pachet>

note: type: textblock
en: Tell debconf what package the command it is running is a part of. This is necessary to get ownership of registered questions right, and to support unregister and purge commands properly.
ro: Îi indică lui debconf din ce pachet face parte comanda pe care o execută. Acest lucru este necesar pentru a obține proprietarul corect al întrebărilor înregistrate și pentru a gestiona corect comenzile de ștergere a înregistrărilor «unregister» și de purjare «purge».

note: type: =item
en: B<-f>I<type>, B<--frontend=>I<type>
ro: B<-f>I<tip>, B<--frontend=>I<tip>

note: type: textblock
en: Select the frontend to use.
ro: Selectează interfața care urmează să fie utilizată.

note: type: =item
en: B<-p>I<value>, B<--priority=>I<value>
ro: B<-p>I<valoare>, B<--priority=>I<valoare>

note: type: textblock
en: Specify the minimum priority of question that will be displayed.
ro: Specifică prioritatea minimă a întrebării care va fi afișată.

note: type: textblock
en: Enables terse output mode. This affects only some frontends.
ro: Activează modul de ieșire laconic. Acest lucru afectează doar unele interfețe.

note: type: =head1
en: EXAMPLES
ro: EXEMPLE

note: type: textblock
en: To debug a shell script that uses debconf, you might use:
ro: Pentru depanarea unui script shell care utilizează debconf, puteți utiliza:

note: type: verbatim
en:  DEBCONF_DEBUG=developer debconf my-shell-prog
ro:  DEBCONF_DEBUG=developer debconf scriptul-meu-shell

note: type: textblock
en: Or, you might use this:
ro: Sau, puteți utiliza această comandă:

note: type: verbatim
en:  debconf --frontend=readline sh -x my-shell-prog
ro:  debconf --frontend=readline sh -x scriptul-meu-shell

note: type: SH
en: SEE ALSO
ro: CONSULTAȚI ȘI

note: type: SH
en: AUTHOR
ro: AUTOR

note: type: textblock
en: Debconf::Client::ConfModule - client module for ConfModules
ro: Debconf::Client::ConfModule - modul client pentru ConfModules

note: type: verbatim
en:  use Debconf::Client::ConfModule ':all';
     version('2.0');
     my $capb=capb('backup');
     input("medium", "foo/bar");
     my @ret=go();
     if ($ret[0] == 30) {
     	# Back button pressed.
     	...
     }
     ...
ro:  use Debconf::Client::ConfModule ':all';
     version('2.0');
     my $capb=capb('backup');
     input("medium", "foo/bar");
     my @ret=go();
     if ($ret[0] == 30) {
     	# Butonul «Înapoi» apăsat.
     	...
     }
     ...

note: type: textblock
en: This is a module to ease writing ConfModules for Debian's configuration management system. It can communicate with a FrontEnd via the debconf protocol (which is documented in full in the debconf_specification in Debian policy).
ro: Acesta este un modul pentru a ușura scrierea de ConfModules pentru sistemul de gestionare a configurației Debian. Poate comunica cu o interfață (FrontEnd) prin protocolul debconf (care este documentat în întregime în debconf_specification din politica Debian).

note: type: textblock
en: The design is that each command in the protocol is represented by one function in this module (with the name lower-cased).  Call the function and pass in any parameters you want to follow the command. If the function is called in scalar context, it will return any textual return code. If it is called in list context, an array consisting of the numeric return code and the textual return code will be returned.
ro: Fiecare comandă din protocol este reprezentată de o funcție în acest modul (cu numele scris cu litere mici). Apelați funcția și treceți orice parametri doriți să urmeze comanda. Dacă funcția este apelată în context scalar, aceasta va returna orice cod de returnare textual. Dacă este apelată în context de listă, va fi returnată o matrice formată din codul de returnare numeric și codul de returnare textual.

note: type: textblock
en: This module uses Exporter to export all functions it defines. To import everything, simply import ":all".
ro: Acest modul utilizează Exporter pentru a exporta toate funcțiile pe care le definește. Pentru a importa totul, importați pur și simplu „:all”.

note: type: textblock
en: Ensure that a FrontEnd is running.  It's a little hackish. If DEBIAN_HAS_FRONTEND is set, a FrontEnd is assumed to be running.  If not, one is started up automatically and stdin and out are connected to it. Note that this function is always run when the module is loaded in the usual way.
ro: Se asigură că o interfață (FrontEnd) rulează. Este un pic mai complicat. Dacă variabila DEBIAN_HAS_FRONTEND este definită, se presupune că o interfață rulează. Dacă nu, una este pornită automat și intrarea și ieșirea standard sunt conectate la aceasta. Rețineți că această funcție este întotdeauna executată atunci când modulul este încărcat în mod obișnuit.

note: type: textblock
en: The frontend doesn't send a return code here, so we cannot try to read it or we'll block.
ro: Interfața nu trimite un cod de returnare aici, deci nu putem încerca să îl citim sau ne vom bloca.

note: type: textblock
en: Creates handler functions for commands on the fly.
ro: Creează din mers funcții de gestionare pentru comenzi.

note: type: textblock
en: The debconf specification (/usr/share/doc/debian-policy/debconf_specification.txt.gz).
ro: Specificația debconf (/usr/share/doc/debian-policy/debconf_specification.txt.gz).

note: type: textblock
en: debconf-apt-progress - install packages using debconf to display a progress bar
ro: debconf-apt-progress - instalează pachete folosind debconf pentru a afișa o bară de progres

note: type: verbatim
en:  debconf-apt-progress [--] command [args ...]
     debconf-apt-progress --config
     debconf-apt-progress --start
     debconf-apt-progress --from waypoint --to waypoint [--] command [args ...]
     debconf-apt-progress --stop
ro:  debconf-apt-progress [--] comanda [argumente ...]
     debconf-apt-progress --config
     debconf-apt-progress --start
     debconf-apt-progress --from waypoint --to waypoint [--] comanda [argumente ...]
     debconf-apt-progress --stop

note: type: textblock
en: B<debconf-apt-progress> installs packages using debconf to display a progress bar. The given I<command> should be any command-line apt frontend; specifically, it must send progress information to the file descriptor selected by the C<APT::Status-Fd> configuration option, and must keep the file descriptors nominated by the C<APT::Keep-Fds> configuration option open when invoking debconf (directly or indirectly), as those file descriptors will be used for the debconf passthrough protocol.
ro: B<debconf-apt-progress> instalează pachete utilizând debconf pentru a afișa o bară de progres. I<comanda> dată ar trebui să fie orice interfață apt din linia de comandă; în special, trebuie să trimită informații despre progres către descriptorul de fișier selectat de opțiunea de configurare C<APT::Status-Fd> și trebuie să mențină deschise descriptoarele de fișier nominalizate de opțiunea de configurare C<APT::Keep-Fds> atunci când se apelează debconf (direct sau indirect), deoarece acele descriptoare de fișier vor fi utilizate pentru protocolul „passthrough” (de trecere la) debconf.

note: type: textblock
en: The arguments to the command you supply should generally include B<-y> (for B<apt-get> or B<aptitude>) or similar to avoid the apt frontend prompting for input. B<debconf-apt-progress> cannot do this itself because the appropriate argument may differ between apt frontends.
ro: Argumentele comenzii pe care o furnizați ar trebui să includă, în general, B<-y> (pentru B<apt-get> sau B<aptitude>) sau ceva similar pentru a evita ca interfața apt să solicite informații. B<debconf-apt-progress> nu poate face acest lucru deoarece argumentul adecvat poate diferi de la o interfață apt la alta.

note: type: textblock
en: The B<--start>, B<--stop>, B<--from>, and B<--to> options may be used to create a progress bar with multiple segments for different stages of installation, provided that the caller is a debconf confmodule. The caller may also interact with the progress bar itself using the debconf protocol if it so desires.
ro: Opțiunile B<--start>, B<--stop>, B<--from> și B<--to> pot fi utilizate pentru a crea o bară de progres cu mai multe segmente pentru diferite etape de instalare, cu condiția ca apelantul să fie un modul de configurare „confmodule” debconf. Apelantul poate, de asemenea, să interacționeze cu bara de progres în sine utilizând protocolul debconf, dacă dorește acest lucru.

note: type: textblock
en: debconf locks its config database when it starts up, which makes it unfortunately inconvenient to have one instance of debconf displaying the progress bar and another passing through questions from packages being installed. If you're using a multiple-segment progress bar, you'll need to eval the output of the B<--config> option before starting the debconf frontend to work around this. See L<the EXAMPLES section/EXAMPLES> below.
ro: debconf își blochează baza de date de configurare atunci când pornește, ceea ce face ca, din păcate, să nu fie convenabil ca o instanță a debconf să afișeze bara de progres și o alta să transmită întrebări de la pachetele în curs de instalare. Dacă utilizați o bară de progres cu mai multe segmente, va trebui să evaluați rezultatul opțiunii B<--config> înainte de a porni interfața debconf pentru a rezolva această problemă. Consultați L<EXEMPLELE din secțiunea EXEMPLE> de mai jos.

note: type: textblock
en: Print environment variables necessary to start up a progress bar frontend.
ro: Afișează variabilele de mediu necesare pentru a porni o interfață cu bara de progres.

note: type: textblock
en: Start up a progress bar, running from 0 to 100 by default. Use B<--from> and B<--to> to use other endpoints.
ro: Pornește o bară de progres, care rulează implicit de la 0 la 100. Utilizați B<--from> și B<--to> pentru a utiliza alte puncte finale.

note: type: =item
en: B<--from> I<waypoint>
ro: B<--from> I<punct-de-reper>

note: type: textblock
en: If used with B<--start>, make the progress bar begin at I<waypoint> rather than 0.
ro: Dacă este utilizată cu B<--start>, bara de progres începe la I<punct-de-reper> în loc de 0.

note: type: textblock
en: Otherwise, install packages with their progress bar beginning at this "waypoint". Must be used with B<--to>.
ro: În caz contrar, instalează pachetele cu bara lor de progres începând de la acest „punct de reper”. Trebuie să fie utilizată cu B<--to>.

note: type: =item
en: B<--to> I<waypoint>
ro: B<--to> I<punct-de-reper>

note: type: textblock
en: If used with B<--start>, make the progress bar end at I<waypoint> rather than 100.
ro: Dacă este utilizată cu B<--start>, bara de progres se termină la I<punct-de-reper> în loc de 100.

note: type: textblock
en: Otherwise, install packages with their progress bar ending at this "waypoint". Must be used with B<--from>.
ro: În caz contrar, instalează pachetele a căror bară de progres se termină la acest „punct-de-reper”. Trebuie să fie utilizată împreună cu B<--from>.

note: type: textblock
en: Stop a running progress bar.
ro: Oprește o bară de progres care rulează.

note: type: textblock
en: Avoid starting, stopping, or stepping the progress bar. Progress messages from apt, media change events, and debconf questions will still be passed through to debconf.
ro: Evită pornirea, oprirea sau parcurgerea pas cu pas a barei de progres. Mesajele de progres de la apt, evenimentele de schimbare a suportului media și întrebările debconf vor fi transmise în continuare către debconf.

note: type: =item
en: B<--dlwaypoint> I<percentage>
ro: B<--dlwaypoint> I<procent>

note: type: textblock
en: Specify what percent of the progress bar to use for downloading packages.  The remainder will be used for installing packages. The default is to use 15% for downloading and the remaining 85% for installing.
ro: Specifică ce procent din bara de progres să fie utilizat pentru descărcarea pachetelor. Restul va fi utilizat pentru instalarea pachetelor. Valoarea implicită este de a utiliza 15% pentru descărcare și restul de 85% pentru instalare.

note: type: =item
en: B<--logfile> I<file>
ro: B<--logfile > I<fișier>

note: type: textblock
en: Send the normal output from apt to the given file.
ro: Trimite ieșirea normală de la apt către fișierul dat.

note: type: textblock
en: Send the normal output from apt to stderr. If you supply neither B<--logfile> nor B<--logstderr>, the normal output from apt will be discarded.
ro: Trimite ieșirea normală de la apt la ieșirea de eroare standard. Dacă nu furnizați nici B<--logfile>, nici B<--logstderr>, ieșirea normală de la apt va fi eliminată.

note: type: textblock
en: Terminate options. Since you will normally need to give at least the B<-y> argument to the command being run, you will usually need to use B<--> to prevent that being interpreted as an option to B<debconf-apt-progress> itself.
ro: Semnalează terminarea opțiunilor. Deoarece în mod normal va trebui să oferiți cel puțin argumentul B<-y> comenzii care se execută, de obicei va trebui să utilizați B<--> pentru a preveni interpretarea acestuia ca opțiune pentru B<debconf-apt-progress>.

note: type: textblock
en: Install the GNOME desktop and an X window system development environment within a progress bar:
ro: Instalați biroul GNOME și un mediu de dezvoltare cu sistemul de ferestre X în cadrul unei bare de progres:

note: type: textblock
en: Install the GNOME, KDE, and XFCE desktops within a single progress bar, allocating 45% of the progress bar for each of GNOME and KDE and the remaining 10% for XFCE:
ro: Instalați birourile GNOME, KDE și XFCE în cadrul unei singure bare de progres, alocând 45% din bara de progres pentru GNOME, alte 45% pentru KDE și restul de 10% pentru XFCE:

note: type: =head1
en: RETURN CODE
ro: COD DE RETURNARE

note: type: textblock
en: The exit code of the specified command is returned, unless the user hit the cancel button on the progress bar. If the cancel button was hit, a value of 30 is returned. To avoid ambiguity, if the command returned 30, a value of 3 will be returned.
ro: Este returnat codul de ieșire al comenzii specificate, cu excepția cazului în care utilizatorul a apăsat butonul de anulare de la bara de progres. Dacă butonul de anulare a fost apăsat, se returnează o valoare de 30. Pentru a evita ambiguitatea, dacă comanda a returnat 30, se va returna o valoare de 3.

note: type: =head1
en: AUTHORS
ro: AUTORI

note: type: textblock
en: debconf-escape - helper when working with debconf's escape capability
ro: debconf-escape - ajutor în lucrul cu capacitatea de eludare a debconf

note: type: verbatim
en:  debconf-escape -e < unescaped-text
     debconf-escape -u < escaped-text
ro:  debconf-escape -e < text-neeludat
     debconf-escape -u < text-eludat

note: type: textblock
en: When debconf has the 'escape' capability set, it will expect commands you send it to have backslashes and newlines escaped (as C<\\> and C<\n> respectively) and will in turn escape backslashes and newlines in its replies. This can be used, for example, to substitute multi-line strings into templates, or to get multi-line extended descriptions reliably using C<METAGET>.
ro: Când debconf are activată funcția „escape” (eludare), se va aștepta ca acele comenzi pe care i le trimiteți să aibă bare oblice și linii noi eludate (ca C<\\> și respectiv C<\n>) și, la rândul său, va eluda barele oblice și liniile noi în răspunsurile sale. Acest lucru poate fi utilizat, de exemplu, pentru a înlocui șiruri cu mai multe linii în șabloane sau pentru a obține descrieri extinse cu mai multe linii în mod fiabil utilizând C<METAGET>.

note: type: textblock
en: L<debconf-devel(7)> (available in the debconf-doc package)
ro: L<debconf-devel(7)> (disponibil în pachetul „debconf-doc”)

note: type: textblock
en: debconf-communicate - communicate with debconf
ro: debconf-communicate - comunicare cu debconf

note: type: verbatim
en:  echo commands | debconf-communicate [options] [package]
ro:  echo comenzi | debconf-communicate [opțiuni] [pachet]

note: type: textblock
en: B<debconf-communicate> allows you to communicate with debconf on the fly, from the command line. The package argument is the name of the package which you are pretending to be as you communicate with debconf, and it may be omitted if you are lazy. It reads commands in the form used by the debconf protocol from stdin. For documentation on the available commands and their usage, see the debconf specification.
ro: B<debconf-communicate> vă permite să comunicați cu debconf din mers, din linia de comandă. Argumentul „pachet” este numele pachetului în care pretindeți că sunteți în timp ce comunicați cu debconf și poate fi omis dacă sunteți leneș. Acesta citește comenzile în forma utilizată de protocolul debconf de la intrarea standard. Pentru documentație privind comenzile disponibile și utilizarea lor, consultați specificațiile debconf.

note: type: textblock
en: The commands are executed in sequence. The textual return code of each is printed out to standard output.
ro: Comenzile sunt executate în succesiune. Codul de returnare textual al fiecăreia este imprimat la ieșirea standard.

note: type: textblock
en: The return value of this program is the numeric return code of the last executed command.
ro: Valoarea de returnare a acestui program este codul numeric de returnare al ultimei comenzi executate.

note: type: SH
en: EXAMPLE
ro: EXEMPLU

note: type: textblock
en: Print out the value of the debconf/frontend question.
ro: Afișează valoarea întrebării din interfața-debconf (debconf/fronted).

note: type: =head1
en: WARNING
ro: AVERTISMENT

note: type: textblock
en: This program should never be used from a maintainer script of a package that uses debconf! It may however, be useful in debugging.
ro: Acest program nu ar trebui să fie utilizat niciodată dintr-un script de menținere a unui pachet care utilizează debconf! Cu toate acestea, poate fi util în depanare.

note: type: textblock
en: debconf-copydb - copy a debconf database
ro: debconf-copydb - copiază o bază de date debconf

note: type: verbatim
en:  debconf-copydb sourcedb destdb [--pattern=pattern] [--owner-pattern=pattern] [--config=Foo:bar]
ro:  debconf-copydb BD-sursă BD-destinație [--pattern=model] [--owner-pattern=model] [--config=Foo:bar]

note: type: textblock
en: B<debconf-copydb> copies items from an existing debconf database into another, possibly new database. The two databases may have different formats; if so a conversion will automatically be done.
ro: B<debconf-copydb> copiază elemente dintr-o bază de date debconf existentă într-o altă bază de date, posibil nouă. Cele două baze de date pot avea formate diferite; în acest caz, se va face automat o conversie.

note: type: =item
en: I<sourcedb>
ro: I<BD-sursă>

note: type: textblock
en: The name of the source database. Typically it will be defined in your debconf.conf (or .debconfrc) file.
ro: Numele bazei de date sursă. De obicei, acesta va fi definit în fișierul debconf.conf (sau .debconfrc).

note: type: =item
en: I<destdb>
ro: I<BD-destinație>

note: type: textblock
en: The name of the destination database. It may be defined in debconf.conf or .debconfrc, or you might define it on the command line (see below).
ro: Numele bazei de date de destinație. Acesta poate fi definit în debconf.conf sau .debconfrc, sau îl puteți defini în linia de comandă (a se vedea mai jos).

note: type: =item
en: B<-p> I<pattern>, B<--pattern> I<pattern>
ro: B<-p> I<model>, B<--pattern> I<model>

note: type: textblock
en: If this is specified, only items in I<sourcedb> whose names match the pattern will be copied.
ro: Dacă acesta este specificat, vor fi copiate numai elementele din I<BD-sursă> ale căror nume corespund modelului.

note: type: =item
en: B<--owner-pattern> I<pattern>
ro: B<--owner-pattern> I<model>

note: type: textblock
en: If this is specified, only items in I<sourcedb> whose owners match the pattern will be copied.
ro: Dacă acesta este specificat, vor fi copiate numai elementele din I<BD-sursă> ai căror proprietari corespund modelului.

note: type: textblock
en: Set option Foo to bar. This is similar to writing:
ro: Stabilește opțiunea „Foo” la „bar”. Acest lucru este similar cu scrierea:

note: type: textblock
en: In debconf.conf, except you probably want to leave off the space on the command line (or quote it: "Foo: bar"). Generally must be used multiple times, to build up a full configuration stanza. While blank lines are used to separate stanzas in debconf.conf, this program will assume that "Name:dbname" denotes the beginning of a new stanza.
ro: În debconf.conf, cu excepția faptului că probabil doriți să omiteți spațiul din linia de comandă (sau să-l puneți între ghilimele duble: "Foo: bar"). În general, trebuie utilizată de mai multe ori, pentru a construi o strofă de configurare completă. În timp ce liniile goale sunt utilizate pentru a separa strofele în debconf.conf, acest program va presupune că „Name:numeBD” reprezintă începutul unei noi strofe.

note: type: verbatim
en:   debconf-copydb configdb backup
ro:   debconf-copydb configdb copie_de_rezervă-BD

note: type: textblock
en: Copy all of configdb to backup, assuming you already have the backup database defined in debconf.conf.
ro: Copiază toată baza de date „configdb” în copie_de_rezervă-BD, presupunând că aveți deja baza de date de copie_de_rezervă-BD definită în debconf.conf.

note: type: verbatim
en:   debconf-copydb configdb newdb --pattern='^slrn/' \
      	--config=Name:newdb --config=Driver:File \
    	--config=Filename:newdb.dat
ro:   debconf-copydb configdb BD-nouă --pattern='^slrn/' \
      	--config=Name:BD-nouă --config=Driver:File \
    	--config=Filename:BD-nouă.dat

note: type: textblock
en: Copy slrn's data out of configdb, and into newdb. newdb is not defined in the rc file, so the --config switches set up the database on the fly.
ro: Copiază datele slrn din baza de date „configdb” în BD-nouă. BD-nouă nu este definită în fișierul rc, astfel încât opțiunea „--config” stabilește baza de date din mers.

note: type: textblock
en: Spit out all the items in the debconf database related to package foo.
ro: Scoate toate elementele din baza de date debconf referitoare la pachetul foo.

note: type: verbatim
en:   debconf-copydb configdb pipe --config=Name:pipe \
                    --config=Driver:Pipe --config=InFd:none | \
      	ssh remotehost debconf-copydb pipe configdb \
    		--config=Name:pipe --config=Driver:Pipe
ro:   debconf-copydb configdb pipe --config=Name:pipe \
                    --config=Driver:Pipe --config=InFd:none | \
      	ssh gazdă_la_distanță debconf-copydb pipe configdb \
    		--config=Name:pipe --config=Driver:Pipe

note: type: textblock
en: This uses the special purpose pipe driver to copy a database to a remote system.
ro: Aceasta utilizează sistemul de control (driver) special pentru acest scop, „pipe”, pentru a copia o bază de date pe un sistem la distanță.

note: type: textblock
en: debconf-getlang - extract a language from a templates file
ro: debconf-getlang - extrage o limbă dintr-un fișier șablon

note: type: verbatim
en:  debconf-getlang lang master [translation]
     debconf-getlang --stats master translation [...]
ro:  debconf-getlang limba fișier-principal [traducerea]
     debconf-getlang --stats fișier-principal traducerea [...]

note: type: textblock
en: Note: This utility is deprecated; you should switch to using the po-debconf package.
ro: Notă: Acest instrument este depreciat; ar trebui să treceți la utilizarea pachetului po-debconf.

note: type: textblock
en: This program helps make and manage translations of debconf templates.  There are basically three situations in which this program might be called:
ro: Acest program ajută la realizarea și gestionarea traducerilor șabloanelor debconf. Există în principiu trei situații în care acest program ar putea fi apelat:

note: type: =item
en: A translation is just being started.
ro: O traducere tocmai a fost începută.

note: type: textblock
en: You want to provide the translator with a file they can work on that has the English fields from your templates file, plus blank Field-ll fields for the target language that they can fill in.
ro: Doriți să furnizați traducătorului un fișier pe care să poată lucra și care conține câmpurile în limba engleză (msgid) din fișierul dvs. de șabloane, plus câmpuri secundare (msgstr) goale pentru limba țintă pe care le poate completa.

note: type: textblock
en: To do this, run the program with first parameter being the code for the language that is being translated to, and the second parameter being the filename of the English templates file.
ro: Pentru a face acest lucru, rulați programul cu primul parametru fiind codul pentru limba în care este tradus, iar al doilea parametru fiind numele fișierului de șabloane în limba engleză.

note: type: =item
en: A translation is well under way.
ro: O traducere este în plină desfășurare.

note: type: textblock
en: You have changed some English text, or added more items to your templates file, and you want to send the translators a file with the English text plus their current translations (or you are the translator, and you want to generate such a file for your own use).
ro: Ați modificat o parte din textul în limba engleză sau ați adăugat mai multe elemente la fișierul dvs. de șabloane și doriți să trimiteți traducătorilor un fișier cu textul în limba engleză plus traducerile lor actuale (sau sunteți traducătorul și doriți să generați un astfel de fișier pentru uz propriu).

note: type: textblock
en: To accomplish this, run the program with the first parameter being the the code for the language that is being translated to, the second parameter being the filename of the master English templates file, and the third parameter being the filename of the current translated file.
ro: Pentru a realiza acest lucru, rulați programul cu primul parametru fiind codul pentru limba în care este tradus, al doilea parametru fiind numele fișierului principal al șabloanelor în limba engleză, iar al treilea parametru fiind numele fișierului tradus curent.

note: type: textblock
en: When run this way, the program is smart enough to notice fuzzy translations. For example a fuzzy Description will be output as Description-<lang>-fuzzy, and a new, blank Description-<lang> will be added.  Translators should remove the -fuzzy fields as they correct the fuzzy translations.
ro: Atunci când este rulat în acest mod, programul este suficient de inteligent pentru a observa traducerile aproximative „fuzzy”. De exemplu, o descriere neclară va fi transmisă ca „Description-<limbă>-fuzzy” și va fi adăugată o descriere nouă, goală, „Description-<limbă>”. Traducătorii trebuie să elimine câmpurile -fuzzy pe măsură ce corectează traducerile aproximative.

note: type: =item
en: Checking the status of a translation
ro: Verificarea stării unei traduceri

note: type: textblock
en: To check the status of a translation, use the --status flag, and pass the english template file as the first parameter, and all the other translated templates after that. It will output statistics for each of them. For example:
ro: Pentru a verifica starea unei traduceri, utilizați opțiunea „--status” și treceți fișierul șablon în limba engleză ca prim parametru, iar apoi toate celelalte șabloane traduse. Se vor afișa statistici pentru fiecare dintre ele. De exemplu:

note: type: =head1
en: NOTE
ro: NOTĂ

note: type: textblock
en: Note that the text in the generated templates may be word-wrapped by debconf.
ro: Rețineți că textul din șabloanele generate poate fi „word wrapped” (încadrat în pagină) de către debconf.

note: type: textblock
en: debconf-get-selections - output contents of debconf database
ro: debconf-get-selections - afișează conținutul bazei de date debconf

note: type: textblock
en: Output the current debconf database in a format understandable by debconf-set-selections.
ro: Afișează baza de date debconf curentă într-un format înțeles de «debconf-set-selections».

note: type: textblock
en: To dump the debconf database of the debian-installer, from /var/log/installer/cdebconf, use the --installer parameter.
ro: Pentru a extrage baza de date „debconf” a «debian-installer», din „/var/log/installer/cdebconf”, utilizați opțiunea „--installer”.

note: type: textblock
en: debconf-loadtemplate - load template file into debconf database
ro: debconf-loadtemplate - încarcă fișierul șablon în baza de date debconf

note: type: verbatim
en:  debconf-loadtemplate owner file [file ..]
ro:  debconf-loadtemplate proprietar fișier [fișier ..]

note: type: textblock
en: Loads one or more template files into the debconf database. The first parameter specifies the owner of the templates (typically, the owner is the name of a debian package). The remaining parameters are template files to load.
ro: Încarcă unul sau mai multe fișiere șablon în baza de date debconf. Primul parametru specifică proprietarul șabloanelor (de obicei, proprietarul este numele unui pachet debian). Parametrii rămași sunt fișierele șablon care urmează să fie încărcate.

note: type: textblock
en: This program should never be used from a maintainer script of a package that uses debconf! It may however, be useful in debugging, or to seed the debconf database.
ro: Acest program nu ar trebui să fie utilizat niciodată de un script de întreținere a unui pachet care utilizează debconf! Cu toate acestea, poate fi util în depanare sau pentru alimentarea bazei de date debconf.

note: type: textblock
en: debconf-mergetemplate - merge together multiple debconf template files
ro: debconf-mergetemplate - îmbină mai multe fișiere șablon debconf

note: type: verbatim
en:  debconf-mergetemplate [options] [templates.ll ...] templates
ro:  debconf-mergetemplate [opțiuni] [templates.ll ...] templates

note: type: textblock
en: Note: This utility is deprecated. You should switch to using po-debconf's po2debconf program.
ro: Notă: Acest instrument este depreciat. Ar trebui să treceți la utilizarea programului po2debconf al po-debconf.

note: type: textblock
en: This program is useful if you have multiple debconf templates files which you want to merge together into one big file. All the specified files will be read in, merged, and output to standard output.
ro: Acest program este util dacă aveți mai multe fișiere de șabloane debconf pe care doriți să le îmbinați într-un singur fișier mare. Toate fișierele specificate vor fi citite, fuzionate și trimise la ieșirea standard.

note: type: textblock
en: This can be especially useful if you are dealing with translated template files. In this case, you might have your main template file, plus several other files provided by the translators. These files will have translated fields in them, and maybe the translators left in the english versions of the fields they translated, for their reference.
ro: Acest lucru poate fi util mai ales dacă aveți de-a face cu fișiere șablon traduse. În acest caz, s-ar putea să aveți fișierul șablon principal, plus alte câteva fișiere furnizate de traducători. Aceste fișiere vor conține câmpuri traduse și poate că traducătorii au lăsat versiunile în limba engleză ale câmpurilor pe care le-au tradus, pentru referință.

note: type: textblock
en: So, you want to merge together all the translated templates files with your main templates file. Any fields that are unique to the translated files need to be added in to the correct templates, but any fields they have in common should be superseded by the fields in the main file (which might be more up-to-date).
ro: Deci, doriți să fuzionați toate fișierele de șabloane traduse cu fișierul principal de șabloane. Orice câmpuri care sunt unice pentru fișierele traduse trebuie adăugate în șabloanele corecte, dar orice câmpuri pe care le au în comun trebuie înlocuite de câmpurile din fișierul principal (care ar putea fi mai actualizate).

note: type: textblock
en: This program handles that case properly, just list each of the translated templates files, and then your main templates file last.
ro: Acest program se ocupă de acest caz în mod corespunzător, doar listează fiecare dintre fișierele de șabloane traduse și apoi ultimul fișier de șabloane principal.

note: type: textblock
en: Merge in even outdated translations. The default is to drop them with a warning message.
ro: Fuzionează chiar și traducerile învechite. În mod implicit, acestea sunt eliminate cu un mesaj de avertizare.

note: type: textblock
en: If a translation has an entire template that is not in the master file (and thus is probably an old template), drop that entire template.
ro: Dacă o traducere are un șablon întreg care nu se află în fișierul principal (și, prin urmare, este probabil un șablon vechi), renunță la acel șablon întreg.

note: type: textblock
en: debconf-set-selections - insert new values into the debconf database
ro: debconf-set-selections - inserează noi valori în baza de date debconf

note: type: verbatim
en:  debconf-set-selections file
     debconf-get-selections | ssh newhost debconf-set-selections
ro:  debconf-set-selections fișier
     debconf-get-selections | ssh gazdă-nouă debconf-set-selections

note: type: textblock
en: B<debconf-set-selections> can be used to pre-seed the debconf database with answers, or to change answers in the database. Each question will be marked as seen to prevent debconf from asking the question interactively.
ro: B<debconf-set-selections> poate fi utilizat pentru a preînsămânța baza de date debconf cu răspunsuri sau pentru a modifica răspunsurile din baza de date. Fiecare întrebare va fi marcată ca văzută pentru a împiedica debconf să pună întrebarea în mod interactiv.

note: type: textblock
en: Reads from a file if a filename is given, otherwise from stdin.
ro: Citește dintr-un fișier dacă este dat un nume de fișier, altfel de la intrarea standard.

note: type: textblock
en: Only use this command to seed debconf values for packages that will be or are installed. Otherwise you can end up with values in the database for uninstalled packages that will not go away, or with worse problems involving shared values. It is recommended that this only be used to seed the database if the originating machine has an identical install.
ro: Utilizați această comandă numai pentru a însămânța valorile debconf pentru pachetele care vor fi sau sunt instalate. În caz contrar, vă puteți trezi cu valori în baza de date pentru pachete dezinstalate care nu vor dispărea sau cu probleme mai grave care implică valori partajate. Se recomandă utilizarea acestei comenzi pentru însămânțarea bazei de date numai dacă mașina de origine are o instalare identică.

note: type: =head1
en: DATA FORMAT
ro: FORMATUL DATELOR

note: type: textblock
en: The data is a series of lines. Lines beginning with a # character are comments. Blank lines are ignored. All other lines set the value of one question, and should contain four values, each separated by one character of whitespace. The first value is the name of the package that owns the question. The second is the name of the question, the third value is the type of this question, and the fourth value (through the end of the line)  is the value to use for the answer of the question.
ro: Datele sunt o serie de linii. Liniile care încep cu un caracter „#” sunt comentarii. Liniile goale sunt ignorate. Toate celelalte linii stabilesc valoarea unei întrebări și ar trebui să conțină patru valori, fiecare separată de un caracter de spațiu alb. Prima valoare este numele pachetului care deține întrebarea. A doua este numele întrebării, a treia valoare este tipul acestei întrebări, iar a patra valoare (până la sfârșitul liniei) este valoarea care trebuie utilizată pentru răspunsul la întrebare.

note: type: textblock
en: Alternatively, the third value can be "seen"; then the preseed line only controls whether the question is marked as seen in debconf's database. Note that preseeding a question's value defaults to marking that question as seen, so to override the default value without marking a question seen, you need two lines.
ro: Alternativ, a treia valoare poate fi „seen” (văzută); atunci linia de pre-configurare controlează doar dacă întrebarea este marcată ca văzută în baza de date a debconf. Rețineți că preconfigurarea valorii unei întrebări duce implicit la marcarea acelei întrebări ca fiind văzută, astfel încât pentru a trece peste valoarea implicită fără a marca o întrebare ca fiind văzută, aveți nevoie de două linii.

note: type: textblock
en: Lines can be continued to the next line by ending them with a "\" character.
ro: Liniile pot fi continuate pe următoarea linie prin terminarea lor cu un caracter „\”.

note: type: verbatim
en:  # Force debconf priority to critical.
     debconf debconf/priority select critical
ro:  # Forțează prioritatea debconf la „critică”.
     debconf debconf/priority select critical

note: type: verbatim
en:  # Override default frontend to readline, but allow user to select.
     debconf debconf/frontend select readline
     debconf debconf/frontend seen false
ro:  # Suprascrie interfața implicită la «readline», dar permite utilizatorului să selecteze.
     debconf debconf/frontend select readline
     debconf debconf/frontend seen false

note: type: textblock
en: verbose output
ro: ieșire cu mesje informative detaliate

note: type: textblock
en: only check the input file format, do not save changes to database
ro: verifică doar formatul fișierului de intrare, nu salvează modificările în baza de date

note: type: textblock
en: L<debconf-get-selections(1)> (available in the debconf-utils package)
ro: L<debconf-get-selections(1)> (disponibil în pachetul debconf-utils)

note: type: textblock
en: debconf-show - query the debconf database
ro: debconf-show - interoghează baza de date debconf

note: type: verbatim
en:  debconf-show packagename [...] [--db=dbname]
     debconf-show --listowners [--db=dbname]
     debconf-show --listdbs
ro:  debconf-show packagename [...] [--db=nume-bază_date]
     debconf-show --listowners [--db=nume-bază_date]
     debconf-show --listdbs

note: type: textblock
en: B<debconf-show> lets you query the debconf database in different ways.
ro: B<debconf-show> vă permite să interogați baza de date debconf în diferite moduri.

note: type: textblock
en: The most common use is "debconf-show packagename", which displays all items in the debconf database owned by a given package, and their current values.  Questions that have been asked already are prefixed with an '*'.
ro: Cea mai comună utilizare este «debconf-show nume-pachet», care afișează toate elementele din baza de date debconf deținute de un anumit pachet și valorile lor actuale.  Întrebările care au fost deja adresate sunt prefixate cu un „*”.

note: type: textblock
en: This can be useful as a debugging aid, and especially handy in bug reports involving a package's use of debconf.
ro: Acest lucru poate fi util ca ajutor pentru depanare și mai ales în rapoartele de erori care implică utilizarea debconf de către un pachet.

note: type: =item
en: B<--db=>I<dbname>
ro: B<--db=>I<nume-bază_date>

note: type: textblock
en: Specify the database to query. By default, debconf-show queries the main database.
ro: Specifică baza de date care urmează să fie interogată. În mod implicit, debconf-show interoghează baza de date principală.

note: type: textblock
en: Lists all owners of questions in the database. Generally an owner is equivalent to a debian package name.
ro: Listează toți proprietarii întrebărilor din baza de date. În general, un proprietar este echivalent cu un nume de pachet debian.

note: type: textblock
en: Lists all available databases.
ro: Listează toate bazele de date disponibile.

note: type: textblock
en: Joey Hess <joeyh@debian.org> and Sylvain Ferriol
ro: Joey Hess <joeyh@debian.org> și Sylvain Ferriol

note: type: textblock
en: dpkg-preconfigure - let packages ask questions prior to their installation
ro: dpkg-preconfigure - permite pachetelor să pună întrebări înainte de instalarea lor

note: type: verbatim
en:  dpkg-preconfigure [options] package.deb
ro:  dpkg-preconfigure [opțiuni] pachet.deb

note: type: textblock
en: B<dpkg-preconfigure> lets packages ask questions before they are installed.  It operates on a set of debian packages, and all packages that use debconf will have their config script run so they can examine the system and ask questions.
ro: B<dpkg-preconfigure> permite pachetelor să pună întrebări înainte de a fi instalate. Funcționează pe un set de pachete debian, iar toate pachetele care utilizează debconf vor avea scriptul lor de configurare rulat astfel încât să poată examina sistemul și să pună întrebări.

note: type: textblock
en: Set the lowest priority of questions you are interested in. Any questions with a priority below the selected priority will be ignored and their default answers will be used.
ro: Stabiliți cea mai mică prioritate a întrebărilor care vă interesează. Orice întrebare cu o prioritate mai mică decât prioritatea selectată va fi ignorată și vor fi utilizate răspunsurile implicite ale acesteia.

note: type: textblock
en: Run in apt mode. It will expect to read a set of package filenames from stdin, rather than getting them as parameters. Typically this is used to make apt run dpkg-preconfigure on all packages before they are installed.  To do this, add something like this to /etc/apt/apt.conf:
ro: Rulează în modul apt. Se va aștepta să citească un set de nume de fișiere de pachete de la intrarea standard, mai degrabă decât să le obțină ca parametri. De obicei, acest lucru este utilizat pentru a face «apt» să ruleze «dpkg-preconfigure» pe toate pachetele înainte ca acestea să fie instalate. Pentru a face acest lucru, adăugați ceva de tipul acesta la „/etc/apt/apt.conf”:

note: type: verbatim
en:  // Pre-configure all packages before
     // they are installed.
     DPkg::Pre-Install-Pkgs {
     	"dpkg-preconfigure --apt --priority=low";
     };
ro:  // Pre- configurați toate pachetele înainte
     // ca acestea să fie instalate.
     DPkg::Pre-Install-Pkgs {
     	"dpkg-preconfigure --apt --priority=low";
     };

note: type: textblock
en: Display usage help.
ro: Afișează ajutorul de utilizare.

note: type: textblock
en: dpkg-reconfigure - reconfigure an already installed package
ro: dpkg-reconfigure - reconfigurează un pachet deja instalat

note: type: verbatim
en:  dpkg-reconfigure [options] packages
ro:  dpkg-reconfigure [opțiuni] pachete

note: type: textblock
en: B<dpkg-reconfigure> reconfigures packages after they have already been installed. Pass it the names of a package or packages to reconfigure. It will ask configuration questions, much like when the package was first installed.
ro: B<dpkg-reconfigure> reconfigurează pachetele după ce acestea au fost deja instalate. Pasați-i numele pachetului sau pachetelor de reconfigurat. Acesta va pune întrebări de configurare, la fel ca atunci când pachetul a fost instalat pentru prima dată.

note: type: textblock
en: If you just want to see the current configuration of a package, see L<debconf-show(1)> instead.
ro: Dacă doriți doar să vedeți configurația curentă a unui pachet, consultați în schimb L<debconf-show(1)>.

note: type: textblock
en: Select the frontend to use. The default frontend can be permanently changed by:
ro: Selectați interfața care urmează să fie utilizată. Interfața implicită poate fi modificată permanent prin:

note: type: textblock
en: Note that if you normally have debconf set to use the noninteractive frontend, dpkg-reconfigure will use the dialog frontend instead, so you actually get to reconfigure the package.
ro: Rețineți că, dacă în mod normal «debconf» este configurat pentru a utiliza interfața neinteractivă, «dpkg-reconfigure» va utiliza în schimb interfața dialog, astfel încât să reconfigurați pachetul.

note: type: textblock
en: Specify the minimum priority of question that will be displayed.  dpkg-reconfigure normally shows low priority questions no matter what your default priority is. See L<debconf(7)> for a list.
ro: Specificați prioritatea minimă a întrebării care va fi afișată. «dpkg-reconfigure» afișează în mod normal întrebări cu prioritate scăzută, indiferent de prioritatea implicită. Consultați L<debconf(7)> pentru o listă.

note: type: textblock
en: Use whatever the default priority of question is, instead of forcing the priority to low.
ro: Utilizează prioritatea implicită a întrebării, în loc să forțeze prioritatea să fie scăzută.

note: type: textblock
en: By default, all questions are shown, even if they have already been answered. If this parameter is set though, only questions that have not yet been seen will be asked.
ro: În mod implicit, sunt afișate toate întrebările, chiar dacă s-a răspuns deja la ele. Totuși, dacă acest parametru este definit, vor fi adresate numai întrebările care nu au fost încă văzute.

note: type: textblock
en: Force dpkg-reconfigure to reconfigure a package even if the package is in an inconsistent or broken state. Use with caution.
ro: Forțează «dpkg-reconfigure» să reconfigureze un pachet chiar dacă pachetul se află într-o stare inconsistentă sau deteriorată. Utilizați cu precauție.

note: type: textblock
en: Prevent dpkg-reconfigure from reloading templates. Use with caution; this will prevent dpkg-reconfigure from repairing broken templates databases.  However, it may be useful in constrained environments where rewriting the templates database is expensive.
ro: Împiedică »dpkg-reconfigure» să reîncarce șabloanele. Utilizați cu precauție; acest lucru va împiedica «dpkg-reconfigure» să repare bazele de date de șabloane defecte. Cu toate acestea, poate fi utilă în medii constrânse în care rescrierea bazei de date a șabloanelor este costisitoare.

note: type: Plain text
en: debconf.conf - debconf configuration file
ro: debconf.conf - fișierul de configurare debconf

note: type: Plain text
en: Debconf is a configuration system for Debian packages. /etc/debconf.conf and ~/.debconfrc are configuration files debconf uses to determine which databases it should use. These databases are used for storing two types of information; dynamic config data the user enters into it, and static template data. Debconf offers a flexible, extensible database backend. New drivers can be created with a minimum of effort, and sets of drivers can be combined in various ways.
ro: Debconf este un sistem de configurare pentru pachetele Debian. „/etc/debconf.conf” și „~/.debconfrc” sunt fișiere de configurare pe care debconf le folosește pentru a determina ce baze de date ar trebui să folosească. Aceste baze de date sunt folosite pentru stocarea a două tipuri de informații; date de configurare dinamice pe care utilizatorul le introduce în ele și date statice de șablon. Debconf oferă un sistem de control (driver) a bazelor de date flexibil și extensibil. Noi sisteme de control pot fi create cu un minim de efort, iar seturile de sisteme de control pot fi combinate în diverse moduri.

note: type: Plain text
en:   # This is a sample config file that is
      # sufficient to use debconf.
      Config: configdb
      Templates: templatedb
ro:   # Acesta este un exemplu de fișier de configurare
      # care este suficient pentru a utiliza debconf.
      Config: configdb
      Templates: templatedb

note: type: SH
en: FILE FORMAT
ro: FORMATUL FIȘIERULUI

note: type: Plain text
en: The format of this file is a series of stanzas, each separated by at least one wholly blank line. Comment lines beginning with a "#" character are ignored.
ro: Formatul acestui fișier este o serie de strofe, fiecare separată de cel puțin un rând complet gol. Liniile de comentariu care încep cu un caracter „#” sunt ignorate.

note: type: Plain text
en: The first stanza of the file is special, is used to configure debconf as a whole. Two fields are required to be in this first stanza:
ro: Prima strofă a fișierului este specială, este utilizată pentru a configura debconf ca un întreg. Două câmpuri trebuie să fie în această primă strofă:

note: type: Plain text
en: Specifies the name of the database from which to load config data.
ro: Specifică numele bazei de date din care se încarcă datele de configurare.

note: type: Plain text
en: Specifies the name of the database to use for the template cache.
ro: Specifică numele bazei de date care urmează să fie utilizată pentru cache-ul șablonului.

note: type: Plain text
en: Additional fields that can be used include:
ro: Câmpurile suplimentare care pot fi utilizate includ:

note: type: Plain text
en: The frontend Debconf should use, overriding any frontend set in the debconf database.
ro: Interfața pe care Debconf ar trebui să o utilizeze, cu prioritate față de orice interfață definită în baza de date debconf.

note: type: Plain text
en: The priority Debconf should use, overriding any priority set in the debconf database.
ro: Prioritatea pe care trebuie să o utilizeze Debconf, care prevalează asupra oricărei priorități definite în baza de date debconf.

note: type: Plain text
en: The email address Debconf should send mail to if it needs to make sure that the admin has seen an important message. Defaults to "root", but can be set to any valid email address to send the mail there. If you prefer to never have debconf send you mail, specify a blank address. This can be overridden on the fly with the DEBCONF_ADMIN_EMAIL environment variable.
ro: Adresa de e poștă electronică la care Debconf ar trebui să trimită mesaje dacă trebuie să se asigure că administratorul a văzut un mesaj important. Valoarea implicită este „root”, dar poate fi definită la orice adresă de poștă electronică validă pentru a trimite mesajul acolo. Dacă preferați ca debconf să nu vă trimită niciodată mesaje, specificați o adresă goală. Acest lucru poate fi anulat din mers cu variabila de mediu DEBCONF_ADMIN_EMAIL.

note: type: Plain text
en: If set, this will cause debconf to output debugging information to standard error. The value it is set to can be something like "user", "developer", "db", or a regular expression. Typically, rather than setting it permanently in a config file, you will only want to temporarily turn on debugging, and the DEBCONF_DEBUG environment variable can be set instead to accomplish that.
ro: Dacă este activată, aceasta va determina debconf să emită informații de depanare la ieșirea de eroare standard. Valoarea la care este definită poate fi ceva de genul „user”, „developer”, „db” sau o expresie regulată. De obicei, mai degrabă decât să o definiți permanent într-un fișier de configurare, veți dori doar să activați temporar depanarea, iar variabila de mediu DEBCONF_DEBUG poate fi definită pentru a realiza acest lucru.

note: type: Plain text
en: If set, this will make debconf not display warnings about various things.  This can be overridden on the fly with the DEBCONF_NOWARNINGS environment variable.
ro: Dacă este activată, aceasta va face ca debconf să nu afișeze avertismente cu privire la diverse lucruri. Acest lucru poate fi anulat din mers cu variabila de mediu DEBCONF_NOWARNINGS.

note: type: Plain text
en: Makes debconf log debugging information as it runs, to the syslog. The value it is set to controls that is logged. See Debug, above for an explanation of the values that can be set to control what is logged.
ro: Face ca debconf să înregistreze informațiile de depanare pe măsură ce rulează, în syslog. Valoarea la care este definită controlează ceea ce este înregistrat. Consultați Debug, mai sus, pentru o explicație a valorilor care pot fi definite pentru a controla ceea ce este înregistrat.

note: type: Plain text
en: If set to "true", makes some debconf frontends use a special terse display mode that outputs as little as possible. Defaults to false. Terse mode may be temporarily set via the DEBCONF_TERSE environment variable.
ro: Dacă este stabilită la „true”, face ca unele interfețe debconf să utilizeze un mod special de afișare laconică care afișează cât mai puțin posibil. Valoarea implicită este „false”. Modul „Terse” (laconic) poate fi activat temporar prin intermediul variabilei de mediu DEBCONF_TERSE.

note: type: Plain text
en: For example, the first stanza of a file might look like this:
      Config: configdb
      Templates: templatedb
ro: De exemplu, prima strofă a unui fișier poate arăta astfel:
      Config: configdb
      Templates: templatedb

note: type: Plain text
en: Each remaining stanza in the file sets up a database. A database stanza
    begins by naming the database:
      Name: configdb
ro: Fiecare strofă rămasă în fișier stabilește o bază de date. O strofă de bază de date
    începe prin numirea bazei de date:
      Name: configdb

note: type: Plain text
en: Then it indicates what database driver should be used for this database.
    See DRIVERS, below, for information about what drivers are available.
      Driver: File
ro: Apoi indică ce sistem de control (driver) de bază de date ar trebui utilizat pentru această bază de date.
    Consultați SISTEME DE CONTROL, mai jos, pentru informații despre sistemele de control disponibile.
      Driver: File

note: type: Plain text
en: You can indicate that the database is not essential to the proper
    functioning of debconf by saying it is not required. This will make debconf
    muddle on if the database fails for some reason.
      Required: false
ro: Puteți indica faptul că baza de date nu este esențială pentru buna funcționare
    a debconf prin a spune că nu este necesară. Acest lucru va face ca debconf
    să meargă mai departe dacă baza de date eșuează din anumite motive.
      Required: false

note: type: Plain text
en: You can mark any database as readonly and debconf will not write anything
    to it.
      Readonly: true
ro: Puteți marca orice bază de date ca „readonly” (numai-citire) și debconf nu
    va scrie nimic în ea.
      Readonly: true

note: type: Plain text
en: You can also limit what types of data can go into the database with Accept- and Reject- lines; see ACCESS CONTROLS, below.
ro: De asemenea, puteți limita tipurile de date care pot intra în baza de date cu ajutorul liniilor Accept- și Reject-; a se vedea CONTROLUL ACCESULUI, mai jos.

note: type: Plain text
en: The remainder of each database stanza is used to provide configuration
    specific to that driver. For example, the Text driver needs to know
    a directory to put the database in, so you might say:
      Filename: /var/cache/debconf/config.dat
ro: Restul fiecărei strofe a bazei de date este utilizat pentru a furniza
    configurația specifică sistemului de control (driver) respectiv. De exemplu,
    sistemul de control „Text” trebuie să știe că are un director în care să
    plaseze baza de date, așa că puteți spune:
      Filename: /var/cache/debconf/config.dat

note: type: SH
en: DRIVERS
ro: SISTEME DE CONTROL

note: type: Plain text
en: A number of drivers are available, and more can be written with little difficulty. Drivers come in two general types. First there are real drivers -- drivers that actually access and store data in some kind of database, which might be on the local filesystem, or on a remote system. Then there are meta-drivers that combine other drivers together to form more interesting systems. Let's start with the former.
ro: Există o serie de sisteme de control (drivers) disponibile, iar altele pot fi scrise cu puțină dificultate. Sistemele de control sunt în general de două tipuri. În primul rând, există sisteme de control reale - sisteme de control care accesează și stochează efectiv date într-un anumit tip de bază de date, care poate fi pe sistemul de fișiere local sau pe un sistem de la distanță. Apoi există meta-sisteme de control care combină alte sisteme de control pentru a forma sisteme mai interesante. Să începem cu primele.

note: type: Plain text
en: This database driver allows debconf to store a whole database in a single flat text file. This makes it easy to archive, transfer between machines, and edit. It is one of the more compact database formats in terms of disk space used. It is also one of the slowest.
ro: Acest sistem de control de bază de date permite debconf să stocheze o întreagă bază de date într-un singur fișier text plat. Acest lucru facilitează arhivarea, transferul între mașini și editarea. Este unul dintre cele mai compacte formate de baze de date în ceea ce privește spațiul utilizat pe disc. Este, de asemenea, unul dintre cele mai lente.

note: type: Plain text
en: On the downside, the entire file has to be read in each time debconf starts up, and saving it is also slow.
ro: Pe de altă parte, întregul fișier trebuie să fie citit de fiecare dată când debconf pornește, iar salvarea acestuia este, de asemenea, lentă.

note: type: Plain text
en: The following things are configurable for this driver.
ro: Următoarele lucruri sunt configurabile pentru acest sistem de control.

note: type: Plain text
en: The file to use as the database. This is a required field.
ro: Fișierul care urmează să fie utilizat ca bază de date. Acesta este un câmp obligatoriu.

note: type: Plain text
en: The permissions to create the file with if it does not exist. Defaults to 600, since the file could contain passwords in some circumstances.
ro: Permisiunile cu care se creează fișierul dacă acesta nu există. Valoarea implicită este 600, deoarece fișierul ar putea conține parole în anumite circumstanțe.

note: type: Plain text
en: The format of the file. See FORMATS below. Defaults to using a rfc-822 like format.
ro: Formatul fișierului. Consultați secțiunea FORMATE de mai jos. În mod implicit se utilizează un format asemănător formatului rfc-822.

note: type: Plain text
en: Whether a backup should be made of the old file before changing it.  Defaults to true.
ro: Dacă ar trebui făcută o copie de rezervă a fișierului vechi înainte de a-l modifica. Valoarea implicită este „true”.

note: type: Plain text
en: As example stanza setting up a database using this driver:
ro: Ca exemplu de configurare a unei baze de date folosind acest sistem de control:

note: type: Plain text
en: This database driver allows debconf to store data in a hierarchical directory structure. The names of the various debconf templates and questions are used as-is to form directories with files in them. This format for the database is the easiest to browse and fiddle with by hand.  It has very good load and save speeds. It also typically occupies the most space, since a lot of small files and subdirectories do take up some additional room.
ro: Acest sistem de control de bază de date permite debconf să stocheze date într-o structură ierarhică de directoare. Numele diferitelor șabloane și întrebări debconf sunt utilizate ca atare pentru a forma directoare cu fișiere în ele. Acest format pentru baza de date este cel mai ușor de navigat și de manipulat manual. Are viteze foarte bune de încărcare și salvare. De asemenea, ocupă de obicei cel mai mult spațiu, deoarece o mulțime de fișiere mici și subdirectoare ocupă spațiu suplimentar.

note: type: Plain text
en: The directory to put the files in. Required.
ro: Directorul în care se pun fișierele. Necesar.

note: type: Plain text
en: An extension to add to the names of files. Must be set to a non-empty string; defaults to ".dat"
ro: O extensie de adăugat la numele fișierelor. Trebuie să fie definită cu un șir nevid; valoarea implicită este „.dat”

note: type: Plain text
en: This database driver is a compromise between the File and DirTree databases. It uses a directory, in which there is (approximately) one file per package that uses debconf. This is fairly fast, while using little more room than the File database driver.
ro: Acest sistem de control de bază de date este un compromis între bazele de date „File” și „DirTree”. Acesta utilizează un director, în care există (aproximativ) un fișier pentru fiecare pachet care utilizează debconf. Acest lucru este destul de rapid, în timp ce utilizează puțin mai mult spațiu decât sistemul de control de bază de date „File”.

note: type: Plain text
en: This driver is configurable in the same ways as is the DirTree driver, plus:
ro: Acest sistem de control este configurabil în aceleași moduri ca și sistemul de control „DirTree”, plus:

note: type: Plain text
en: The permissions to create files with. Defaults to 600, since the files could contain passwords in some circumstances.
ro: Permisiunile cu care se creează fișierele. Valoarea implicită este 600, deoarece fișierele ar putea conține parole în anumite circumstanțe.

note: type: Plain text
en: WARNING: This database driver is currently experimental. Use with caution.
ro: AVERTISMENT: Acest sistem de control de bază de date este în prezent experimental. Utilizați-l cu precauție.

note: type: Plain text
en: This database driver accesses a LDAP directory for debconf configuration data. Due to the nature of the beast, LDAP directories should typically be accessed in read-only mode. This is because multiple accesses can take place, and it's generally better for data consistency if nobody tries to modify the data while this is happening. Of course, write access is supported for those cases where you do want to update the config data in the directory.
ro: Acest sistem de control de bază de date accesează un director LDAP pentru datele de configurare debconf. Datorită naturii acestui mecanism, directoarele LDAP ar trebui accesate în mod normal în modul numai citire. Acest lucru se datorează faptului că pot avea loc accesări multiple și, în general, este mai bine pentru consistența datelor dacă nimeni nu încearcă să modifice datele în acest timp. Desigur, accesul în scris este acceptat pentru acele cazuri în care doriți să actualizați datele de configurare din director.

note: type: Plain text
en: For information about setting up a LDAP server for debconf, read /usr/share/doc/debconf-doc/README.LDAP (from the debconf-doc package).
ro: Pentru informații despre configurarea unui server LDAP pentru debconf, citiți „/usr/share/doc/debconf-doc/README.LDAP” (din pachetul „debconf-doc”).

note: type: Plain text
en: To use this database driver, you must have the libnet-ldap-perl package installed. Debconf suggests that package, but does not depend on it.
ro: Pentru a utiliza acest sistem de control de bază de date, trebuie să aveți instalat pachetul „libnet-ldap-perl”. debconf sugerează acest pachet, dar nu depinde de el.

note: type: Plain text
en: Please carefully consider the security implications of using a remote debconf database. Unless you trust the source, and you trust the intervening network, it is not a very safe thing to do.
ro: Vă rugăm să analizați cu atenție implicațiile de securitate ale utilizării unei baze de date debconf la distanță. Dacă nu aveți încredere în sursă și în rețeaua care intervine, nu este un lucru foarte sigur de făcut.

note: type: Plain text
en: The host name or IP address of an LDAP server to connect to.
ro: Numele gazdei sau adresa IP a unui server LDAP la care să se efectueze conectarea.

note: type: Plain text
en: The port on which to connect to the LDAP server. If none is given, the default port is used.
ro: Portul la care se face conectarea la serverul LDAP. Dacă nu este dat niciunul, este utilizat portul implicit.

note: type: Plain text
en: The DN under which all config items will be stored. Each config item will be assumed to live in a DN of cn=E<lt>item nameE<gt>,E<lt>Base DNE<gt>. If this structure is not followed, all bets are off.
ro: DN-ul sub care vor fi stocate toate elementele de configurare. Se presupune că fiecare element de configurare va trăi într-un DN de tipul cn=E<lt>numele elementuluiE<gt>,E<lt>DN de bazăE<gt>. Dacă această structură nu este respectată, toate pariurile sunt închise...

note: type: Plain text
en: The DN to bind to the directory as. Anonymous bind will be used if none is specified.
ro: DN-ul pentru conectarea la director. Dacă nu este specificat niciunul, se va utiliza legătura anonimă.

note: type: Plain text
en: The password to use in an authenticated bind (used with binddn, above). If not specified, anonymous bind will be used.
ro: Parola care urmează să fie utilizată într-o legătură autentificată (utilizată cu binddn, mai sus). Dacă nu este specificată, se va utiliza legătura anonimă.

note: type: Plain text
en: This option should not be used in the general case. Anonymous binding should be sufficient most of the time for read-only access. Specifying a bind DN and password should be reserved for the occasional case where you wish to update the debconf configuration data.
ro: Această opțiune nu ar trebui utilizată în cazul general. Legarea anonimă ar trebui să fie suficientă de cele mai multe ori pentru accesul doar la citire. Specificarea unui DN și a unei parole de conectare ar trebui rezervată pentru cazurile ocazionale în care doriți să actualizați datele de configurare debconf.

note: type: Plain text
en: Enable access to individual LDAP entries, instead of fetching them all at once in the beginning. This is very useful if you want to monitor your LDAP logs for specific debconf keys requested. In this way, you could also write custom handling code on the LDAP server part.
ro: Activează accesul la intrări LDAP individuale, în loc de a le prelua pe toate odată la început. Acest lucru este foarte util dacă doriți să monitorizați jurnalele LDAP pentru anumite chei debconf solicitate. În acest fel, ați putea scrie, de asemenea, cod de manipulare personalizat pe partea serverului LDAP.

note: type: Plain text
en: Note that when this option is enabled, the connection to the LDAP server is kept active during the whole Debconf run. This is a little different from the all-in-one behavior where two brief connections are made to LDAP; in the beginning to retrieve all the entries, and in the end to save eventual changes.
ro: Rețineți că atunci când această opțiune este activată, conexiunea la serverul LDAP este menținută activă pe parcursul întregii execuții Debconf. Acest lucru este puțin diferit de comportamentul „toate în una” în care se fac două conexiuni scurte la LDAP; la început pentru a prelua toate intrările și la sfârșit pentru a salva eventualele modificări.

note: type: Plain text
en: An example stanza setting up a database using this driver, assuming the remote database is on example.com and can be accessed anonymously:
ro: Un exemplu de strofă care configurează o bază de date utilizând acest sistem de control, presupunând că baza de date de la distanță se află pe example.com și poate fi accesată anonim:

note: type: Plain text
en: Another example, this time the LDAP database is on localhost, and can be written to:
ro: Un alt exemplu, de data aceasta baza de date LDAP este pe localhost și se poate scrie în ea:

note: type: Plain text
en: This special-purpose database driver reads and writes the database from standard input/output. It may be useful for people with special needs.
ro: Acest sistem de control de bază de date cu scop special citește și scrie baza de date de la intrarea/ieșirea standard. Poate fi util pentru persoanele cu nevoi speciale.

note: type: Plain text
en: The format to read and write. See FORMATS below. Defaults to using a rfc-822 like format.
ro: Formatul pentru citire și scriere. Consultați secțiunea FORMATE de mai jos. În mod implicit se utilizează un format asemănător formatului rfc-822.

note: type: Plain text
en: File descriptor number to read from. Defaults to reading from stdin. If set to "none", the database will not read any data on startup.
ro: Numărul descriptorului de fișier din care se citește. Valoarea implicită este citirea de la intrarea standard. Dacă este definit la „none”, baza de date nu va citi niciun fel de date la pornire.

note: type: Plain text
en: File descriptor number to write to. Defaults to writing to stdout. If set to "none", the database will be thrown away on shutdown.
ro: Numărul descriptorului de fișier în care se scrie. În mod implicit, se scrie la ieșirea standard. Dacă este definit la „none”, baza de date va fi înlăturată la închidere.

note: type: Plain text
en: That's all of the real drivers, now moving on to meta-drivers..
ro: Aceștia sunt toate sistemele control reale, acum trecem la meta-sistemele de control.

note: type: Plain text
en: This driver stacks up a number of other databases (of any type), and allows them to be accessed as one. When debconf asks for a value, the first database on the stack that contains the value returns it. If debconf writes something to the database, the write normally goes to the first driver on the stack that has the item debconf is modifying, and if none do, the new item is added to the first writable database on the stack.
ro: Acest sistem de control stivuiește un număr de alte baze de date (de orice tip) și le permite să fie accesate ca una singură. Atunci când debconf solicită o valoare, prima bază de date din stivă care conține valoarea o returnează. Dacă debconf scrie ceva în baza de date, scrierea se face în mod normal în primul sistem de control din stivă care are elementul pe care debconf îl modifică, iar dacă nu există niciunul, noul element este adăugat la prima bază de date din stivă care poate fi scrisă.

note: type: Plain text
en: Things become more interesting if one of the databases on the stack is readonly. Consider a stack of the databases foo, bar, and baz, where foo and baz are both readonly. Debconf wants to change an item, and this item is only present in baz, which is readonly. The stack driver is smart enough to realize that won't work, and it will copy the item from baz to bar, and the write will take place in bar. Now the item in baz is shadowed by the item in bar, and it will not longer be visible to debconf.
ro: Lucrurile devin mai interesante dacă una dintre bazele de date din stivă este numai-pentru-citire. „readonly”. Luați în considerare o stivă de baze de date I<foo>, I<bar> și I<baz>, unde I<foo> și I<baz> sunt ambele numai-pentru-citire. Debconf dorește să schimbe un element, iar acest element este prezent doar în I<baz>, care este numai-pentru-citire. Sistemul de control de stivă „stack” este suficient de inteligent pentru a realiza că nu va funcționa și va copia elementul din I<baz> în I<bar>, iar scrierea va avea loc în I<bar>. Acum elementul din I<baz> este umbrit de elementul din I<bar> și nu va mai fi vizibil pentru debconf.

note: type: Plain text
en: This kind of thing is particularly useful if you want to point many systems at a central, readonly database, while still allowing things to be overridden on each system. When access controls are added to the picture, stacks allow you to do many other interesting things, like redirect all passwords to one database while a database underneath it handles everything else.
ro: Acest tip de lucru este deosebit de util în cazul în care doriți să direcționați mai multe sisteme către o bază de date centrală, numai pentru citire, permițând în același timp ca anumite lucruri să fie anulate pe fiecare sistem. Atunci când se adaugă controlul accesului, stivele vă permit să faceți multe alte lucruri interesante, cum ar fi redirecționarea tuturor parolelor către o bază de date, în timp ce o bază de date aflată sub aceasta se ocupă de orice altceva.

note: type: Plain text
en: Only one piece of configuration is needed to set up a stack:
ro: Pentru a configura o stivă „stack” , este necesară o singură piesă de configurare:

note: type: Plain text
en: This is where you specify a list of other databases, by name, to tell it what makes up the stack.
ro: Aici specificați o listă de alte baze de date, după nume, pentru a-i spune ce alcătuiește stiva.

note: type: Plain text
en: For example:
ro: De exemplu:

note: type: Plain text
en: WARNING: The stack driver is not very well tested yet. Use at your own risk.
ro: AVERTISMENT: Sistemul de control de stivă „stack” nu este încă foarte bine testat. Utilizați-l pe propriul risc.

note: type: Plain text
en: This driver passes all requests on to another database driver. But it also copies all write requests to a backup database driver.
ro: Acest sistem de control transmite toate cererile către un alt sistem de control de bază de date. Dar, de asemenea, copiază toate cererile de scriere către un sistem de control de bază de date de rezervă.

note: type: Plain text
en: You must specify the following fields to set up this driver:
ro: Trebuie să specificați următoarele câmpuri pentru a configura acest sistem de control de baze de date:

note: type: Plain text
en: The database to read from and write to.
ro: Baza de date din care se citește și în care se scrie.

note: type: Plain text
en: The name of the database to send copies of writes to.
ro: Numele bazei de date către care se trimit copii ale scrierilor.

note: type: Plain text
en: This driver passes all requests on to another database driver, outputting verbose debugging output about the request and the result.
ro: Acest sistem de control transmite toate cererile către un alt sistem de control de bază de date, generând un rezultat de depanare detaliat cu privire la cerere și la rezultat.

note: type: SH
en: ACCESS CONTROLS
ro: CONTROLUL ACCESULUI

note: type: Plain text
en: When you set up a database, you can also use some fields to specify access controls. You can specify that a database only accepts passwords, for example, or make a database only accept things with "foo" in their name.
ro: Atunci când configurați o bază de date, puteți, de asemenea, să utilizați anumite câmpuri pentru a specifica controlul accesului. De exemplu, puteți specifica că o bază de date acceptă numai parole sau că o bază de date acceptă numai lucruri cu „foo” în nume.

note: type: Plain text
en: As was mentioned earlier, this access control, if set to "true", makes a database readonly. Debconf will read values from it, but will never write anything to it.
ro: După cum s-a menționat mai înainte, acest control de acces, dacă este stabilit la „true”, face ca o bază de date să fie de tip „readonly”, numai-pentru-citire. Debconf va citi valori din aceasta, dar nu va scrie niciodată nimic în ea.

note: type: Plain text
en: The text in this field is a perl-compatible regular expression that is matched against the names of items as they are requested from the database. Only if an items name matches the regular expression, will the database allow debconf to access or modify it.
ro: Textul din acest câmp este o expresie regulată compatibilă perl care este comparată cu numele elementelor pe măsură ce acestea sunt solicitate din baza de date. Numai dacă numele unui element corespunde expresiei regulate, baza de date va permite debconf să îl acceseze sau să îl modifice.

note: type: Plain text
en: Like Accept-Name, except any item name matching this regular expression will be rejected.
ro: La fel ca Accept-Name, cu excepția faptului că orice nume de element care corespunde acestei expresii regulate va fi respins.

note: type: Plain text
en: Another regular expression, this matches against the type of the item that is being accessed. Only if the type matches the regex will access be granted.
ro: O altă expresie regulată, aceasta se potrivește cu tipul elementului care este accesat. Accesul va fi permis numai dacă tipul corespunde expresiei regulate.

note: type: Plain text
en: Like Accept-Type, except any type matching this regular expression will be rejected.
ro: La fel ca Accept-Type, cu excepția faptului că orice tip care corespunde acestei expresii regulate va fi respins.

note: type: SH
en: FORMATS
ro: FORMATE

note: type: Plain text
en: Some of the database drivers use format modules to control the actual format in which the database is stored on disk. These formats are currently supported:
ro: Unele dintre sistemele de control de baze de date utilizează module de format pentru a controla formatul real în care baza de date este stocată pe disc. Acestea sunt formatele acceptate în prezent:

note: type: Plain text
en: This is a file format loosely based upon the rfc-822 format for email message headers. Similar formats are used throughout Debian; in the dpkg status file, and so on.
ro: Acesta este un format de fișier bazat în mare măsură pe formatul rfc-822 pentru antetele mesajelor de poștă electronică. Formate similare sunt folosite în cadrul Debian; în fișierul de stare (status) dpkg, și așa mai departe.

note: type: Plain text
en: Here is a more complicated example of a debconf.conf file.
ro: Iată un exemplu mai complicat de fișier debconf.conf.

note: type: Plain text
en:   # This stanza is used for general debconf setup.
      Config: stack
      Templates: templates
      Log: developer
      Debug: developer
ro:   # Această strofă este utilizată pentru configurarea
      # generală a debconf.
      Config: stack
      Templates: templates
      Log: developer
      Debug: developer

note: type: Plain text
en:   # This is my own local database.
      Name: mydb
      Driver: DirTree
      Directory: /var/cache/debconf/config
ro:   # Aceasta este propria mea bază de date locală.
      Name: mydb
      Driver: DirTree
      Directory: /var/cache/debconf/config

note: type: Plain text
en:   # This is another database that I use to hold
      # only X server configuration.
      Name: X
      Driver: File
      Filename: /etc/X11/debconf.dat
      Mode: 644
      # It's sorta hard to work out what questions
      # belong to X; it should be using a deeper
      # tree structure so I could just match on ^X/
      # Oh well.
      Accept-Name: xserver|xfree86|xbase
ro:   # Aceasta este o altă bază de date pe care o folosesc
      # pentru a păstra doar configurația serverului X.
      Name: X
      Driver: File
      Filename: /etc/X11/debconf.dat
      Mode: 644
      # Este cam greu să-mi dau seama ce întrebări
      # aparțin lui X; ar trebui să folosească o structură
      # arborescentă mai profundă, astfel încât să pot
      # face potrivire doar pentru ^X/
      # În fine.
      Accept-Name: xserver|xfree86|xbase

note: type: Plain text
en:   # This is our company's global, read-only
      # (for me!) debconf database.
      Name: company
      Driver: LDAP
      Server: debconf.foo.com
      BaseDN: cn=debconf,dc=foo,dc=com
      BindDN: uid=admin,dc=foo,dc=com
      BindPasswd: secret
      Readonly: true
      # I don't want any passwords that might be
      # floating around in there.
      Reject-Type: password
      # If this db is not accessible for whatever
      # reason, carry on anyway.
      Required: false
ro:   # Aceasta este baza de date debconf globală,
      # numai-citire (pentru mine!) a companiei noastre.
      Name: company
      Driver: LDAP
      Server: debconf.foo.com
      BaseDN: cn=debconf,dc=foo,dc=com
      BindDN: uid=admin,dc=foo,dc=com
      BindPasswd: secret
      Readonly: true
      # Nu vreau nicio parolă care ar putea
      # să se afle pe acolo.
      Reject-Type: password
      # Dacă această BD nu este accesibilă
      # din orice motiv, continuă oricum.
      Required: false

note: type: Plain text
en:   # I use this database to hold
      # passwords safe and secure.
      Name: passwords
      Driver: File
      Filename: /etc/debconf/passwords
      Mode: 600
      Accept-Type: password
ro:   # Folosesc această bază de date
      # pentru a păstra parolele în siguranță.
      Name: passwords
      Driver: File
      Filename: /etc/debconf/passwords
      Mode: 600
      Accept-Type: password

note: type: Plain text
en:   # Let's put them all together
      # in a database stack.
      Name: stack
      Driver: Stack
      Stack: passwords, X, mydb, company
      # So, all passwords go to the password database.
      # Most X configuration stuff goes to the X
      # database, and anything else goes to my main
      # database. Values are looked up in each of those
      # in turn, and if none has a particular value, it
      # is looked up in the company-wide LDAP database
      # (unless it's a password).
ro:   # Să le punem pe toate împreună într-o bază de date.
      # in a database stack.
      Name: stack
      Driver: Stack
      Stack: passwords, X, mydb, company
      # Astfel, toate parolele ajung în baza de date a parolelor.
      # Cele mai multe lucruri legate de configurarea X se duc
      # în baza de date X, iar orice altceva se duce în baza mea
      # de date principală. Valorile sunt căutate pe rând în fiecare
      # dintre acestea, iar dacă niciuna nu are o anumită valoare,
      # aceasta este căutată în baza de date LDAP a întregii
      # companii (cu excepția cazului în care este o parolă).

note: type: Plain text
en:   # A database is also used to hold templates. We
      # don't need to make this as fancy.
      Name: templates
      Driver: File
      Mode: 644
      Format: 822
      Filename: /var/cache/debconf/templates
ro:   # O bază de date este, de asemenea, utilizată pentru
      # a păstra șabloanele. Nu este nevoie să o facem
      # la fel de sofisticată.
      Name: templates
      Driver: File
      Mode: 644
      Format: 822
      Filename: /var/cache/debconf/templates

note: type: SH
en: NOTES
ro: NOTE

note: type: Plain text
en: If you use something like ${HOME} in this file, it will be replaced with the value of the named environment variable.
ro: Dacă utilizați ceva de genul ${HOME} în acest fișier, aceasta va fi înlocuită cu valoarea variabilei de mediu numită.

note: type: Plain text
en: Environment variables can also be used to override the databases on the fly, see B<debconf>(7)
ro: Variabilele de mediu pot fi de asemenea utilizate pentru a suprascrie bazele de date din mers, a se vedea B<debconf>(7)

note: type: Plain text
en: The field names (the part of the line before the colon) is case-insensitive. The values, though, are case sensitive.
ro: Numele câmpurilor (partea de linie înainte de două puncte) nu sunt sensibile la majuscule. Valorile, însă, sunt sensibile la majuscule.

note: type: SH
en: PLANNED ENHANCEMENTS
ro: ÎMBUNĂTĂȚIRI PLANIFICATE

note: type: Plain text
en: More drivers and formats. Some ideas include: A SQL driver, with the capability to access a remote database.  A DHCP driver, that makes available some special things like hostname, IP address, and DNS servers.  A driver that pulls values out of public DNS records TXT fields.  A format that is compatible with the output of cdebconf.  An override driver, which can override the value field or flags of all requests that pass through it.
ro: Mai multe sisteme de control și formate. Unele idei includ: un sistem de control „SQL”, cu capacitatea de a accesa o bază de date la distanță. Un sistem de control „DHCP,” care pune la dispoziție unele lucruri speciale, cum ar fi numele de gazdă, adresa IP și serverele DNS. Un sistem de control care extrage valori din câmpurile TXT ale înregistrărilor DNS publice. Un format care este compatibil cu rezultatul cdebconf. Un sistem de control de suprascriere, care poate suprascrie câmpul de valori sau fanioanele tuturor cererilor care trec prin el.

note: type: SH
en: FILES
ro: FIȘIERE

note: type: Plain text
en: confmodule - communicate with Debian configuration system FrontEnd.
ro: confmodule - comunică cu interfața sistemului de configurare Debian

note: type: Plain text
en: This is a library of shell functions that eases communication with Debian's configuration management system. It can communicate with a FrontEnd via the debconf protocol. The design is that each command in the protocol is represented by one function in this module. The functionname is the same as the command, except it is prefixed with "db_" and is lower-case. Call the function and pass in any parameters you want to follow the command. Any textual return code from the FrontEnd will be returned to you in the $RET variable, while the numeric return code from the FrontEnd will be returned as a return code (and so those return codes must be captured or ignored).
ro: Aceasta este o bibliotecă de funcții shell care facilitează comunicarea cu sistemul de gestionare a configurației Debian. Poate comunica cu o interfață prin protocolul debconf. Conceptul este că fiecare comandă din protocol este reprezentată de o funcție în acest modul. Numele funcției este același cu al comenzii, cu excepția faptului că este prefixat cu „db_” și este scris cu minuscule. Apelați la funcție și introduceți orice parametru care urmează comenzii. Orice cod de returnare textual de la interfață vă va fi returnat în variabila $RET, în timp ce codul de returnare numeric de la interfață va fi returnat ca un cod de returnare (și astfel aceste coduri de returnare trebuie capturate sau ignorate).

note: type: Plain text
en: Once this library is loaded, any text you later output will go to standard
    error, rather than standard output. This is a good thing in general, because
    text sent to standard output is interpreted by the FrontEnd as commands. If
    you do want to send a command directly to the FrontEnd, you must output it
    to file descriptor 3, like this:
      echo GET foo/bar E<gt>&3
ro: Odată ce această bibliotecă este încărcată, orice text pe care îl scoateți
    ulterior va fi trimis la ieșirea de eroare standard, în loc de la ieșirea
    standard. Acesta este un lucru bun în general, deoarece textul trimis la
    ieșirea standard este interpretat de interfață ca o comandă. Dacă doriți să
    trimiteți o comandă direct către interfață, trebuie să o trimiteți la
    descriptorul de fișier 3, astfel:
      echo GET foo/bar E<gt>&3

note: type: Plain text
en: The library checks to make sure it is actually speaking to a FrontEnd by examining the DEBIAN_HAS_FRONTEND variable. If it is set, a FrontEnd is assumed to be running. If not, the library turns into one, and runs a copy of the script that loaded the library connected to it. This means that if you source this library, you should do so very near to the top of your script, because everything before the sourcing of the library may well be run again.
ro: Biblioteca verifică dacă comunică efectiv cu o interfață prin examinarea variabilei DEBIAN_HAS_FRONTEND. Dacă aceasta este definită, se presupune că rulează o interfață. Dacă nu, biblioteca se transformă într-una și rulează o copie a scriptului care a încărcat biblioteca conectată la ea. Aceasta înseamnă că, dacă obțineți sursa acestei biblioteci, ar trebui să o faceți foarte aproape de partea de sus a scriptului, deoarece este foarte posibil ca tot ceea ce precede obținerea sursei bibliotecii să fie executat din nou.

note: type: Plain text
en: B<debconf-devel>(7), B<dpkg-preconfigure>(8), B<dpkg-reconfigure>(8), debconf_specification in the debian-policy package
ro: B<debconf-devel>(7), B<dpkg-preconfigure>(8), B<dpkg-reconfigure>(8), debconf_specification în pachetul debian-policy

note: type: Plain text
en: debconf - Debian package configuration system
ro: debconf - sistemul de configurare a pachetelor Debian

note: type: Plain text
en: Debconf is a configuration system for Debian packages. There is a rarely-used command named debconf, documented in B<debconf>(1)
ro: Debconf este un sistem de configurare pentru pachetele Debian. Există o comandă rar utilizată numită debconf, documentată în B<debconf>(1)

note: type: Plain text
en: Debconf provides a consistent interface for configuring packages, allowing you to choose from several user interface frontends. It supports preconfiguring packages before they are installed, which allows large installs and upgrades to ask you for all the necessary information up front, and then go do the work while you do something else. It lets you, if you're in a hurry, skip over less important questions and information while installing a package (and revisit it later).
ro: Debconf oferă o interfață consistentă pentru configurarea pachetelor, permițându-vă să alegeți din mai multe interfețe de utilizator. Aceasta oferă suport pentru preconfigurarea pachetelor înainte ca acestea să fie instalate, ceea ce permite instalărilor și actualizărilor de mari dimensiuni să vă ceară toate informațiile necesare în prealabil și apoi să facă treaba în timp ce dumneavoastră faceți altceva. Vă permite, dacă vă grăbiți, să săriți peste întrebările și informațiile mai puțin importante în timpul instalării unui pachet (și să reveniți asupra acestora mai târziu).

note: type: SH
en: Preconfiguring packages
ro: Preconfigurarea pachetelor

note: type: Plain text
en: Debconf can configure packages before they are even installed onto your system. This is useful because it lets all the questions the packages are going to ask be asked at the beginning of an install, so the rest of the install can proceed while you are away getting a cup of coffee.
ro: Debconf poate configura pachetele chiar înainte ca acestea să fie instalate în sistemul dumneavoastră. Acest lucru este util deoarece permite ca toate întrebările pe care pachetele le vor pune să fie adresate la începutul unei instalări, astfel încât restul instalării să poată continua în timp ce sunteți plecat să serviți o ceașcă de cafea.

note: type: Plain text
en: If you use apt (version 0.5 or above), and you have apt-utils installed, each package apt installs will be automatically preconfigured. This is controlled via I</etc/apt/apt.conf.d/70debconf>
ro: Dacă utilizați apt (versiunea 0.5 sau ulterioară) și aveți instalat apt-utils, fiecare pachet instalat de apt va fi preconfigurat automat. Acest lucru este controlat prin intermediul I</etc/apt/apt.conf.d/70debconf>

note: type: Plain text
en: Sometimes you might want to preconfigure a package by hand, when you're not installing it with apt. You can use B<dpkg-preconfigure>(8)  to do that, just pass it the filenames of the packages you want to preconfigure. You will need apt-utils installed for that to work.
ro: Uneori s-ar putea să doriți să preconfigurați un pachet manual, atunci când nu îl instalați cu apt. Puteți utiliza B<dpkg-preconfigure>(8) pentru a face acest lucru, doar treceți-i numele de fișiere ale pachetelor pe care doriți să le preconfigurați. Veți avea nevoie de apt-utils instalat pentru ca acest lucru să funcționeze.

note: type: SH
en: Reconfiguring packages
ro: Reconfigurarea pachetelor

note: type: Plain text
en: Suppose you installed the package, and answered debconf's questions, but now that you've used it awhile, you realize you want to go back and change some of your answers. In the past, reinstalling a package was often the thing to do when you got in this situation, but when you reinstall the package, debconf seems to remember you have answered the questions, and doesn't ask them again (this is a feature).
ro: Să presupunem că ați instalat pachetul și ați răspuns la întrebările lui debconf, dar acum că l-ați folosit o vreme, vă dați seama că doriți să reveniți și să modificați unele dintre răspunsurile dumneavoastră. În trecut, reinstalarea unui pachet era adesea lucrul care trebuia făcut atunci când erați în această situație, dar atunci când reinstalați pachetul, debconf pare să își amintească că ați răspuns la întrebări și nu le mai pune din nou (aceasta este o caracteristică).

note: type: Plain text
en: Luckily, debconf makes it easy to reconfigure any package that uses it.
    Suppose you want to reconfigure debconf itself. Just run, as root:
      dpkg-reconfigure debconf
ro: Din fericire, debconf facilitează reconfigurarea oricărui pachet care îl utilizează. Să presupunem că doriți să reconfigurați chiar debconf. Trebuie doar să rulați, ca root:
      dpkg-reconfigure debconf

note: type: Plain text
en: This will ask all the questions you saw when debconf was first installed.  It may ask you other questions as well, since it asks even low priority questions that may have been skipped when the package was installed.  You can use it on any other package that uses debconf, as well.
ro: Aceasta va pune toate întrebările pe care le-ați văzut când debconf a fost instalat prima dată. Este posibil să vă pună și alte întrebări, deoarece pune chiar și întrebări cu prioritate scăzută care ar fi putut fi omise atunci când pachetul a fost instalat. Îl puteți utiliza și pe orice alt pachet care utilizează debconf.

note: type: SH
en: Frontends
ro: Interfețe

note: type: Plain text
en: One of debconf's unique features is that the interface it presents to you is only one of many, that can be swapped in at will. There are many debconf frontends available:
ro: Una dintre caracteristicile unice ale debconf este faptul că interfața pe care v-o prezintă este doar una dintre multe altele, care pot fi schimbate după bunul plac. Există multe interfețe debconf disponibile:

note: type: Plain text
en: The default frontend, this uses the B<whiptail>(1)  or B<dialog>(1)  programs to display questions to you. It works in text mode.
ro: Interfața implicită, aceasta utilizează programele B<whiptail>(1) sau B<dialog>(1) pentru a vă afișa întrebările. Aceasta funcționează în modul text.

note: type: Plain text
en: The most traditional frontend, this looks quite similar to how Debian configuration always has been: a series of questions, printed out at the console using plain text, and prompts done using the readline library. It even supports tab completion. The libterm-readline-gnu-perl package is strongly recommended if you chose to use this frontend; the default readline module does not support prompting with default values.  At the minimum, you'll need the perl-modules package installed to use this frontend.
ro: Cea mai tradițională interfață, aceasta arată destul de asemănător cu modul în care a fost întotdeauna configurarea Debian: o serie de întrebări, afișate la consolă folosind text simplu, și solicitări realizate folosind biblioteca readline. Oferă chiar și suport pentru completarea cu tabulatorul. Pachetul libterm-readline-gnu-perl este foarte recomandat dacă alegeți să utilizați această interfață; modulul readline implicit nu acceptă solicitarea cu valori implicite.  Cel puțin, veți avea nevoie de pachetul perl-modules instalat pentru a utiliza această interfață.

note: type: Plain text
en: This frontend has some special hotkeys. Pageup (or ctrl-u)  will go back to the previous question (if that is supported by the package that is using debconf), and pagedown (or ctrl-v) will skip forward to the next question.
ro: Această interfață are câteva taste rapide speciale. «pageup» (sau «ctrl-u») va reveni la întrebarea anterioară (dacă pachetul care utilizează debconf acceptă acest lucru), iar «pagedown» (sau «ctrl-v») va trece la următoarea întrebare.

note: type: Plain text
en: This is the best frontend for remote admin work over a slow connection, or for those who are comfortable with unix.
ro: Aceasta este cea mai bună interfață pentru munca de administrare de la distanță pe o conexiune lentă, sau pentru cei care se descurcă bine cu unix.

note: type: Plain text
en: This is the anti-frontend. It never interacts with you at all, and makes the default answers be used for all questions. It might mail error messages to root, but that's it; otherwise it is completely silent and unobtrusive, a perfect frontend for automatic installs. If you are using this front-end, and require non-default answers to questions, you will need to preseed the debconf database; see the section below on Unattended Package Installation for more details.
ro: Aceasta este anti-interfața. Nu interacționează deloc cu dvs. și face ca răspunsurile implicite să fie utilizate pentru toate întrebările. Poate trimite mesaje de eroare către root, dar asta este tot; în rest, este complet silențioasă și discretă, o interfață perfectă pentru instalările automate. Dacă utilizați această interfață și aveți nevoie de răspunsuri la întrebări care nu sunt implicite, va trebui să preconfigurați baza de date debconf; consultați secțiunea de mai jos privind instalarea nesupravegheată a pachetelor pentru mai multe detalii.

note: type: Plain text
en: This is a modern X GUI using the gtk and gnome libraries. Of course, it requires a valid DISPLAY to work; debconf will fall back to other frontends if it can't work. Note that this frontend requires you have the libgtk3-perl package installed.
ro: Aceasta este o interfață grafică X modernă care utilizează bibliotecile gtk și gnome. Desigur, necesită ca variabila de mediu DISPLAY să aibă o valoare validă pentru a funcționa; debconf se va întoarce la alte interfețe dacă nu poate funcționa. Rețineți că această interfață necesită să aveți instalat pachetul libgtk3-perl.

note: type: Plain text
en: This frontend provides a modern X GUI based on the KDE Platform. You of course need a DISPLAY to use this frontend and you must install debconf-kde-helper package. The frontend will fall back to dialog if some of the prerequisites are not met.
ro: Această interfață oferă o interfață grafică X modernă bazată pe platforma KDE. Desigur, aveți nevoie ca variabila de mediu DISPLAY să aibă o valoare validă pentru a utiliza această interfață și trebuie să instalați pachetul debconf-kde-helper. Interfața va reveni la dialog dacă unele dintre condițiile prealabile nu sunt îndeplinite.

note: type: Plain text
en: This is for those fanatics who have to do everything in a text editor. It runs your editor on a file that looks something like a typical unix config file, and you edit the file to communicate with debconf. Debconf's author prefers to not comment regarding the circumstances that led to this frontend being written.
ro: Aceasta este pentru acei fanatici care trebuie să facă totul într-un editor de text. Acesta rulează editorul dvs. preferat pe un fișier care seamănă cu un fișier de configurare unix tipic, iar dvs. editați fișierul pentru a comunica cu debconf. Autorul Debconf preferă să nu comenteze cu privire la circumstanțele care au dus la scrierea acestei interfețe.

note: type: Plain text
en: This frontend acts as a web server, that you connect to with your web browser, to browse the questions and answer them.  It has a lot of promise, but is a little rough so far.  When this frontend starts up, it will print out the location you should point your web browser to. You have to run the web browser on the same machine you are configuring, for security reasons.
ro: Această interfață acționează ca un server web, la care vă conectați cu navigatorul dvs. web, pentru a parcurge întrebările și a răspunde la ele. Este foarte promițător, dar deocamdată este puțin greoi. Atunci când această interfață pornește, ea va afișa locația către care trebuie să îndreptați navigatorul dvs. web. Din motive de securitate, trebuie să executați navigatorul web pe aceeași mașină pe care o configurați.

note: type: Plain text
en: Do keep in mind that this is not a very secure frontend.  Anyone who has access to the computer being configured can currently access the web server and configure things while this frontend is running. So this is more of a proof of concept than anything.
ro: Țineți cont de faptul că aceasta nu este o interfață foarte sigură. Oricine are acces la calculatorul care este configurat poate accesa serverul web și configura lucrurile în timp ce această interfață rulează. Prin urmare, aceasta este mai mult o dovadă de concept decât orice altceva.

note: type: Plain text
en: You can change the default frontend debconf uses by reconfiguring
    debconf. On the other hand, if you just want to change the frontend
    for a minute, you can set the DEBIAN_FRONTEND environment variable to
    the name of the frontend to use. For example:
      DEBIAN_FRONTEND=readline apt-get install slrn
ro: Puteți schimba interfața implicită utilizată de debconf prin reconfigurarea debconf. Pe de altă parte, dacă doriți să schimbați interfața doar pentru un minut, puteți defini variabila de mediu DEBIAN_FRONTEND la numele interfeței de utilizat. De exemplu:
      DEBIAN_FRONTEND=readline apt-get install slrn

note: type: Plain text
en: The B<dpkg-reconfigure>(8)  and B<dpkg-preconfigure>(8)  commands also let you pass I<--frontend=> to them, followed by the frontend you want them to use.
ro: Comenzile B<dpkg-reconfigure>(8) și B<dpkg-preconfigure>(8) vă permit, de asemenea, să le pasați opțiunea I<--frontend=>, urmată de numele interfeței pe care doriți să o utilizeze.

note: type: Plain text
en: Note that not all frontends will work in all circumstances. If a frontend fails to start up for some reason, debconf will print out a message explaining why, and fall back to the next-most similar frontend.
ro: Rețineți că nu toate interfețele vor funcționa în toate situațiile. Dacă o interfață nu reușește să pornească din anumite motive, debconf va afișa un mesaj explicând de ce și va trece la următoarea interfață similară.

note: type: SH
en: Priorities
ro: Priorități

note: type: Plain text
en: Another nice feature of debconf is that the questions it asks you are prioritized. If you don't want to be bothered about every little thing, you can set up debconf to only ask you the most important questions.  On the other hand, if you are a control freak, you can make it show you all questions. Each question has a priority. In increasing order of importance:
ro: O altă caracteristică plăcută a debconf este că întrebările pe care vi le pune sunt prioritizate. Dacă nu doriți să fiți deranjat de fiecare lucru mărunt, puteți configura debconf să vă pună doar cele mai importante întrebări. Pe de altă parte, dacă sunteți obsedat de control, îl puteți face să vă arate toate întrebările. Fiecare întrebare are o prioritate. În ordinea crescătoare a importanței:

note: type: Plain text
en: Very trivial questions that have defaults that will work in the vast majority of cases.
ro: Întrebări foarte banale care au valori implicite care vor funcționa în marea majoritate a cazurilor.

note: type: Plain text
en: Normal questions that have reasonable defaults.
ro: Întrebări normale care au valori implicite rezonabile.

note: type: Plain text
en: Questions that don't have a reasonable default.
ro: Întrebări care nu au un răspuns implicit rezonabil.

note: type: Plain text
en: Questions that you really, really need to see (or else).
ro: Întrebări pe care trebuie să le vedeți cu adevărat (altfel...).

note: type: Plain text
en: Only questions with a priority equal to or greater than the priority you choose will be shown to you. You can set the priority value by reconfiguring debconf, or temporarily by passing I<--priority=> followed by the value to the B<dpkg-reconfigure>(8)  and B<dpkg-preconfigure>(8)  commands, or by setting the DEBIAN_PRIORITY environment variable.
ro: Vi se vor afișa numai întrebările cu o prioritate egală sau mai mare decât prioritatea aleasă. Puteți stabili valoarea priorității prin reconfigurarea debconf sau temporar, pasând I<--priority=> urmată de valoare, comenzilor B<dpkg-reconfigure>(8) și B<dpkg-preconfigure>(8), sau prin definirea variabilei de mediu DEBIAN_PRIORITY.

note: type: SH
en: Backend Database
ro: Baza de date principală

note: type: Plain text
en: Debconf uses a rather flexible and potentially complicated backend database for storing data such as the answers to questions. The file B</etc/debconf.conf> is used to configure this database. If you need to set up something complicated, like make debconf read a remote database to get defaults, with local overrides, read the B<debconf.conf>(5)  man page for all the gory details. Generally, the backend database is located in B</var/cache/debconf/> .
ro: Debconf utilizează o bază de date principală destul de flexibilă și potențial complicată pentru stocarea datelor, cum ar fi răspunsurile la întrebări. Fișierul B</etc/debconf.conf> este utilizat pentru a configura această bază de date. Dacă trebuie să configurați ceva complicat, cum ar fi să faceți debconf să citească o bază de date de la distanță pentru a obține valorile implicite, cu suprapuneri locale, citiți pagina de manual B<debconf.conf>(5) pentru toate detaliile sângeroase. În general, baza de date principală este localizată în B</var/cache/debconf/> .

note: type: SH
en: Unattended Package Installation
ro: Instalarea nesupravegheată a pachetelor

note: type: Plain text
en: If you have many machines to manage you will sometimes find yourself in the position of needing to perform an unattended installation or upgrade of packages on many systems, when the default answers to some configuration questions are not acceptable. There are many ways to approach this; all involve setting up a database and making debconf use it to get the answers you want.
ro: Dacă aveți multe mașini de gestionat, vă veți afla uneori în situația de a trebui să efectuați o instalare sau o actualizare nesupravegheată a pachetelor pe mai multe sisteme, atunci când răspunsurile implicite la unele întrebări de configurare nu sunt acceptabile. Există mai multe moduri de a aborda această problemă; toate implică crearea unei baze de date și utilizarea acesteia de către debconf pentru a obține răspunsurile dorite.

note: type: Plain text
en: You should really read B<debconf.conf>(5)  before this section, as you need to understand how debconf's databases work.
ro: Ar trebui să citiți B<debconf.conf>(5) înainte de această secțiune, deoarece trebuie să înțelegeți cum funcționează bazele de date ale debconf.

note: type: Plain text
en: The easiest way to set up the database is to install the packages on one machine and answer their questions as usual. Or you might just use B<dpkg-preconfigure>(8)  to configure a set of packages without actually installing them. Or you might even decide to write a plain text debconf database by hand or something.
ro: Cel mai simplu mod de a configura baza de date este să instalați pachetele pe o mașină și să răspundeți la întrebările lor ca de obicei. Sau ați putea folosi B<dpkg-preconfigure>(8) pentru a configura un set de pachete fără a le instala efectiv. Sau ați putea decide chiar să scrieți manual o bază de date debconf în text simplu sau ceva de acest gen.

note: type: Plain text
en: Once you have the database, you need to figure out how to make the remote systems use it. This depends of course on the configuration of those systems and what database types they are set up to use.
ro: Odată ce aveți baza de date, trebuie să vă dați seama cum să faceți sistemele la distanță să o utilizeze. Acest lucru depinde, desigur, de configurația acestor sisteme și de tipurile de baze de date pe care sunt configurate să le utilizeze.

note: type: Plain text
en: If you are using the LDAP debconf database, an entire network of debian machines can also have any or all package installation questions answered automatically by a single LDAP server.
ro: Dacă utilizați baza de date debconf LDAP, un singur server LDAP poate răspunde automat la oricare sau la toate întrebările privind instalarea pachetelor pentru o întreagă rețea de mașini debian.

note: type: Plain text
en: But perhaps you're using something a little bit easier to set up like, say, the default debconf database configuration, or you just don't want your remote systems to use LDAP all the time. In this case the best approach is to temporarily configure the remote systems to stack your database underneath their own existing databases, so they pull default values out of it. Debconf offers two environment variables, DEBCONF_DB_FALLBACK and DEBCONF_DB_OVERRIDE, to make it easy to do this on the fly. Here is a sample use:
ro: Dar poate că utilizați ceva mai ușor de configurat, cum ar fi, de exemplu, configurația implicită a bazei de date debconf, sau pur și simplu nu doriți ca sistemele dvs. de la distanță să utilizeze LDAP tot timpul. În acest caz, cea mai bună abordare este să configurați temporar sistemele la distanță pentru a stivui baza dvs. de date sub propriile baze de date existente, astfel încât să extragă valorile implicite din aceasta. Debconf oferă două variabile de mediu, DEBCONF_DB_FALLBACK și DEBCONF_DB_OVERRIDE, pentru a facilita acest lucru din mers. Iată un exemplu de utilizare:

note: type: Plain text
en: This makes the debconf on the remote host read in the data that is piped across the ssh connection and interpret it as a plain text format debconf database. It then uses that database as a fallback database -- a read-only database that is queried for answers to questions if the system's main debconf database lacks answers.
ro: Acest lucru face ca debconf de pe gazda de la distanță să citească datele care sunt transmise prin conexiunea ssh și să le interpreteze ca o bază de date debconf în format text simplu. Apoi utilizează această bază de date ca bază de date de rezervă - o bază de date numai pentru citire care este interogată pentru răspunsuri la întrebări în cazul în care baza de date debconf principală a sistemului nu are răspunsuri.

note: type: Plain text
en: Here's another way to use the DEBCONF_DB_FALLBACK environment variable:
ro: Iată o altă modalitate de a utiliza variabila de mediu DEBCONF_DB_FALLBACK:

note: type: Plain text
en: Here ssh is used to set up a tunneled LDAP connection and run debconf.  Debconf is told to use the LDAP server as the fallback database. Note the use of "{host:localhost}" to configure how debconf accesses the LDAP database by providing the "host" field with a value of "localhost".
ro: Aici ssh este utilizat pentru a configura o conexiune LDAP tunelată și pentru a rula debconf. Debconf este instruit să utilizeze serverul LDAP ca bază de date de rezervă. Observați utilizarea lui „{host:localhost}” pentru a configura modul în care debconf accesează baza de date LDAP prin furnizarea câmpului „host” cu valoarea „localhost”.

note: type: Plain text
en: Here's another method:
ro: Iată o altă metodă:

note: type: Plain text
en: Here you copy the database over with scp, and then ssh over and make debconf use the file you copied over. This illustrates a shorthand you can use in the DEBCONF_DB_FALLBACK parameters -- if a field name is left off, it defaults to "filename".
ro: Aici copiați baza de date cu scp, apoi ssh și faceți debconf să utilizeze fișierul pe care l-ați copiat. Acest lucru ilustrează o prescurtare pe care o puteți utiliza în parametrii DEBCONF_DB_FALLBACK - dacă un nume de câmp este omis, acesta devine implicit „nume fișier”.

note: type: Plain text
en: There is only one problem with these uses of the DEBCONF_DB_FALLBACK parameter: While the fallback database can provide answers to questions the other debconf databases have never seen, it is only queried as a fallback; after the other databases. If you need to instead temporarily override an existing value on the remote host, you should instead use the DEBCONF_DB_OVERRIDE variable. Like DEBCONF_DB_FALLBACK, it sets up a temporary database, but this database is consulted before any others, and can be used to override existing values.
ro: Există o singură problemă cu aceste utilizări ale parametrului DEBCONF_DB_FALLBACK: În timp ce baza de date de rezervă poate oferi răspunsuri la întrebări pe care celelalte baze de date debconf nu le-au văzut niciodată, aceasta este interogată doar ca o soluție de rezervă; după celelalte baze de date. Dacă trebuie să înlocuiți temporar o valoare existentă pe gazda de la distanță, trebuie să utilizați în schimb variabila DEBCONF_DB_OVERRIDE. Ca și DEBCONF_DB_FALLBACK, aceasta stabilește o bază de date temporară, dar această bază de date este consultată înaintea celorlalte și poate fi utilizată pentru a înlocui valorile existente.

note: type: SH
en: Developing for Debconf
ro: Dezvoltarea pentru Debconf

note: type: Plain text
en: Package developers and others who want to develop packages that use debconf should read B<debconf-devel>(7)  .
ro: Dezvoltatorii de pachete și alte persoane care doresc să dezvolte pachete care utilizează debconf ar trebui să citească B<debconf-devel>(7) .

note: type: Plain text
en: Briefly, debconf communicates with maintainer scripts or other programs via standard input and output, using a simple line-oriented command language similar to that used by common internet protocols such as SMTP. Programs use this protocol to ask debconf to display questions to the user, and retrieve the user's answers. The questions themselves are defined in a separate file, called the "templates file", which has a format not unlike a debian control file.
ro: Pe scurt, debconf comunică cu scripturile de întreținere sau cu alte programe prin intermediul intrării și ieșirii standard, utilizând un limbaj de comandă simplu, orientat pe linii, similar cu cel utilizat de protocoalele comune de internet, cum ar fi SMTP. Programele utilizează acest protocol pentru a solicita debconf să afișeze întrebări utilizatorului și să recupereze răspunsurile utilizatorului. Întrebările în sine sunt definite într-un fișier separat, denumit fișier de șabloane „templates file”, care are un format asemănător unui fișier de control debian.

note: type: Plain text
en: Debian packages which use debconf typically provide both a templates file and a "config" script (run to preconfigure the package) in the control metadata section of the package.
ro: Pachetele Debian care utilizează debconf furnizează de obicei atât un fișier de șabloane „templates”, cât și un script „config” (rulat pentru a preconfigura pachetul) în secțiunea de metadate de control a pachetului.

note: type: SH
en: ENVIRONMENT
ro: VARIABILE DE MEDIU

note: type: Plain text
en: Used to temporarily change the frontend debconf uses. See above.
ro: Utilizată pentru a schimba temporar interfața utilizată de debconf. A se vedea mai sus.

note: type: Plain text
en: Used to temporarily change the minimum priority of question debconf will display. See above.
ro: Utilizată pentru a modifica temporar prioritatea minimă a întrebării pe care debconf o va afișa. A se vedea mai sus.

note: type: Plain text
en: Turns on debugging output on standard error. May be set to a facility name or a regular expression which matches a facility name (such as '.*' to output all debug info). The facility names include:
ro: Activează ieșirea de depanare la ieșirea de eroare standard. Poate fi definită ca un nume de facilitate sau o expresie regulată care corespunde unui nume de facilitate (cum ar fi '.*' pentru a afișa toate informațiile de depanare). Numele facilităților includ:

note: type: Plain text
en: Debugging info of interest to a debconf user.
ro: Informații de depanare de interes pentru un utilizator debconf.

note: type: Plain text
en: Debugging info of interest to a package developer.
ro: Informații de depanare de interes pentru un dezvoltator de pachete.

note: type: Plain text
en: Debugging info about the backend database.
ro: Informații de depanare despre baza de date principală.

note: type: Plain text
en: Set to "yes" to disable some warnings that debconf may display. Does not suppress display of fatal errors.
ro: Definiți la „yes” pentru a dezactiva unele avertismente pe care debconf le poate afișa. Nu suprimă afișarea erorilor fatale.

note: type: Plain text
en: Set to "yes" to enable terse mode, in which debconf frontends cut down on the verbiage as much as possible.
ro: Definiți la „yes” pentru a activa modul laconic, în care interfețele debconf reduc cantitatea de detalii cât mai mult posibil.

note: type: Plain text
en: Stack a database after the normally used databases, so that it is used as a fallback to get configuration information from. See "Unattended Package Installation" above. If the value of the variable is the name of an existing database in debconf.conf, then that database will be used.  Otherwise, the environment variable can be used to configure a database on the fly, by telling the type of database, and optionally passing field:value settings, inside curly braces after the type. Spaces are used to separate fields, so you cannot specify a field value containing whitespace.
ro: Stivuiește o bază de date după bazele de date utilizate în mod normal, astfel încât aceasta să fie utilizată ca soluție de rezervă pentru obținerea informațiilor de configurare. Consultați „Instalarea nesupravegheată a pachetelor” de mai sus. Dacă valoarea variabilei este numele unei baze de date existente în debconf.conf, atunci acea bază de date va fi utilizată. În caz contrar, variabila de mediu poate fi utilizată pentru a configura o bază de date din mers, prin indicarea tipului de bază de date și, opțional, prin transmiterea parametrilor câmp:valoare, în interiorul unor acolade după tip. Spațiile sunt utilizate pentru a separa câmpurile, astfel încât nu puteți specifica o valoare de câmp care conține spații albe.

note: type: Plain text
en: Thus, this uses the fallbackdb in debconf.conf:
      DEBCONF_DB_FALLBACK=fallbackdb
ro: Astfel, aceasta utilizează fallbackdb în debconf.conf:
      DEBCONF_DB_FALLBACK=fallbackdb

note: type: Plain text
en: While this sets up a new database of type File, and tells it a filename to
    use and turns off backups:
      DEBCONF_DB_FALLBACK=File{Filename:/root/config.dat Backup:no}
ro: În timp ce acest lucru creează o nouă bază de date de tip File, îi indică un nume de fișier de utilizat și dezactivează efectuarea copiilor de rezervă:
      DEBCONF_DB_FALLBACK=File{Filename:/root/config.dat Backup:no}

note: type: Plain text
en: And as a shorthand, this sets up a database of type File with a filename:
      DEBCONF_DB_FALLBACK=File{/root/config.dat}
ro: Și ca o prescurtare, aceasta creează o bază de date de tip File cu un nume de fișier:
     DEBCONF_DB_FALLBACK=File{/root/config.dat}

note: type: Plain text
en: Note that if a fallback database is set up on the fly, it will be read-only by default.
ro: Rețineți că, dacă o bază de date de rezervă este configurată din mers, aceasta va fi implicit numai pentru citire.

note: type: Plain text
en: Stack a database before the normally used databases, so that it can override values from them. The value of the variable works the same as does the value of DEBCONF_DB_FALLBACK.
ro: Stivuiește o bază de date înaintea bazelor de date utilizate în mod normal, astfel încât să poată trece peste valorile din acestea. Valoarea variabilei funcționează la fel ca valoarea lui DEBCONF_DB_FALLBACK.

note: type: Plain text
en: Use a given database instead of the normally used databases.  This may be useful for testing with a separate database without having to create a separate debconf.conf, or to avoid locking the normal databases.
ro: Utilizează o anumită bază de date în locul bazelor de date utilizate în mod normal.  Acest lucru poate fi util pentru testarea cu o bază de date separată fără a fi nevoie să creați un debconf.conf separat sau pentru a evita blocarea bazelor de date normale.

note: type: Plain text
en: If this environment variable is set, debconf will ignore a user's ~/.debconfrc file, and use the system one instead.  If it is set to the name of a regular file, debconf will use that file in preference to the system configuration files.
ro: Dacă această variabilă de mediu este activată, debconf va ignora fișierul ~/.debconfrc al unui utilizator și va utiliza în schimb fișierul de sistem. Dacă este definită la numele unui fișier obișnuit, debconf va utiliza acel fișier cu prioritate față de fișierele de configurare ale sistemului.

note: type: Plain text
en: If this environment variable is set, debconf will use dialog in preference to whiptail for the dialog frontend.
ro: Dacă această variabilă de mediu este activată, debconf va utiliza dialog în locul whiptail pentru interfața de dialog.

note: type: Plain text
en: If this environment variable is set, debconf will use Xdialog in preference to whiptail for the dialog frontend.
ro: Dacă această variabilă de mediu este activată, debconf va utiliza Xdialog în loc de whiptail pentru interfața de dialog.

note: type: Plain text
en: Set to "true" to cause the seen flag to be set for questions asked in the noninteractive frontend.
ro: Stabiliți-o la „true” pentru ca fanionul „seen” să fie activat pentru întrebările adresate în interfața neinteractivă.

note: type: SH
en: BUGS
ro: ERORI

note: type: Plain text
en: Probably quite a few, there's a lot of code here.
ro: Probabil destul de multe, există o grămadă de cod aici.

note: type: Plain text
en: If you do file a bug report, be sure to include the following information:
ro: Dacă depuneți un raport de eroare, asigurați-vă că includeți următoarele informații:

note: type: Plain text
en: The debconf frontend you were using when the problem occurred
ro: Interfața debconf pe care o foloseați când a apărut problema

note: type: Plain text
en: What you did to trigger the problem.
ro: Ce ați făcut pentru a declanșa problema.

note: type: Plain text
en: The full text of any error messages. If you can reproduce the bug, do so with DEBCONF_DEBUG='.*' set and exported. This speeds up debugging a lot.
ro: Textul integral al oricărui mesaj de eroare. Dacă puteți reproduce eroarea, faceți acest lucru cu DEBCONF_DEBUG='.*' definită și exportată. Acest lucru accelerează foarte mult depanarea.

note: type: Plain text
en: debconf - developers guide
ro: debconf - ghidul dezvoltatorilor

note: type: Plain text
en: This is a guide for developing packages that use debconf.
ro: Acesta este un ghid pentru dezvoltarea de pachete care utilizează debconf.

note: type: Plain text
en: This manual assumes that you are familiar with debconf as a user, and are familiar with the basics of debian package construction.
ro: Acest manual presupune că sunteți familiarizat cu debconf în calitate de utilizator și că sunteți familiarizat cu elementele de bază ale construcției pachetelor debian.

note: type: Plain text
en: This manual begins by explaining two new files that are added to debian packages that use debconf. Then it explains how the debconf protocol works, and points you at some libraries that will let your programs speak the protocol. It discusses other maintainer scripts that debconf is typically used in: the postinst and postrm scripts. Then moves on to more advanced topics like shared debconf templates, debugging, and some common techniques and pitfalls of programming with debconf. It closes with a discussion of debconf's current shortcomings.
ro: Acest manual începe prin a explica două fișiere noi care sunt adăugate la pachetele debian care utilizează debconf. Apoi explică modul în care funcționează protocolul debconf și vă indică câteva biblioteci care vor permite programelor dvs. să utilizeze protocolul. Sunt discutate și alte scripturi de întreținere în care debconf este utilizat în mod obișnuit: scripturile „postinst” și „postrm”. Apoi trece la subiecte mai avansate, cum ar fi șabloanele debconf partajate, depanarea și unele tehnici și capcane comune ale programării cu debconf. Se încheie cu o discuție despre deficiențele actuale ale debconf.

note: type: SH
en: THE CONFIG SCRIPT
ro: SCRIPTUL DE CONFIGURARE

note: type: Plain text
en: Debconf adds an additional maintainer script, the config script, to the set of maintainer scripts that can be in debian packages (the postinst, preinst, postrm, and prerm). The config script is responsible for asking any questions necessary to configure the package.
ro: Debconf adaugă un script de întreținere suplimentar, scriptul „config”, la setul de scripturi de întreținere care pot fi în pachetele debian („postinst”, „preinst”, „postrm” și „prerm”). Scriptul config este responsabil cu adresarea oricăror întrebări necesare pentru configurarea pachetului.

note: type: Plain text
en: Note: It is a little confusing that dpkg refers to running a package's postinst script as "configuring" the package, since a package that uses debconf is often fully pre-configured, by its config script, before the postinst ever runs. Oh well.
ro: Notă: Este puțin confuz faptul că dpkg se referă la rularea scriptului „postinst” al unui pachet ca la „configurarea” pachetului, deoarece un pachet care utilizează debconf este adesea complet pre-configurat, prin scriptul său de configurare, înainte ca scriptul „postinst” să fie rulat vreodată. În fine!

note: type: Plain text
en: Like the postinst, the config script is passed two parameters when it is run. The first tells what action is being performed, and the second is the version of the package that is currently installed. So, like in a postinst, you can use dpkg --compare-versions on $2 to make some behavior happen only on upgrade from a particular version of a package, and things like that.
ro: La fel ca „postinst”, scriptul „config” primește doi parametri atunci când este rulat. Primul spune ce acțiune este efectuată, iar al doilea este versiunea pachetului care este instalat în prezent. Astfel, la fel ca în „postinst”, puteți utiliza dpkg --compare-versions pe $2 pentru a face ca un anumit comportament să se întâmple numai la actualizarea de la o anumită versiune a unui pachet și alte lucruri de acest gen.

note: type: Plain text
en: The config script can be run in one of three ways:
ro: Scriptul de configurare poate fi rulat în trei moduri:

note: type: Plain text
en: If a package is pre-configured, with dpkg-preconfigure, its config script is run, and is passed the parameters "configure", and installed-version.
ro: Dacă un pachet este preconfigurat, cu dpkg-preconfigure, scriptul său de configurare este rulat și i se transmit parametrii „configure” și installed-version.

note: type: Plain text
en: When a package's postinst is run, debconf will try to run the config script then too, and it will be passed the same parameters it was passed when it is pre-configured. This is necessary because the package might not have been pre-configured, and the config script still needs to get a chance to run. See HACKS for details.
ro: Atunci când scriptul „postinst” al unui pachet este rulat, debconf va încerca să ruleze și scriptul „config”, iar acestuia i se vor pasa aceiași parametri care i-au fost pasați atunci când a fost preconfigurat. Acest lucru este necesar deoarece este posibil ca pachetul să nu fi fost preconfigurat, iar scriptul „config” trebuie să aibă în continuare șansa de a se executa. Consultați secțiunea TRUCURI pentru detalii.

note: type: Plain text
en: If a package is reconfigured, with dpkg-reconfigure, its config script it run, and is passed the parameters "reconfigure" and installed-version.
ro: Dacă un pachet este reconfigurat, cu dpkg-reconfigure, scriptul său „config” este rulat și i se transmit parametrii „reconfigure” și installed-version.

note: type: Plain text
en: Note that since a typical package install or upgrade using apt runs steps 1 and 2, the config script will typically be run twice. It should do nothing the second time (to ask questions twice in a row is annoying), and it should definitely be idempotent. Luckily, debconf avoids repeating questions by default, so this is generally easy to accomplish.
ro: Rețineți că, deoarece o instalare sau o actualizare tipică a unui pachet utilizând apt execută pașii 1 și 2, scriptul „config” va fi de obicei executat de două ori. Acesta nu ar trebui să facă nimic a doua oară (a pune întrebări de două ori la rând este enervant) și ar trebui cu siguranță să fie idempotent. Din fericire, debconf evită implicit repetarea întrebărilor, astfel încât acest lucru este în general ușor de realizat.

note: type: Plain text
en: Note that the config script is run before the package is unpacked. It should only use commands that are in essential packages. The only dependency of your package that is guaranteed to be met when its config script is run is a dependency (possibly versioned) on debconf itself.
ro: Rețineți că scriptul „config” este rulat înainte ca pachetul să fie despachetat. Acesta ar trebui să utilizeze numai comenzile care se află în pachetele esențiale. Singura dependență a pachetului dvs. care este garantată a fi îndeplinită atunci când scriptul config este rulat este o dependență (posibil cu o versiune specificată) de debconf însuși.

note: type: Plain text
en: The config script should not need to modify the filesystem at all. It just examines the state of the system, and asks questions, and debconf stores the answers to be acted on later by the postinst script. Conversely, the postinst script should almost never use debconf to ask questions, but should instead act on the answers to questions asked by the config script.
ro: Scriptul „config” nu ar trebui să fie nevoit să modifice deloc sistemul de fișiere. Acesta examinează doar starea sistemului și pune întrebări, iar debconf stochează răspunsurile pentru a fi utilizate ulterior de scriptul „postinst”. În schimb, scriptul „postinst” nu ar trebui să utilizeze aproape niciodată debconf pentru a pune întrebări, ci ar trebui să acționeze pe baza răspunsurilor la întrebările puse de scriptul „config”.

note: type: SH
en: THE TEMPLATES FILE
ro: FIȘIERUL DE ȘABLOANE „TEMPLATES”

note: type: Plain text
en: A package that uses debconf probably wants to ask some questions. These questions are stored, in template form, in the templates file.
ro: Un pachet care utilizează debconf dorește probabil să pună câteva întrebări. Aceste întrebări sunt stocate, sub formă de șablon, în fișierul templates.

note: type: Plain text
en: Like the config script, the templates file is put in the control.tar.gz section of a deb. Its format is similar to a debian control file; a set of stanzas separated by blank lines, with each stanza having a RFC822-like form:
ro: La fel ca scriptul config, fișierul templates este pus în secțiunea control.tar.gz a unui deb. Formatul său este similar cu cel al unui fișier de control debian; un set de strofe separate prin linii goale, fiecare strofă având o formă similară formatului RFC822:

note: type: Plain text
en:   Template: foo/bar
      Type: string
      Default: foo
      Description: This is a sample string question.
       This is its extended description.
       .
       Notice that:
        - Like in a debian package description, a dot
          on its own line sets off a new paragraph.
        - Most text is word-wrapped, but doubly-indented
          text is left alone, so you can use it for lists
          of items, like this list. Be careful, since
          it is not word-wrapped, if it's too wide
          it will look bad. Using it for short items
          is best (so this is a bad example).
ro:   Template: foo/bar
      Type: string
      Defult: foo
      Description: Aceasta este un exemplu de chestionar.
       Aceasta este descrierea sa extinsă.
       .
       Rețineți că:n
        - Ca în descrierea unui pachet debian, un punct plasat
          singur pe linie marchează începutul unui nou paragraf.
        - Majoritatea textului este încadrat în cuvinte, dar textul
          cu dublă aliniere este lăsat singur, deci îl puteți folosi
          pentru liste de elemente, precum această listă. Fiți atenți,
          deoarece acesta nu este încadrat în cuvinte, dacă este
          prea lat va arăta urât. Utilizarea lui pentru elemente scurte
          este cel mai potrivit (deci acesta este un exemplu prost).

note: type: Plain text
en:   Template: foo/baz
      Type: boolean
      Description: Clear enough, no?
       This is another question, of boolean type.
ro:   Template: foo/baz
      Type: boolean
      Description: Destul de clar, nu?
       Aceasta este o altă întrebare, de tip boolean.

note: type: Plain text
en: For some real-life examples of templates files, see /var/lib/dpkg/info/debconf.templates, and other .templates files in that directory.
ro: Pentru câteva exemple reale de fișiere șablon, consultați „/var/lib/dpkg/info/debconf.templates” și alte fișiere „.templates” din acel director.

note: type: Plain text
en: Let's look at each of the fields in turn..
ro: Să analizăm pe rând fiecare dintre câmpuri.

note: type: Plain text
en: The name of the template, in the 'Template' field, is generally prefixed with the name of the package. After that the namespace is wide open; you can use a simple flat layout like the one above, or set up "subdirectories" containing related questions.
ro: Numele șablonului, în câmpul „Template”, este în general precedat de numele pachetului. După aceea, spațiul de nume este foarte liber; puteți utiliza un aspect plat simplu, precum cel de mai sus, sau puteți crea „subdirectoare” care să conțină întrebări conexe.

note: type: Plain text
en: The type of the template determines what kind of widget is displayed to the user. The currently supported types are:
ro: Tipul șablonului determină ce tip de element de meniu este afișat utilizatorului. Tipurile acceptate în prezent sunt:

note: type: Plain text
en: Results in a free-form input field that the user can type any string into.
ro: Rezultă un câmp de intrare cu formă liberă în care utilizatorul poate introduce orice șir de caractere.

note: type: Plain text
en: Prompts the user for a password. Use this with caution; be aware that the password the user enters will be written to debconf's database. You should probably clean that value out of the database as soon as is possible.
ro: Solicită utilizatorului o parolă. Utilizați această opțiune cu precauție; fiți conștienți de faptul că parola introdusă de utilizator va fi scrisă în baza de date a debconf. Probabil ar trebui să eliminați această valoare din baza de date cât mai curând posibil.

note: type: Plain text
en: A true/false choice.
ro: O alegere adevărat/fals (true/false).

note: type: Plain text
en: A choice between one of a number of values. The choices must be specified in a field named 'Choices'. Separate the possible values with commas and spaces, like this:
ro: O alegere între una dintre mai multe valori. Opțiunile trebuie specificate într-un câmp numit „Choices”. Separați valorile posibile cu virgule și spații, astfel:

note: type: Plain text
en:   Choices: yes, no, maybe
ro:   Choices: da, nu, poate

note: type: Plain text
en: Like the select data type, except the user can choose any number of items from the choices list (or choose none of them).
ro: La fel ca tipul de date de selectare, cu excepția faptului că utilizatorul poate alege orice număr de elemente din lista de opțiuni (sau poate să nu aleagă niciuna dintre ele).

note: type: Plain text
en: Rather than being a question per se, this datatype indicates a note that can be displayed to the user. It should be used only for important notes that the user really should see, since debconf will go to great pains to make sure the user sees it; halting the install for them to press a key.  It's best to use these only for warning about very serious problems, and the error datatype is often more suitable.
ro: Mai degrabă decât o întrebare în sine, acest tip de date indică o notă care poate fi afișată utilizatorului. Ar trebui utilizat numai pentru note importante pe care utilizatorul ar trebui să le vadă, deoarece debconf se va strădui foarte mult să se asigure că utilizatorul le vede, oprind instalarea pentru ca acesta să apese o tastă. Cel mai bine este să le folosiți doar pentru avertizări cu privire la probleme foarte grave, iar tipul de date B<error> este adesea mai potrivit.

note: type: Plain text
en: This datatype is used for error messages, such as input validation errors.  Debconf will show a question of this type even if the priority is too high or the user has already seen it.
ro: Acest tip de date este utilizat pentru mesajele de eroare, cum ar fi erorile de validare a intrărilor. Debconf va afișa o întrebare de acest tip chiar dacă prioritatea este prea mare sau dacă utilizatorul a văzut-o deja.

note: type: Plain text
en: This datatype is used for titles, to be set with the SETTITLE command.
ro: Acest tip de date este utilizat pentru titluri, pentru a fi definite cu comanda SETTITLE.

note: type: Plain text
en: This datatype can be used for fragments of text, such as labels, that can be used for cosmetic reasons in the displays of some frontends. Other frontends will not use it at all. There is no point in using this datatype yet, since no frontends support it well. It may even be removed in the future.
ro: Acest tip de date poate fi utilizat pentru fragmente de text, cum ar fi etichetele, care pot fi utilizate din motive cosmetice în afișajele unor interfețe. Alte interfețe nu îl vor utiliza deloc. Deocamdată nu are rost să utilizați acest tip de date, deoarece nicio interfață nu îl acceptă bine. Acesta ar putea fi chiar eliminat în viitor.

note: type: Plain text
en: The 'Default' field tells debconf what the default value should be. For multiselect, it can be a list of choices, separated by commas and spaces, similar to the 'Choices' field. For select, it should be one of the choices. For boolean, it is "true" or "false", while it can be anything for a string, and it is ignored for passwords.
ro: Câmpul „Default” indică debconf care ar trebui să fie valoarea implicită. Pentru B<multiselect>, aceasta poate fi o listă de opțiuni, separate prin virgule și spații, similar câmpului „Choices”. Pentru B<select>, ar trebui să fie una dintre opțiuni. Pentru B<boolean>, este „true” sau „false”, în timp ce poate fi orice pentru un B<string> și este ignorat pentru B<password>.

note: type: Plain text
en: Don't make the mistake of thinking that the default field contains the "value" of the question, or that it can be used to change the value of the question. It does not, and cannot, it just provides a default value for the first time the question is displayed. To provide a default that changes on the fly, you'd have to use the SET command to change the value of a question.
ro: Nu faceți greșeala de a crede că câmpul B<Default> conține „valoarea” întrebării sau că poate fi utilizat pentru a modifica valoarea întrebării. Nu este așa și nici nu poate fi, ci doar oferă o valoare implicită pentru prima dată când este afișată întrebarea. Pentru a furniza o valoare implicită care se modifică din mers, ar trebui să utilizați comanda SET pentru a modifica valoarea unei întrebări.

note: type: Plain text
en: The 'Description' field, like the description of a Debian package, has two parts: A short description and an extended description. Note that some debconf frontends don't display the long description, or might only display it if the user asks for help. So the short description should be able to stand on its own.
ro: Câmpul „ Description ”, ca și descrierea unui pachet Debian, are două părți: O descriere scurtă și o descriere extinsă. Rețineți că unele interfețe debconf nu afișează descrierea lungă sau o pot afișa doar dacă utilizatorul cere ajutor. Așadar, descrierea scurtă ar trebui să fie capabilă „să se descurce” singură.

note: type: Plain text
en: If you can't think up a long description, then first, think some more. Post to debian-devel. Ask for help. Take a writing class! That extended description is important. If after all that you still can't come up with anything, leave it blank. There is no point in duplicating the short description.
ro: Dacă nu vă puteți gândi la o descriere lungă, atunci mai întâi, gândiți-vă mai mult. Adresați-vă la debian-devel. Cereți ajutor. Luați un curs de scriere! Acea descriere extinsă este importantă. Dacă după toate astea tot nu vă vine nimic în minte, lăsați-o goală. Nu are rost să duplicați descrierea scurtă.

note: type: Plain text
en: Text in the extended description will be word-wrapped, unless it is prefixed by additional whitespace (beyond the one required space). You can break it up into separate paragraphs by putting " ." on a line by itself between them.
ro: Textul din descrierea extinsă va fi încadrat în cuvinte, cu excepția cazului în care este prefixat de un spațiu alb suplimentar (în afară de spațiul necesar). Îl puteți împărți în paragrafe separate punând „ .” pe o linie de sine stătătoare între ele.

note: type: SH
en: QUESTIONS
ro: ÎNTREBĂRI

note: type: Plain text
en: A question is an instantiated template. By asking debconf to display a question, your config script can interact with the user. When debconf loads a templates file (this happens whenever a config or postinst script is run), it automatically instantiates a question from each template. It is actually possible to instantiate several independent questions from the same template (using the REGISTER command), but that is rarely necessary. Templates are static data that comes from the templates file, while questions are used to store dynamic data, like the current value of the question, whether a user has seen a question, and so on. Keep the distinction between a template and a question in mind, but don't worry too much about it.
ro: O întrebare este o instanță a unui șablon. Solicitând debconf să afișeze o întrebare, scriptul dvs. „config” poate interacționa cu utilizatorul. Atunci când debconf încarcă un fișier de șabloane (acest lucru se întâmplă ori de câte ori se execută un script „config” sau „postinst”), acesta creează automat o instanță de întrebare din fiecare șablon. De fapt, este posibilă crearea de instanțe de mai multe întrebări independente din același șablon (utilizând comanda REGISTER), dar acest lucru este rareori necesar. Șabloanele sunt date statice care provin din fișierul de șabloane, în timp ce întrebările sunt utilizate pentru a stoca date dinamice, cum ar fi valoarea curentă a întrebării, dacă un utilizator a văzut o întrebare și așa mai departe. Țineți cont de distincția dintre un șablon și o întrebare, dar nu vă faceți prea multe griji cu privire la aceasta.

note: type: SH
en: SHARED TEMPLATES
ro: ȘABLOANE PARTAJATE

note: type: Plain text
en: It's actually possible to have a template and a question that are shared among a set of packages. All the packages have to provide an identical copy of the template in their templates files. This can be useful if a bunch of packages need to ask the same question, and you only want to bother the user with it once. Shared templates are generally put in the shared/ pseudo-directory in the debconf template namespace.
ro: De fapt, este posibil să existe un șablon și o întrebare care sunt partajate între un set de pachete. Toate pachetele trebuie să furnizeze o copie identică a șablonului în fișierele lor de șabloane. Acest lucru poate fi util dacă o serie de pachete trebuie să pună aceeași întrebare și doriți să deranjați utilizatorul o singură dată cu aceasta. Șabloanele partajate sunt în general plasate în pseudo-directorul shared/ din spațiul de nume al șabloanelor debconf.

note: type: SH
en: THE DEBCONF PROTOCOL
ro: PROTOCOLUL DEBCONF

note: type: Plain text
en: Config scripts communicate with debconf using the debconf protocol. This is a simple line-oriented protocol, similar to common internet protocols such as SMTP. The config script sends debconf a command by writing the command to standard output. Then it can read debconf's reply from standard input.
ro: Scripturile „config” comunică cu debconf utilizând protocolul debconf. Acesta este un protocol simplu orientat pe linii, similar protocoalelor comune de Internet, cum ar fi SMTP. Scriptul „config” trimite o comandă către debconf prin scrierea comenzii la ieșirea standard. Apoi poate citi răspunsul debconf de la intrarea standard.

note: type: Plain text
en: Debconf's reply can be broken down into two parts: A numeric result code (the first word of the reply), and an optional extended result code (the remainder of the reply). The numeric code uses 0 to indicate success, and other numbers to indicate various kinds of failure. For full details, see the table in Debian policy's debconf specification document.
ro: Răspunsul Debconf poate fi împărțit în două părți: Un cod de rezultat numeric (primul cuvânt al răspunsului) și un cod de rezultat extins opțional (restul răspunsului). Codul numeric utilizează 0 pentru a indica succesul, iar alte numere pentru a indica diferite tipuri de eșecuri. Pentru detalii complete, consultați tabelul din documentul de specificații debconf al politicii Debian.

note: type: Plain text
en: The extended return code is generally free form and unspecified, so you should generally ignore it, and should certainly not try to parse it in a program to work out what debconf is doing. The exception is commands like GET, that cause a value to be returned in the extended return code.
ro: Codul de returnare extins este, în general, liber și nespecificat, astfel încât, în general, ar trebui să îl ignorați și cu siguranță nu ar trebui să încercați să îl analizați într-un program pentru a afla ce face debconf. Excepție fac comenzile precum GET, care fac ca o valoare să fie returnată în codul de răspuns extins.

note: type: Plain text
en: Generally you'll want to use a language-specific library that handles the nuts and bolts of setting up these connections to debconf and communicating with it.
ro: În general, veți dori să utilizați o bibliotecă specifică limbajului care să se ocupe de configurarea acestor conexiuni la debconf și de comunicarea cu acesta.

note: type: Plain text
en: For now, here are the commands in the protocol. This is not the definitive definition, see Debian policy's debconf specification document for that.
ro: Pentru moment, aici sunt comenzile din protocol. Aceasta nu este definiția definitivă, consultați documentul de specificații debconf al politicii Debian pentru aceasta.

note: type: TP
en: B<VERSION number>
ro: B<VERSION număr>

note: type: Plain text
en: You generally don't need to use this command. It exchanges with debconf the protocol version number that is being used. The current protocol version is 2.0, and versions in the 2.x series will be backwards-compatible. You may specify the protocol version number you are speaking and debconf will return the version of the protocol it speaks in the extended result code. If the version you specify is too low, debconf will reply with numeric code 30.
ro: În general, nu este necesar să utilizați această comandă. Aceasta schimbă cu debconf numărul versiunii protocolului care este utilizat. Versiunea actuală a protocolului este 2.0, iar versiunile din seria 2.x vor fi retrocompatibile. Puteți specifica numărul versiunii protocolului pe care îl vorbiți, iar debconf va returna versiunea protocolului pe care îl vorbește în codul de rezultat extins. Dacă versiunea pe care o specificați este prea mică, debconf va răspunde cu codul numeric 30.

note: type: TP
en: B<CAPB capabilities>
ro: B<CAPB capacități>

note: type: Plain text
en: You generally don't need to use this command. It exchanges with debconf a list of supported capabilities (separated by spaces). Capabilities that both you and debconf support will be used, and debconf will reply with all the capabilities it supports.
ro: În general, nu este necesar să utilizați această comandă. Aceasta schimbă cu debconf o listă de capacități acceptate (separate prin spații). Capacitățile pe care atât dumneavoastră, cât și debconf le acceptați vor fi utilizate, iar debconf va răspunde cu toate capacitățile pe care le acceptă.

note: type: Plain text
en: If 'escape' is found among your capabilities, debconf will expect commands you send it to have backslashes and newlines escaped (as \e\e and \en respectively) and will in turn escape backslashes and newlines in its replies. This can be used, for example, to substitute multi-line strings into templates, or to get multi-line extended descriptions reliably using METAGET. In this mode, you must escape input text yourself (you can use B<debconf-escape>(1)  to help with this if you want), but the confmodule libraries will unescape replies for you.
ro: Dacă „escape” se găsește printre capacitățile dvs., debconf se va aștepta ca comenzile pe care i le trimiteți să aibă bare oblice și linii noi eludate (ca \e\e și respectiv \en) și va eluda la rândul său bare oblice și linii noi în răspunsurile sale. Acest lucru poate fi utilizat, de exemplu, pentru a înlocui șiruri de caractere cu mai multe linii în șabloane sau pentru a obține descrieri extinse cu mai multe linii în mod fiabil utilizând METAGET. În acest mod, trebuie să eludați singuri textul de intrare (dacă doriți, puteți utiliza B<debconf-escape>(1) pentru a vă ajuta în acest sens), iar bibliotecile confmodule vor elimina eludarea din răspunsuri pentru dumneavoastră.

note: type: TP
en: B<SETTITLE question>
ro: B<SETTITLE întrebare>

note: type: Plain text
en: This sets the title debconf displays to the user, using the short description of the template for the specified question. The template should be of type title. You rarely need to use this command since debconf can automatically generate a title based on your package's name.
ro: Aceasta definește titlul pe care debconf îl afișează utilizatorului, utilizând descrierea scurtă a șablonului pentru întrebarea specificată. Șablonul trebuie să fie de tip B<title>. Rareori trebuie să utilizați această comandă, deoarece debconf poate genera automat un titlu bazat pe numele pachetului dvs.

note: type: Plain text
en: Setting the title from a template means they are stored in the same place as the rest of the debconf questions, and allows them to be translated.
ro: Definirea titlurilor dintr-un șablon înseamnă că acestea sunt stocate în același loc ca și restul întrebărilor debconf și permite traducerea lor.

note: type: TP
en: B<TITLE string>
ro: B<TITLE șir>

note: type: Plain text
en: This sets the title debconf displays to the user to the specified string.  Use of the SETTITLE command is normally to be preferred as it allows for translation of the title.
ro: Aceasta stabilește titlul pe care debconf îl afișează utilizatorului la șirul specificat. Utilizarea comenzii SETTITLE este în mod normal de preferat, deoarece permite traducerea titlului.

note: type: TP
en: B<INPUT priority question>
ro: B<INPUT prioritate întrebare>

note: type: Plain text
en: Ask debconf to prepare to display a question to the user. The question is not actually displayed until a GO command is issued; this lets several INPUT commands be given in series, to build up a set of questions, which might all be asked on a single screen.
ro: Solicită debconf să se pregătească pentru a afișa o întrebare utilizatorului. Întrebarea nu este afișată efectiv până când nu este emisă o comandă GO; acest lucru permite ca mai multe comenzi INPUT să fie date în serie, pentru a construi un set de întrebări, care ar putea fi adresate toate pe un singur ecran.

note: type: Plain text
en: The priority field tells debconf how important it is that this question be shown to the user. The priority values are:
ro: Câmpul de prioritate îi indică lui debconf cât de important este ca această întrebare să fie afișată utilizatorului. Valorile priorității sunt:

note: type: Plain text
en: Very trivial items that have defaults that will work in the vast majority of cases; only control freaks see these.
ro: Elemente foarte banale care au valori implicite care vor funcționa în marea majoritate a cazurilor; doar obsedații de control le văd.

note: type: Plain text
en: Normal items that have reasonable defaults.
ro: Elemente normale care au valori implicite rezonabile.

note: type: Plain text
en: Items that don't have a reasonable default.
ro: Elemente care nu au o valoare implicită rezonabilă.

note: type: Plain text
en: Items that will probably break the system without user intervention.
ro: Elemente care probabil vor distruge sistemul fără intervenția utilizatorului.

note: type: Plain text
en: Debconf decides if the question is actually displayed, based on its priority, and whether the user has seen it before, and which frontend is being used. If the question will not be displayed, debconf replies with code 30.
ro: Debconf decide dacă întrebarea este afișată efectiv, pe baza priorității sale, dacă utilizatorul a mai văzut-o înainte și ce interfață este utilizată. Dacă întrebarea nu va fi afișată, debconf răspunde cu codul 30.

note: type: Plain text
en: Tells debconf to display the accumulated set of questions (from INPUT commands) to the user.
ro: Îi indică lui debconf să afișeze utilizatorului setul acumulat de întrebări (din comenzile INPUT).

note: type: Plain text
en: If the backup capability is supported and the user indicates they want to back up a step, debconf replies with code 30.
ro: Dacă capacitatea de copiere de rezervă este acceptată și utilizatorul indică faptul că dorește să copieze de rezervă un pas, debconf răspunde cu codul 30.

note: type: Plain text
en: Clears the accumulated set of questions (from INPUT commands) without displaying them.
ro: Șterge setul acumulat de întrebări (de la comenzile INPUT) fără a le afișa.

note: type: Plain text
en: Some debconf frontends can display a number of questions to the user at once.  Maybe in the future a frontend will even be able to group these questions into blocks on screen. BEGINBLOCK and ENDBLOCK can be placed around a set of INPUT commands to indicate blocks of questions (and blocks can even be nested). Since no debconf frontend is so sophisticated yet, these commands are ignored for now.
ro: Unele interfețe debconf pot afișa utilizatorului un număr de întrebări simultan.  Poate că în viitor o interfață va putea chiar să grupeze aceste întrebări în blocuri pe ecran. BEGINBLOCK și ENDBLOCK pot fi plasate în jurul unui set de comenzi INPUT pentru a indica blocuri de întrebări (iar blocurile pot fi chiar imbricate). Deoarece nicio interfață debconf nu este încă atât de sofisticată, aceste comenzi sunt ignorate pentru moment.

note: type: Plain text
en: This command tells debconf that you're done talking to it. Often debconf can detect termination of your program and this command is not necessary.
ro: Această comandă îi indică lui debconf că ați terminat de dialogat cu el. Adesea, debconf poate detecta terminarea programului dvs. și această comandă nu este necesară.

note: type: TP
en: B<GET question>
ro: B<GET întrebare>

note: type: Plain text
en: After using INPUT and GO to display a question, you can use this command to get the value the user entered. The value is returned in the extended result code.
ro: După ce utilizați INPUT și GO pentru a afișa o întrebare, puteți utiliza această comandă pentru a obține valoarea introdusă de utilizator. Valoarea este returnată în codul de rezultat extins.

note: type: TP
en: B<SET question value>
ro: B<SET întrebare valoare>

note: type: Plain text
en: This sets the value of a question, and it can be used to override the default value with something your program calculates on the fly.
ro: Aceasta stabilește valoarea unei întrebări și poate fi utilizată pentru a înlocui valoarea implicită cu ceva ce programul dvs. calculează din mers.

note: type: TP
en: B<RESET question>
ro: B<RESET întrebare>

note: type: Plain text
en: This resets the question to its default value (as is specified in the 'Default' field of its template).
ro: Aceasta readuce întrebarea la valoarea sa implicită (așa cum este specificată în câmpul „ Default ” al șablonului său).

note: type: TP
en: B<SUBST question key value>
ro: B<SUBST întrebare cheie valoare>

note: type: Plain text
en: Questions can have substitutions embedded in their 'Description' and 'Choices' fields (use of substitutions in 'Choices' fields is a bit of a hack though; a better mechanism will eventually be developed). These substitutions look like "${key}". When the question is displayed, the substitutions are replaced with their values. This command can be used to set the value of a substitution. This is useful if you need to display some message to the user that you can't hard-code in the templates file.
ro: Întrebările pot avea substituții încorporate în câmpurile „Description” și „Choices” (utilizarea substituțiilor în câmpurile „Choices” este un pic de improvizație; un mecanism mai bun va fi dezvoltat în cele din urmă). Aceste substituții arată ca „${key}”. Atunci când întrebarea este afișată, substituțiile sunt înlocuite cu valorile lor. Această comandă poate fi utilizată pentru a defini valoarea unei substituții. Acest lucru este util dacă trebuie să afișați utilizatorului un mesaj pe care nu îl puteți codifica în interiorul codului din fișierul de șabloane.

note: type: Plain text
en: Do not try to use SUBST to change the default value of a question; it won't work since there is a SET command explicitly for that purpose.
ro: Nu încercați să utilizați SUBST pentru a schimba valoarea implicită a unei întrebări; nu va funcționa, deoarece există o comandă SET explicită pentru acest scop.

note: type: TP
en: B<FGET question flag>
ro: B<FGET întrebare fanion>

note: type: Plain text
en: Questions can have flags associated with them. The flags can have a value of "true" or "false". This command returns the value of a flag.
ro: Întrebările pot avea asociate fanioane. Fanioanele pot avea o valoare de „true” sau „false”. Această comandă returnează valoarea unui fanion.

note: type: TP
en: B<FSET question flag value>
ro: B<FSET întrebare fanion valoare>

note: type: Plain text
en: This sets the value of a question's flag. The value must be either "true" or "false".
ro: Aceasta stabilește valoarea fanionului unei întrebări. Valoarea trebuie să fie „true” sau „false”.

note: type: Plain text
en: One common flag is the "seen" flag. It is normally only set if a user has already seen a question. Debconf usually only displays questions to users if they have the seen flag set to "false" (or if it is reconfiguring a package).  Sometimes you want the user to see a question again -- in these cases you can set the seen flag to false to force debconf to redisplay it.
ro: Un fanion comun este fanionul „seen”. În mod normal, acesta este activat numai dacă un utilizator a văzut deja o întrebare. De obicei, Debconf afișează întrebările utilizatorilor numai dacă aceștia au fanionul B<seen> definit la „false” (sau dacă reconfigurează un pachet). Uneori doriți ca utilizatorul să vadă din nou o întrebare - în aceste cazuri, puteți defini fanionul B<seen> la „false” pentru a forța debconf să o afișeze din nou.

note: type: TP
en: B<METAGET question field>
ro: B<METAGET întrebare câmp>

note: type: Plain text
en: This returns the value of any field of a question's associated template (the Description, for example).
ro: Aceasta returnează valoarea oricărui câmp din șablonul asociat unei întrebări ( descrierea B<Description>, de exemplu).

note: type: TP
en: B<REGISTER template question>
ro: B<REGISTER șablon întrebare>

note: type: Plain text
en: This creates a new question that is bound to a template. By default each template has an associated question with the same name. However, any number of questions can really be associated with a template, and this lets you create more such questions.
ro: Aceasta creează o întrebare nouă care este legată de un șablon. În mod implicit, fiecare șablon are asociată o întrebare cu același nume. Cu toate acestea, orice număr de întrebări poate fi asociat cu un șablon, iar acest lucru vă permite să creați mai multe astfel de întrebări.

note: type: TP
en: B<UNREGISTER question>
ro: B<UNREGISTER întrebare>

note: type: Plain text
en: This removes a question from the database.
ro: Aceasta elimină o întrebare din baza de date.

note: type: Plain text
en: Call this in your postrm when your package is purged. It removes all of your package's questions from debconf's database.
ro: Apelați această comandă în scriptul dvs. „postrm” atunci când pachetul dvs. este purjat. Aceasta elimină toate întrebările pachetului dvs. din baza de date a debconf.

note: type: TP
en: B<X_LOADTEMPLATEFILE /path/to/templates [owner]>
ro: B<X_LOADTEMPLATEFILE /ruta/la/templates [proprietar]>

note: type: Plain text
en: This extension loads the specified template file into debconf's database.  The owner defaults to the package that is being configured with debconf.
ro: Această extensie încarcă fișierul șablon specificat în baza de date a debconf.  Proprietarul este implicit pachetul care este configurat cu debconf.

note: type: Plain text
en: Here is a simple example of the debconf protocol in action.
ro: Iată un exemplu simplu de protocol debconf în acțiune.

note: type: Plain text
en:   INPUT medium debconf/frontend
      30 question skipped
      FSET debconf/frontend seen false
      0 false
      INPUT high debconf/frontend
      0 question will be asked
      GO
      [ Here debconf displays a question to the user. ]
      0 ok
      GET no/such/question
      10 no/such/question doesn't exist
      GET debconf/frontend
      0 Dialog
ro:   INPUT medium debconf/frontend
      30 question skipped
      FSET debconf/frontend seen false
      0 false
      INPUT high debconf/frontend
      0 question will be asked
      GO
      [ Aici debconf afișează o întrebare pentru utilizator. ]
      0 ok
      GET no/such/question
      10 no/such/question doesn't exist
      GET debconf/frontend
      0 Dialog

note: type: SH
en: LIBRARIES
ro: BIBLIOTECI

note: type: Plain text
en: Setting things up so you can talk to debconf, and speaking the debconf protocol by hand is a little too much work, so some thin libraries exist to relieve this minor drudgery.
ro: Configurarea lucrurilor astfel încât să puteți comunica cu debconf și să dialogați cu el prin intermediul protocolului debconf este un pic prea mult de lucru, așa că există câteva biblioteci mici pentru a ușura această corvoadă minoră.

note: type: Plain text
en: For shell programming, there is the /usr/share/debconf/confmodule library, which you can source at the top of a shell script, and talk to debconf in a fairly natural way, using lower-case versions of the debconf protocol commands, that are prefixed with "db_" (ie, "db_input" and "db_go"). For details, see B<confmodule>(3)  .
ro: Pentru programarea în shell, există biblioteca „/usr/share/debconf/confmodule”, pe care o puteți utiliza ca sursă în partea de sus a unui script de tip shell și care vă permite să comunicați cu debconf într-un mod destul de natural, utilizând versiuni cu minuscule ale comenzilor protocolului debconf, care sunt prefixate cu „db_” (de exemplu, „db_input” și „db_go”). Pentru detalii, consultați B<confmodule>(3) .

note: type: Plain text
en: Perl programmers can use the B<Debconf::Client::ConfModule>(3pm)  perl module, and python programmers can use the debconf python module.
ro: Programatorii Perl pot utiliza modulul perl B<Debconf::Client::ConfModule>(3pm), iar programatorii python pot utiliza modulul python debconf.

note: type: Plain text
en: The rest of this manual will use the /usr/share/debconf/confmodule library in example shell scripts. Here is an example config script using that library, that just asks a question:
ro: Restul acestui manual va utiliza biblioteca „/usr/share/debconf/confmodule” în exemple de scripturi shell. Iată un exemplu de script de configurare care utilizează această bibliotecă, care pune doar o întrebare:

note: type: Plain text
en: Notice the uses of "|| true" to prevent the script from dying if debconf decides it can't display a question, or the user tries to back up. In those situations, debconf returns a non-zero exit code, and since this shell script is set -e, an untrapped exit code would make it abort.
ro: Observați utilizarea lui „|| true” pentru a preveni moartea scriptului dacă debconf decide că nu poate afișa o întrebare sau dacă utilizatorul încearcă să dea înapoi. În aceste situații, debconf returnează un cod de ieșire diferit de zero și, din moment ce acest script shell este definit cu „ -e”, un cod de ieșire nepreluat l-ar face să abandoneze.

note: type: Plain text
en: And here is a corresponding postinst script, that uses the user's answer to the question to see if the system should be rebooted (a rather absurd example..):
ro: Și aici este un script „postinst” corespunzător, care utilizează răspunsul utilizatorului la întrebare pentru a vedea dacă sistemul ar trebui repornit (un exemplu destul de absurd..):

note: type: Plain text
en: Notice the use of the $RET variable to get at the extended return code from the GET command, which holds the user's answer to the question.
ro: Observați utilizarea variabilei $RET pentru a obține codul de răspuns extins de la comanda GET, care conține răspunsul utilizatorului la întrebare.

note: type: SH
en: THE POSTINST SCRIPT
ro: SCRIPTUL POSTINST

note: type: Plain text
en: The last section had an example of a postinst script that uses debconf to get the value of a question, and act on it. Here are some things to keep in mind when writing postinst scripts that use debconf:
ro: Ultima secțiune conținea un exemplu de script „postinst” care utilizează debconf pentru a obține valoarea unei întrebări și pentru a acționa în funcție de aceasta. Iată câteva lucruri de care trebuie să țineți cont atunci când scrieți scripturi „postinst” care utilizează debconf:

note: type: Plain text
en: Avoid asking questions in the postinst. Instead, the config script should ask questions using debconf, so that pre-configuration will work.
ro: Evitați să puneți întrebări în „postinst”. În schimb, scriptul „config” ar trebui să pună întrebări utilizând debconf, astfel încât pre-configurarea să funcționeze.

note: type: Plain text
en: Always source /usr/share/debconf/confmodule at the top of your postinst, even if you won't be running any db_* commands in it.  This is required to make sure the config script gets a chance to run (see HACKS for details).
ro: Întotdeauna sursa „/usr/share/debconf/confmodule” în partea de sus a scriptului dvs. „postinst”, chiar dacă nu veți executa nicio comandă db_* în acesta. Acest lucru este necesar pentru a vă asigura că scriptul „config” are șansa de a rula (consultați secțiunea TRUCURI pentru detalii).

note: type: Plain text
en: Avoid outputting anything to stdout in your postinst, since that can confuse debconf, and postinst should not be verbose anyway. Output to stderr is ok, if you must.
ro: Evitați să trimiteți ceva la ieșirea standard (stdout) în „postinst”, deoarece acest lucru poate crea confuzie în debconf, iar „postinst” nu ar trebui să fie oricum prea „vorbăreț”. Ieșirea la ieșirea de eroare standard este ok, dacă este necesar.

note: type: Plain text
en: If your postinst launches a daemon, make sure you tell debconf to STOP at the end, since debconf can become a little confused about when your postinst is done otherwise.
ro: Dacă scriptul dvs. „postinst” lansează un demon, asigurați-vă că îi indicați lui debconf să efectueze STOP la sfârșit, deoarece debconf poate deveni puțin confuz cu privire la momentul în care scriptul dvs. postinst este gata.

note: type: Plain text
en: Make your postinst script accept a first parameter of "reconfigure". It can treat it just like "configure". This will be used in a later version of debconf to let postinsts know when they are reconfigured.
ro: Asigurați-vă că scriptul „postinst” acceptă un prim parametru „reconfigure”. Acesta îl poate trata la fel ca „configure”. Acesta va fi utilizat într-o versiune ulterioară a debconf pentru a anunța scripturile „postinist” atunci când sunt reconfigurate.

note: type: SH
en: OTHER SCRIPTS
ro: ALTE SCRIPTURI

note: type: Plain text
en: Besides the config script and postinst, you can use debconf in any of the other maintainer scripts. Most commonly, you'll be using debconf in your postrm, to call the PURGE command when your package is purged, to clean out its entries in the debconf database. (This is automatically set up for you by B<dh_installdebconf>(1)B<,> by the way.)
ro: Pe lângă scripturile „config” și „postinst”, puteți utiliza debconf în oricare dintre celelalte scripturi ale întreținătorului. Cel mai frecvent, veți utiliza debconf în „postrm”, pentru a apela comanda PURGE atunci când pachetul dvs. este purjat, pentru a curăța intrările sale din baza de date debconf. (Apropo, acest lucru este configurat automat pentru dvs. de B<dh_installdebconf>(1)B<,>).

note: type: Plain text
en: A more involved use of debconf would be if you want to use it in the postrm when your package is purged, to ask a question about deleting something. Or maybe you find you need to use it in the preinst or prerm for some reason. All of these uses will work, though they'll probably involve asking questions and acting on the answers in the same program, rather than separating the two activities as is done in the config and postinst scripts.
ro: O utilizare mai implicată a debconf ar fi dacă doriți să o utilizați în „postrm” atunci când pachetul dvs. este curățat, pentru a pune o întrebare despre ștergerea a ceva. Sau poate descoperiți că trebuie să îl folosiți în „preinst” sau „prerm” pentru un motiv oarecare. Toate aceste utilizări vor funcționa, deși vor implica probabil adresarea de întrebări și luarea de măsuri în funcție de răspunsuri în același program, mai degrabă decât separarea celor două activități, așa cum se face în scripturile „config” și „postinst”.

note: type: Plain text
en: Note that if your package's sole use of debconf is in the postrm, you should make your package's postinst source /usr/share/debconf/confmodule, to give debconf a chance to load up your templates file into its database. Then the templates will be available when your package is being purged.
ro: Rețineți că, dacă singura utilizare a debconf de către pachetul dvs. este în „postrm”, ar trebui să faceți ca scriptul „postinst” a pachetului dvs. să includă „/usr/share/debconf/confmodule”, pentru a da debconf o șansă de a încărca fișierul șabloanelor dvs. în baza sa de date. Apoi, șabloanele vor fi disponibile atunci când pachetul dvs. este purjat.

note: type: Plain text
en: You can also use debconf in other, standalone programs. The issue to watch out for here is that debconf is not intended to be, and must not be used as a registry. This is unix after all, and programs are configured by files in /etc, not by some nebulous debconf database (that is only a cache anyway and might get blown away). So think long and hard before using debconf in a standalone program.
ro: De asemenea, puteți utiliza debconf în alte programe de sine stătătoare. Problema la care trebuie să fiți atenți aici este că debconf nu este destinat să fie și nu trebuie să fie utilizat ca un registru. La urma urmei, acesta este unix, iar programele sunt configurate de fișiere din „/etc”, nu de o bază de date nebuloasă debconf (care oricum este doar o cache și ar putea fi distrusă). Așa că gândiți-vă bine înainte de a utiliza debconf într-un program autonom.

note: type: Plain text
en: There are times when it can make sense, as in the apt-setup program which uses debconf to prompt the user in a manner consistent with the rest of the debian install process, and immediately acts on their answers to set up apt's sources.list.
ro: Există momente în care poate avea sens, cum ar fi în programul apt-setup care utilizează debconf pentru a solicita utilizatorului o manieră consecventă cu restul procesului de instalare debian și acționează imediat în funcție de răspunsurile acestuia pentru a configura fișierul sources.list al apt.

note: type: SH
en: LOCALIZATION
ro: LOCALIZAREA

note: type: Plain text
en: Debconf supports localization of templates files. This is accomplished by adding more fields, with translated text in them. Any of the fields can be translated. For example, you might want to translate the description into Spanish. Just make a field named 'Description-es' that holds the translation. If a translated field is not available, debconf falls back to the normal English field.
ro: Debconf acceptă traducerea fișierelor șablon. Acest lucru se realizează prin adăugarea mai multor câmpuri, cu text tradus în ele. Oricare dintre câmpuri poate fi tradus. De exemplu, ați putea dori să traduceți descrierea în română. Trebuie doar să creați un câmp numit „Description-ro” care să conțină traducerea. Dacă un câmp tradus nu este disponibil, debconf revine la câmpul normal în limba engleză.

note: type: Plain text
en: Besides the 'Description' field, you should translate the 'Choices' field of a select or multiselect template. Be sure to list the translated choices in the same order as they appear in the main 'Choices' field. You do not need to translate the 'Default' field of a select or multiselect question, and the value of the question will be automatically returned in English.
ro: Pe lângă câmpul „Description”, trebuie să traduceți câmpul „Choices” al unui șablon B<select> sau B<multiselect>. Asigurați-vă că listați opțiunile traduse în aceeași ordine în care apar în câmpul principal „Choices”. Nu este necesar să traduceți câmpul „Default” al unei întrebări B<select> sau B<multiselect>, iar valoarea întrebării va fi returnată automat în limba engleză.

note: type: Plain text
en: You will find it easier to manage translations if you keep them in separate files; one file per translation. In the past, the B<debconf-getlang>(1)  and B<debconf-mergetemplate>(1)  programs were used to manage debian/template.ll files. This has been superseded by the B<po-debconf>(7)  package, which lets you deal with debconf translations in .po files, just like any other translations. Your translators will thank you for using this new improved mechanism.
ro: Vă va fi mai ușor să gestionați traducerile dacă le păstrați în fișiere separate; un fișier pentru fiecare traducere. În trecut, programele B<debconf-getlang>(1) și B<debconf-mergetemplate>(1) erau utilizate pentru a gestiona fișierele debian/template.ll. Acestea au fost înlocuite de pachetul B<po-debconf>(7), care vă permite să gestionați traducerile debconf în fișiere .po, la fel ca orice alte traduceri. Traducătorii dvs. vă vor mulțumi pentru utilizarea acestui nou mecanism îmbunătățit.

note: type: Plain text
en: For the details on po-debconf, see its man page. If you're using debhelper, converting to po-debconf is as simple as running the B<debconf-gettextize>(1)  command once, and adding a Build-Dependency on po-debconf and on debhelper (E<gt>= 4.1.13).
ro: Pentru detalii despre po-debconf, consultați pagina sa de manual. Dacă utilizați debhelper, convertirea la po-debconf este la fel de simplă ca și rularea comenzii B<debconf-gettextize>(1) o dată și adăugarea unui Build-Dependency în po-debconf și în debhelper (E<gt>= 4.1.13).

note: type: SH
en: PUTTING IT ALL TOGETHER
ro: PUNÂND TOTUL CAP LA CAP

note: type: Plain text
en: So you have a config script, a templates file, a postinst script that uses debconf, and so on. Putting these pieces together into a debian package isn't hard. You can do it by hand, or can use B<dh_installdebconf>(1)  which will merge your translated templates, copy the files into the right places for you, and can even generate the call to PURGE that should go in your postrm script. Make sure that your package depends on debconf (E<gt>= 0.5), since earlier versions were not compatible with everything described in this manual. And you're done.
ro: Deci, aveți un script „config”, un fișier templates, un script „postinst” care utilizează debconf și așa mai departe. Punerea acestor piese împreună într-un pachet debian nu este dificilă. O puteți face manual sau puteți utiliza B<dh_installdebconf>(1), care va fuziona șabloanele traduse, va copia fișierele în locurile potrivite pentru dvs. și poate chiar genera apelul la PURGE care ar trebui să apară în scriptul „postrm”. Asigurați-vă că pachetul dvs. depinde de debconf (E<gt>= 0.5), deoarece versiunile anterioare nu erau compatibile cu tot ceea ce este descris în acest manual. Și ați terminat.

note: type: Plain text
en: Well, except for testing, debugging, and actually using debconf for more interesting things than asking a few basic questions. For that, read on..
ro: Este în regulă, cu excepția testării, a depanării și a utilizării debconf pentru lucruri mai interesante decât adresarea unor întrebări de bază. Pentru asta, citiți mai departe..

note: type: SH
en: DEBUGGING
ro: DEPANAREA

note: type: Plain text
en: So you have a package that's supposed to use debconf, but it doesn't quite work. Maybe debconf is just not asking that question you set up. Or maybe something weirder is happening; it spins forever in some kind of loop, or worse. Luckily, debconf has plenty of debugging facilities.
ro: Deci, aveți un pachet care ar trebui să utilizeze debconf, dar nu prea funcționează. Poate că debconf pur și simplu nu pune întrebarea pe care ați stabilit-o. Sau poate se întâmplă ceva mai ciudat; se învârte la nesfârșit într-un fel de buclă, sau mai rău. Din fericire, debconf are o mulțime de facilități de depanare.

note: type: Plain text
en: The first thing to reach for is the DEBCONF_DEBUG environment variable.  If you set and export DEBCONF_DEBUG=developer, debconf will output to stderr a dump of the debconf protocol as your program runs. It'll look something like this -- the typo is made clear:
ro: Primul lucru pe care trebuie să îl căutați este variabila de mediu DEBCONF_DEBUG. Dacă definiți și exportați DEBCONF_DEBUG=developer, debconf va afișa la ieșirea de eroare standard o captură a protocolului debconf în timp ce programul dvs. rulează. Acesta va arăta cam așa - greșeala de tastare este evidențiată:

note: type: Plain text
en: It's rather useful to use debconf's readline frontend when you're debugging (in the author's opinion), as the questions don't get in the way, and all the debugging output is easily preserved and logged.
ro: Este destul de util să utilizați interfața „readline” a debconf atunci când depanați (în opinia autorului), deoarece întrebările nu vă încurcă, iar toate rezultatele de depanare sunt ușor de păstrat și de înregistrat.

note: type: Plain text
en: If this environment variable is set to 'true', the frontend will display the values in Choices-C fields (if present) of select and multiselect templates rather than the descriptive values.
ro: Dacă această variabilă de mediu este definită la „true”, interfața va afișa valorile din câmpurile Choices-C (dacă sunt prezente) ale șabloanelor B<select> și B<multiselect> mai degrabă decât valorile descriptive.

note: type: Plain text
en: Another useful tool is the B<debconf-communicate>(1)  program. Fire it up and you can speak the raw debconf protocol to debconf, interactively. This is a great way to try stuff out on the fly.
ro: Un alt instrument util este programul B<debconf-communicate>(1). Porniți-l și puteți comunica cu protocolul debconf în mod interactiv cu debconf. Aceasta este o modalitate excelentă de a încerca lucruri din mers.

note: type: Plain text
en: If a user is reporting a problem, B<debconf-show>(1)  can be used to dump out all the questions owned by your package, displaying their values and whether the user has seen them.
ro: Dacă un utilizator raportează o problemă, B<debconf-show>(1) poate fi utilizat pentru a afișa toate întrebările deținute de pachetul dvs., afișând valorile acestora și dacă utilizatorul le-a văzut.

note: type: Plain text
en: To avoid the often tedious build/install/debug cycle, it can be useful to load up your templates with B<debconf-loadtemplate>(1)  and run your config script by hand with the B<debconf>(1)  command. However, you still have to do that as root, right? Not so good.  And ideally you'd like to be able to see what a fresh installation of your package looks like, with a clean debconf database.
ro: Pentru a evita ciclul adesea plictisitor de compilare/ instalare/depanare, poate fi util să vă încărcați șabloanele cu B<debconf-loadtemplate>(1) și să vă rulați manual scriptul „config” cu comanda B<debconf>(1). Cu toate acestea, trebuie să faceți toate acestea ca root, nu? Nu este prea grozav. Și ideal ar fi să puteți vedea cum arată o instalare proaspătă a pachetului dumneavoastră, cu o bază de date debconf curată.

note: type: Plain text
en: It turns out that if you set up a ~/.debconfrc file for a normal user, pointing at a personal config.dat and template.dat for the user, you can load up templates and run config scripts all you like, without any root access. If you want to start over with a clean database, just blow away the *.dat files.
ro: Se pare că, dacă configurați un fișier „~/.debconfrc” pentru un utilizator normal, care indică un fișier config.dat și template.dat personal pentru utilizator, puteți încărca șabloane și rula scripturi „config” cât doriți, fără acces root. Dacă doriți să începeți din nou cu o bază de date curată, pur și simplu îndepărtați fișierele *.dat.

note: type: Plain text
en: For details about setting this up, see B<debconf.conf>(5)B<,> and note that /etc/debconf.conf makes a good template for a personal ~/.debconfrc file.
ro: Pentru detalii despre această configurare, consultați B<debconf.conf>(5)B<,> și rețineți că „/etc/debconf.conf” este un model bun pentru un fișier „~/.debconfrc” personal.

note: type: SH
en: ADVANCED PROGRAMMING WITH DEBCONF
ro: PROGRAMARE AVANSATĂ CU DEBCONF

note: type: SS
en: Config file handling
ro: Gestionarea fișierelor de configurare

note: type: Plain text
en: Many of you seem to want to use debconf to help manage config files that are part of your package. Perhaps there is no good default to ship in a conffile, and so you want to use debconf to prompt the user, and write out a config file based on their answers. That seems easy enough to do, but then you consider upgrades, and what to do when someone modifies the config file you generate, and dpkg-reconfigure, and ...
ro: Mulți dintre dvs. par să dorească să utilizeze debconf pentru a ajuta la gestionarea fișierelor de configurare care fac parte din pachetul dvs. Poate că nu există o valoare implicită bună pentru a fi livrată într-un pachet și, prin urmare, doriți să utilizați debconf pentru a întreba utilizatorul și a scrie un fișier de configurare pe baza răspunsurilor sale. Acest lucru pare destul de ușor de făcut, dar apoi vă gândiți la actualizări și ce să faceți atunci când cineva modifică fișierul de configurare pe care îl generați, și dpkg-reconfigure, și ...

note: type: Plain text
en: There are a lot of ways to do this, and most of them are wrong, and will often earn you annoyed bug reports. Here is one right way to do it. It assumes that your config file is really just a series of shell variables being set, with comments in between, and so you can just source the file to "load" it.  If you have a more complicated format, reading (and writing) it becomes a bit trickier.
ro: Există o mulțime de modalități de a face acest lucru, iar cele mai multe dintre ele sunt greșite și vă vor aduce deseori rapoarte de eroare enervante. Iată o modalitate corectă de a face acest lucru. Aceasta presupune că fișierul dvs. de configurare este de fapt doar o serie de variabile shell care trebuiesc definite, cu comentarii între ele, și astfel tot ce aveți de făcut, este doar să includeți sursa fișierului (ce conține valorile acestor variabile) pentru a-l „încărca”. Dacă aveți un format mai complicat, citirea (și scrierea) acestuia devine un pic mai complicată.

note: type: Plain text
en: Your config script will look something like this:
ro: Scriptul dvs. de configurare va arăta cam așa:

note: type: Plain text
en:  # Load config file, if it exists.
     if [ -e $CONFIGFILE ]; then
     	. $CONFIGFILE || true
ro:  # Încarcă fișierul de configurare, dacă există.
     if [ -e $CONFIGFILE ]; then
     	. $CONFIGFILE || true

note: type: Plain text
en:  	# Store values from config file into
     	# debconf db.
     	db_set mypackage/foo "$FOO"
     	db_set mypackage/bar "$BAR"
     fi
ro:  	# Stochează valorile din fișierul de configurare
     	# în debconf db.
     	db_set mypackage/foo "$FOO"
     	db_set mypackage/bar "$BAR"
     fi

note: type: Plain text
en:  # Ask questions.
     db_input medium mypackage/foo || true
     db_input medium mypackage/bar || true
     db_go || true
ro:  # Pune întrebări.
     db_input medium mypackage/foo || true
     db_input medium mypackage/bar || true
     db_go || true

note: type: Plain text
en: And the postinst will look something like this:
ro: Iar scriptul „postinst” va arăta cam așa:

note: type: Plain text
en:  # Generate config file, if it doesn't exist.
     # An alternative is to copy in a template
     # file from elsewhere.
     if [ ! -e $CONFIGFILE ]; then
     	echo "# Config file for my package" E<gt> $CONFIGFILE
     	echo "FOO=" E<gt>E<gt> $CONFIGFILE
     	echo "BAR=" E<gt>E<gt> $CONFIGFILE
     fi
ro:  # Generează fișierul de configurare, dacă acesta nu există.
     # O alternativă este să copiați un fișier șablon din altă parte.
     if [ ! -e $CONFIGFILE ]; then
     	echo "# Fișierul de configurare pentru pachetul meu" E<gt> $CONFIGFILE
     	echo "FOO=" E<gt>E<gt> $CONFIGFILE
     	echo "BAR=" E<gt>E<gt> $CONFIGFILE
     fi

note: type: Plain text
en:  # Substitute in the values from the debconf db.
     # There are obvious optimizations possible here.
     # The cp before the sed ensures we do not mess up
     # the config file's ownership and permissions.
     db_get mypackage/foo
     FOO="$RET"
     db_get mypackage/bar
     BAR="$RET"
     cp -a -f $CONFIGFILE $CONFIGFILE.tmp
ro:  # Înlocuiește valorile din db debconf.
     # Sunt posibile optimizări evidente aici.
     # «cp» înainte de «sed» ne asigură că nu încurcăm
     # proprietarul și permisiunile fișierului de configurare.
     # the config file's ownership and permissions.
     db_get mypackage/foo
     FOO="$RET"
     db_get mypackage/bar
     BAR="$RET"
     cp -a -f $CONFIGFILE $CONFIGFILE.tmp

note: type: Plain text
en:  # If the admin deleted or commented some variables but then set
     # them via debconf, (re-)add them to the conffile.
     test -z "$FOO" || grep -Eq '^ *FOO=' $CONFIGFILE || \e
     	echo "FOO=" E<gt>E<gt> $CONFIGFILE
     test -z "$BAR" || grep -Eq '^ *BAR=' $CONFIGFILE || \e
     	echo "BAR=" E<gt>E<gt> $CONFIGFILE
ro:  # Dacă administratorul a șters sau a comentat unele variabile,
     # dar apoi le-a definit prin debconf, (re)adăugați-le în conffile.
     test -z "$FOO" || grep -Eq '^ *FOO=' $CONFIGFILE || \e
     	echo "FOO=" E<gt>E<gt> $CONFIGFILE
     test -z "$BAR" || grep -Eq '^ *BAR=' $CONFIGFILE || \e
     	echo "BAR=" E<gt>E<gt> $CONFIGFILE

note: type: Plain text
en: Consider how these two scripts handle all the cases. On fresh installs the questions are asked by the config script, and a new config file generated by the postinst. On upgrades and reconfigures, the config file is read in, and the values in it are used to change the values in the debconf database, so the admin's manual changes are not lost. The questions are asked again (and may or may not be displayed). Then the postinst substitutes the values back into the config file, leaving the rest of it unchanged.
ro: Luați în considerare modul în care aceste două scripturi tratează toate cazurile. La noile instalări, întrebările sunt adresate de scriptul „config”, iar un nou fișier se configurare este generat de „postinst”. La actualizări și reconfigurări, fișierul de configurare este citit, iar valorile din acesta sunt utilizate pentru a modifica valorile din baza de date debconf, astfel încât modificările manuale ale administratorului să nu fie pierdute. Întrebările sunt puse din nou (și pot fi afișate sau nu). Apoi „postinst” înlocuiește valorile înapoi în fișierul de configurare, lăsând restul acestuia neschimbat.

note: type: SS
en: Letting the user back up
ro: Permițând utilizatorului să revină la întrebarea anterioară

note: type: Plain text
en: Few things are more frustrating when using a system like debconf than being asked a question, and answering it, then moving on to another screen with a new question on it, and realizing that hey, you made a mistake, with that last question, and you want to go back to it, and discovering that you can't.
ro: Puține lucruri sunt mai frustrante atunci când folosești un sistem precum debconf decât să ți se pună o întrebare, să răspunzi la ea, apoi să treci la un alt ecran cu o nouă întrebare pe el și să-ți dai seama că ai făcut o greșeală cu ultima întrebare și vrei să te întorci la ea și să descoperi că nu poți.

note: type: Plain text
en: Since debconf is driven by your config script, it can't jump back to a previous question on its own but with a little help from you, it can accomplish this feat. The first step is to make your config script let debconf know it is capable of handling the user pressing a back button.  You use the CAPB command to do this, passing backup as a parameter.
ro: Deoarece debconf este condus de scriptul dvs. de configurare, acesta nu poate reveni singur la o întrebare anterioară, dar cu puțin ajutor din partea dvs., poate realiza această „performanță”. Primul pas este să faceți ca scriptul dvs. de configurare să informeze debconf că este capabil să gestioneze apăsarea unui buton înapoi de către utilizator. Utilizați comanda CAPB pentru a face acest lucru, trecând „backup” ca parametru.

note: type: Plain text
en: Then after each GO command, you must test to see if the user asked to back up (debconf returns a code of 30), and if so jump back to the previous question.
ro: Apoi, după fiecare comandă GO, trebuie să verificați dacă utilizatorul a cerut să revină la întrebarea anterioară (debconf returnează un cod de 30) și, în caz afirmativ, să săriți înapoi la întrebarea anterioară.

note: type: Plain text
en: There are several ways to write the control structures of your program so it can jump back to previous questions when necessary. You can write goto-laden spaghetti code. Or you can create several functions and use recursion. But perhaps the cleanest and easiest way is to construct a state machine. Here is a skeleton of a state machine that you can fill out and expand.
ro: Există mai multe moduri de a scrie structurile de control ale programului dvs. astfel încât acesta să poată reveni la întrebările anterioare atunci când este necesar. Puteți scrie cod „spaghetti” încărcat de goto-uri. Sau puteți crea mai multe funcții și folosi recursivitatea. Dar poate cea mai curată și mai ușoară modalitate este să construiți o mașină de stare. Iată un schelet de mașină de stare pe care îl puteți completa și extinde.

note: type: Plain text
en:  STATE=1
     while true; do
     	case "$STATE" in
      	1)
      		# Two unrelated questions.
     		db_input medium my/question || true
     		db_input medium my/other_question || true
     	;;
     	2)
     		# Only ask this question if the
     		# first question was answered in
     		# the affirmative.
            	db_get my/question
     		if [ "$RET" = "true" ]; then
     			db_input medium my/dep_question || true
     		fi
      	;;
     	*)
     		# The default case catches when $STATE is greater than the
     		# last implemented state, and breaks out of the loop. This
     		# requires that states be numbered consecutively from 1
     		# with no gaps, as the default case will also be entered
     		# if there is a break in the numbering
     		break # exits the enclosing "while" loop
      	;;
      	esac
ro:  STATE=1
     while true; do
     	case "$STATE" in
      	1)
      		# Două întrebări care nu au legătură.
     		db_input medium my/question || true
     		db_input medium my/other_question || true
     	;;
     	2)
     		# Puneți această întrebare numai dacă
     		# răspunsul la prima întrebare a fost
     		# afirmativ.
            	db_get my/question
     		if [ "$RET" = "true" ]; then
     			db_input medium my/dep_question || true
     		fi
      	;;
     	*)
     		# Cazul implicit este detectat atunci când $STATE este mai mare
     		# decât ultima stare implementată și iese din buclă. Acest lucru
     		#  necesită ca stările să fie numerotate consecutiv de la 1 fără
     		# întreruperi, deoarece cazul implicit va fi introdus și dacă există
     		# o întrerupere în numerotare
     		break # iese din bucla „while”.
      	;;
      	esac

note: type: Plain text
en:  if [ $STATE -eq 0 ]; then
     	# The user has asked to back up from the first
     	# question. This case is problematical. Regular
     	# dpkg and apt package installation isn't capable
     	# of backing up questions between packages as this
     	# is written, so this will exit leaving the package
     	# unconfigured - probably the best way to handle
     	# the situation.
     	exit 10
     fi
ro:  if [ $STATE -eq 0 ]; then
     	# Utilizatorul a cerut să revină de la prima întrebare.
     	# Acest caz este problematic. Instalarea obișnuită a
     	# pachetelor dpkg și apt nu este capabilă să facă o
     	# copie de rezervă a întrebărilor între pachete, așa
     	# cum este scris acest lucru, astfel încât va ieși
     	# lăsând pachetul neconfigurat - probabil cel mai
     	# bun mod de a gestiona situația.
     	exit 10
     fi

note: type: Plain text
en: Note that if all your config script does is ask a few unrelated questions, then there is no need for the state machine. Just ask them all, and GO; debconf will do its best to present them all in one screen, and the user won't need to back up.
ro: Rețineți că, dacă scriptul dvs. de configurare nu face decât să pună câteva întrebări fără legătură între ele, atunci nu este nevoie de mașina de stare. Doar puneți-le pe toate și „GO”; debconf va face tot posibilul să le prezinte pe toate într-un singur ecran, iar utilizatorul nu va trebui să se întoarcă.

note: type: SS
en: Preventing infinite loops
ro: Prevenirea buclelor infinite

note: type: Plain text
en: One gotcha with debconf comes up if you have a loop in your config script. Suppose you're asking for input and validating it, and looping if it's not valid:
ro: O problemă cu debconf apare dacă aveți o buclă în scriptul de configurare. Să presupunem că solicitați o intrare și o validați, iar dacă aceasta nu este validă, faceți o buclă:

note: type: Plain text
en: This looks ok at first glance. But consider what happens if the value of foo/bar is "" when this loop is entered, and the user has their priority set high, or is using a non-interactive frontend, and so they are not really asked for input. The value of foo/bar is not changed by the db_input, and so it fails the test and loops. And loops ...
ro: Acest lucru pare în regulă la prima vedere. Dar gândiți-vă ce se întâmplă dacă valoarea lui foo/bar este „” atunci când se intră în această buclă, iar utilizatorul are stabilită o prioritate ridicată sau utilizează o interfață neinteractivă și, prin urmare, nu i se solicită cu adevărat un răspuns. Valoarea lui foo/bar nu este modificată de db_input și, prin urmare, nu trece testul și intră în buclă. Și bucle ...

note: type: Plain text
en: One fix for this is to make sure that before the loop is entered, the value of foo/bar is set to something that will pass the test in the loop. So for example if the default value of foo/bar is "1", then you could RESET foo/bar just before entering the loop.
ro: O soluție este să vă asigurați că, înainte de a intra în buclă, valoarea foo/bar este stabilită la ceva care va trece testul în buclă. Astfel, de exemplu, dacă valoarea implicită a foo/bar este „1”, atunci puteți pune RESET foo/bar chiar înainte de a intra în buclă.

note: type: Plain text
en: Another fix is to check the return code of the INPUT command. If it is 30 then the user is not being shown the question you asked them, and you should break out of the loop.
ro: O altă soluție este să verificați codul de răspuns al comenzii INPUT. Dacă este 30, atunci utilizatorului nu i se arată întrebarea pe care i-ați pus-o și ar trebui să ieșiți din buclă.

note: type: SS
en: Choosing among related packages
ro: Alegerea dintre pachetele conexe

note: type: Plain text
en: Sometimes a set of related packages can be installed, and you want to prompt the user which of the set should be used by default. Examples of such sets are window managers, or ispell dictionary files.
ro: Uneori poate fi instalat un set de pachete conexe și doriți să întrebați utilizatorul care dintre acestea ar trebui să fie utilizate în mod implicit. Exemple de astfel de seturi sunt administratorii de ferestre sau fișierele de dicționar ispell.

note: type: Plain text
en: While it would be possible for each package in the set to simply prompt, "Should this package be default?", this leads to a lot of repetitive questions if several of the packages are installed. It's possible with debconf to present a list of all the packages in the set and allow the user to choose between them. Here's how.
ro: Deși ar fi posibil ca fiecare pachet din set să solicite pur și simplu „Acest pachet ar trebui să fie implicit?”, acest lucru duce la o mulțime de întrebări repetitive dacă sunt instalate mai multe pachete. Este posibil ca debconf să prezinte o listă a tuturor pachetelor din set și să permită utilizatorului să aleagă între ele. Iată cum.

note: type: Plain text
en: Make all the packages in the set use a shared template. Something like this:
ro: Faceți ca toate pachetele din set să utilizeze un șablon comun. Ceva de genul acesta:

note: type: Plain text
en:  Template: shared/window-manager
     Type: select
     Choices: ${choices}
     Description: Select the default window manager.
      Select the window manager that will be started by
      default when X starts.
ro:  Template: shared/window-manager
     Type: select
     Choices: ${choices}
     Description: Selectați administratorul implicit de ferestre.
      Selectați administratorul de ferestre care va fi pornit
      implicit la pornirea X.

note: type: Plain text
en: Each package should include a copy of the template. Then it should include some code like this in its config script:
ro: Fiecare pachet ar trebui să includă o copie a șablonului. Apoi ar trebui să includă un cod ca acesta în scriptul său „config”:

note: type: Plain text
en: A bit of an explanation is called for. By the time your config script runs, debconf has already read in all the templates for the packages that are being installed. Since the set of packages share a question, debconf records that fact in the owners field. By a strange coincidence, the format of the owners field is the same as that of the choices field (a comma and space delimited list of values).
ro: Este necesară o mică explicație. În momentul în care scriptul dvs. de configurare rulează, debconf a citit deja toate șabloanele pentru pachetele care sunt instalate. Deoarece setul de pachete are o întrebare comună, debconf înregistrează acest fapt în câmpul „owners”. Printr-o coincidență ciudată, formatul câmpului owners este același cu cel al câmpului „choices” (o listă de valori delimitată prin virgule și spații).

note: type: Plain text
en: The METAGET command can be used to get the list of owners and the list of choices. If they are different, then a new package has been installed. So use the SUBST command to change the list of choices to be the same as the list of owners, and ask the question.
ro: Comanda METAGET poate fi utilizată pentru a obține lista de proprietari și lista de opțiuni. Dacă acestea sunt diferite, atunci a fost instalat un pachet nou. Prin urmare, utilizați comanda SUBST pentru a modifica lista de opțiuni pentru a fi aceeași cu lista de proprietari și puneți întrebarea.

note: type: Plain text
en: When a package is removed, you probably want to see if that package is the currently selected choice, and if so, prompt the user to select a different package to replace it.
ro: Atunci când un pachet este eliminat, probabil doriți să vedeți dacă acel pachet este alegerea selectată în prezent și, în caz afirmativ, să solicitați utilizatorului să selecteze un alt pachet pentru a-l înlocui.

note: type: Plain text
en: This can be accomplished by adding something like this to the prerm scripts of all related packages (replacing E<lt>packageE<gt> with the package name):
ro: Acest lucru poate fi realizat prin adăugarea unui text ca acesta în scripturile „prerm” ale tuturor pachetelor aferente (înlocuind E<lt>packageE<gt> cu numele pachetului):

note: type: Plain text
en:  if [ -e /usr/share/debconf/confmodule ]; then
     	. /usr/share/debconf/confmodule
     	# I no longer claim this question.
     	db_unregister shared/window-manager
ro:  if [ -e /usr/share/debconf/confmodule ]; then
     	. /usr/share/debconf/confmodule
     	# Nu mai solicit această întrebare.
     	db_unregister shared/window-manager

note: type: Plain text
en:  	# See if the shared question still exists.
     	if db_get shared/window-manager; then
     		db_metaget shared/window-manager owners
     		db_subst shared/window-manager choices $RET
     		db_metaget shared/window-manager value
     		if [ "E<lt>packageE<gt>" = "$RET" ] ; then
     			db_fset shared/window-manager seen false
     			db_input high shared/window-manager || true
     			db_go || true
     		fi
ro:  	# Vedeți dacă întrebarea comună mai există.
     	if db_get shared/window-manager; then
     		db_metaget shared/window-manager owners
     		db_subst shared/window-manager choices $RET
     		db_metaget shared/window-manager value
     		if [ "E<lt>packageE<gt>" = "$RET" ] ; then
     			db_fset shared/window-manager seen false
     			db_input high shared/window-manager || true
     			db_go || true
     		fi

note: type: Plain text
en:  		# Now do whatever the postinst script did
     		# to update the window manager symlink.
     	fi
     fi
ro:  		# Acum faceți orice a făcut scriptul „postinst” pentru a actualiza
     		# legătura simbolică a administratorului de ferestre.
     	fi
     fi

note: type: SH
en: HACKS
ro: TRUCURI

note: type: Plain text
en: Debconf is currently not fully integrated into dpkg (but I want to change this in the future), and so some messy hacks are currently called for.
ro: Debconf nu este în prezent complet integrat în dpkg (dar vreau să schimb acest lucru în viitor) și, prin urmare, sunt necesare unele trucuri murdare.

note: type: Plain text
en: The worst of these involves getting the config script to run. The way that works now is the config script will be run when the package is pre-configured. Then, when the postinst script runs, it starts up debconf again. Debconf notices it is being used by the postinst script, and so it goes off and runs the config script. This can only work if your postinst loads up one of the debconf libraries though, so postinsts always have to take care to do that. We hope to address this later by adding explicit support to dpkg for debconf. The B<debconf>(1)  program is a step in this direction.
ro: Cea mai gravă dintre acestea implică rularea scriptului „config”. Modul în care funcționează acum este că scriptul „config” va fi rulat atunci când pachetul este preconfigurat. Apoi, când se execută scriptul „postinst”, se pornește din nou debconf. Debconf observă că este utilizat de scriptul „postinst”, așa că pornește și rulează scriptul „config”. Totuși, acest lucru poate funcționa numai dacă scriptul dvs. „postinst” încarcă una dintre bibliotecile debconf, astfel încât scripturile „postinst” trebuie să aibă întotdeauna grijă să facă acest lucru. Sperăm să rezolvăm această problemă mai târziu prin adăugarea unui suport explicit pentru debconf în dpkg. Programul B<debconf>(1) este un pas în această direcție.

note: type: Plain text
en: A related hack is getting debconf running when a config script, postinst, or other program that uses it starts up. After all, they expect to be able to talk to debconf right away. The way this is accomplished for now is that when such a script loads a debconf library (like /usr/share/debconf/confmodule), and debconf is not already running, it is started up, and a new copy of the script is re-execed. The only noticeable result is that you need to put the line that loads a debconf library at the very top of the script, or weird things will happen. We hope to address this later by changing how debconf is invoked, and turning it into something more like a transient daemon.
ro: O problemă conexă este să faceți debconf să ruleze atunci când un script „config”, „postinst” sau alt program care îl utilizează pornește. La urma urmei, acestea se așteaptă să poată comunica imediat cu debconf. Modul în care se realizează acest lucru pentru moment este că, atunci când un astfel de script încarcă o bibliotecă debconf (cum ar fi „/usr/share/debconf/confmodule”), iar debconf nu rulează deja, acesta este pornit și o nouă copie a scriptului este re-executată. Singurul rezultat notabil este că trebuie să puneți linia care încarcă o bibliotecă debconf chiar în partea de sus a scriptului, altfel se vor întâmpla lucruri ciudate. Sperăm să rezolvăm această problemă mai târziu, schimbând modul în care debconf este invocat și transformându-l în ceva mai asemănător unui demon tranzitoriu.

note: type: Plain text
en: It's rather hackish how debconf figures out what templates files to load, and when it loads them. When the config, preinst, and postinst scripts invoke debconf, it will automatically figure out where the templates file is, and load it. Standalone programs that use debconf will cause debconf to look for templates files in /usr/share/debconf/templates/progname.templates.  And if a postrm wants to use debconf at purge time, the templates won't be available unless debconf had a chance to load them in its postinst. This is messy, but rather unavoidable. In the future some of these programs may be able to use debconf-loadtemplate by hand though.
ro: Este destul de complicat modul în care debconf își dă seama ce fișiere de șabloane să încarce și când să le încarce. Atunci când scripturile „config”, „preinst” și „postinst” apelează debconf, acesta își va da seama automat unde se află fișierul de șabloane și îl va încărca. Programele autonome care utilizează debconf vor face ca debconf să caute fișiere de tip șablon în „/usr/share/debconf/templates/progname.templates”. Iar dacă un script „postrm” dorește să utilizeze debconf la momentul purjării, șabloanele nu vor fi disponibile decât dacă debconf a avut ocazia să le încarce în scriptul său „postinst”. Acest lucru este murdar, dar mai degrabă inevitabil. În viitor, unele dintre aceste programe ar putea fi capabile să utilizeze manual debconf-loadtemplate.

note: type: Plain text
en: /usr/share/debconf/confmodule's historic behavior of playing with file descriptors and setting up a fd #3 that talks to debconf, can cause all sorts of trouble when a postinst runs a daemon, since the daemon ends up talking to debconf, and debconf can't figure out when the script terminates. The STOP command can work around this. In the future, we are considering making debconf communication happen over a socket or some other mechanism than stdio.
ro: Comportamentul istoric al „/usr/share/debconf/confmodule” de a se juca cu descriptorii de fișiere și de a configura un fd #3 care comunică cu debconf, poate cauza tot felul de probleme atunci când un script „postinst” rulează un demon, deoarece demonul ajunge să comunice cu debconf, iar debconf nu își poate da seama când se termină scriptul. Comanda STOP poate rezolva această problemă. În viitor, ne gândim să facem ca comunicarea debconf să se realizeze prin intermediul unui soclu sau al unui alt mecanism decât intrarea/ieșirea standard.

note: type: Plain text
en: Debconf sets DEBCONF_RECONFIGURE=1 before running postinst scripts, so a postinst script that needs to avoid some expensive operation when reconfigured can look at that variable. This is a hack because the right thing would be to pass $1 = "reconfigure", but doing so without breaking all the postinsts that use debconf is difficult. The migration plan away from this hack is to encourage people to write postinsts that accept "reconfigure", and once they all do, begin passing that parameter.
ro: Debconf stabilește DEBCONF_RECONFIGURE=1 înainte de a rula scripturile „postinst”, astfel încât un script „postinst” care trebuie să evite o operație costisitoare atunci când este reconfigurat se poate uita la această variabilă. Acesta este un „truc”, deoarece lucrul corect ar fi să treceți $1 = „reconfigure”, dar este dificil să faceți acest lucru fără a rupe toate scripturile „postinst” care utilizează debconf. Planul de migrare departe de acest „truc” este de a încuraja oamenii să scrie scripturi „postinst” care acceptă „reconfigure” și, odată ce toți o fac, să înceapă să treacă acest parametru.

note: type: Plain text
en: B<debconf>(7)  is the debconf user's guide.
ro: B<debconf>(7) este ghidul utilizatorului debconf.

note: type: Plain text
en: The debconf specification in debian policy is the canonical definition of the debconf protocol. /usr/share/doc/debian-policy/debconf_specification.txt.gz
ro: Specificația debconf din politica debian este definiția canonică a protocolului debconf, și anume „/usr/share/doc/debian-policy/debconf_specification.txt.gz”.

note: type: Plain text
en: B<debconf.conf>(5)  has much useful information, including some info about the backend database.
ro: B<debconf.conf>(5) conține multe informații utile, inclusiv unele informații despre baza de date principală.
