Le serveur de fichiers d'AVG offre la protection contre les virus pour des serveurs de fichiers de Linux et de FreeBSD. Protection de garantie contre des virus, des vis sans fin et des Trojan pour des serveurs de fichiers de Linux et de FreeBSD, indépendamment des charges de travail.

Installation et lancement

AVG 7.5 pour des modules d'installation de Linux/FreeBSD sont fournis comme dossiers de T/MN ou de DEB, ou comme ensemble de mesures de tar.gz.

Pour l'installation à partir du dossier de T/MN (Linux seulement), employer la commande suivante dans votre interpréteur de commandes interactif (accessible par exemple using l'application de xterm dans votre système d'hublot de X).

# T/MN - I avg75lms- {desserrage} - {version de vdb} .i386.rpm

Pour l'installation à partir du dossier de .deb (Linux seulement), employer la commande suivante dans votre interpréteur de commandes interactif (accessible par exemple using l'application de xterm dans votre système d'hublot de X).

# dpkg - I avg75lms- {desserrage} - {version de vdb} .i386.deb

Pour l'installation de l'ensemble de mesures de .tar.gz, employer les commandes suivantes (dans le répertoire où l'ensemble de mesures est localisé) d'éclater son contenu, changer le répertoire et puis exécuter finalement la séquence type de montage (comme fond). Pour Linux procéder à ces opérations :

# xzvf avg75lms- {desserrage} de goudron - {version de vdb} .i386.tar.gz
# avg7-linux cd
# ./install.sh

Vous serez alors offert la chance d'enregistrer votre logiciel. Vous pouvez le faire maintenant ou plus tard (voir l'enregistrement de produit du chapitre 3.3). Pour le FreeBSD procéder à ces opérations :

# xzvf avg75fms- {desserrage} de goudron - {version de vdb} .i386.tar.gz
# avg7-freebsd cd
# ./install.sh

Vous serez alors offert la chance d'enregistrer votre logiciel. Vous pouvez le faire maintenant ou plus tard (voir l'enregistrement de produit du chapitre 3.3). Note : Les dossiers de régime de l'AVG 7.5 pour les versions 11 de Linux/FreeBSD et plus vieux sont montés sur le répertoire de /usr/local/lib/avg7. Même si vous exécutez la pleine mise à jour d'une version plus ancienne de votre AVG, la structure de répertoire demeure la même (assurant ascendant la compatibilité). Cependant, tous les éléments essentiels d'AVG
7.5 pour Linux/FreeBSD sont toujours mis à jour correctement pour t'offrir la sécurité maximale et la fiabilité.

Les versions 12 et plus neuf sont globalement montées sur le répertoire de /opt/grisoft. Des tiges symboliques sont produites dans divers répertoires système, menant au sous-arbre de répertoire de /opt/grisoft. Si vous voulez améliorer la vieille structure de répertoire, vous devez complet réinstaller votre AVG 7.5 pour Linux/FreeBSD. Noter cela dans cette documentation est toujours décrit l'emplacement plus neuf preferred d'AVG 7.5 pour
Installation de Linux/FreeBSD !

Le dossier est l'application de source ouverte de la commande de dossier utilisée sur presque chaque système d'exploitation libre (OpenBSD, Linux, FreeBSD, NetBSD) et également sur les systèmes qui emploient le logiciel gratuit (OS/2 y compris, DOS, MS Windows, etc.).

La commande de dossier, si au courant de youre pas de elle, est un outil de ligne de commande qui vous indique dans les mots ce qu'un peu la caractéristique un dossier contient. À la différence du MS-WINDOWS, l'UNIX et d'autres systèmes ne se fondent pas sur des extentions de nom de fichier pour vous indiquer que le type d'un dossier, mais regardent le contenu réel de dossiers. C'est, naturellement, plus fiable, mais exige un morceau d'E/S.

La commande originelle de dossier expédiée avec les Laboratoires Bell UNIX mais était indisponible sous la forme source aux masses avant reimplementation d'Ians.

Cette commande de dossier (et dossier magique) ont été initialement sauvés par Ian Darwin (qui contribue toujours de temps en temps) et sont maintenant mis à jour par un groupe de développeurs aboutissent par Christos Zoulas.

Whos using lui ?

Chaque distribution connue de schéma (FreeBSD, NetBSD, OpenBSD, Darwin/Mac OS X, etc.)
Chaque distribution Linux connue
Le module mod_mime_magic de serveur de httpd d'Apache utilise les intestins de commandes de dossier pour effectuer le type de fichier estimant un httpd de dessous plus fiable d'Apache.

le navigateur de fichiers de jsp est un facile à utiliser et facile de monter la page de serveur de Java d'explorateur de fichiers. Ce régime de JSP permet l'accès et la manipulation basés sur le WEB lointains de dossier.

Voici quelques fonctionnalités clé de « navigateur de fichiers de jsp » :

· Produire, copier, déplacer, renommer et effacer les dossiers et les répertoires
· Voir les dossiers (illustrations, films, pdf, HTML,…)
· Éditer les fichiers texte
· Télécharger les dossiers au serveur (le mode par l'intermédiaire du moniteur de téléchargement)
· fichiers téléchargés du serveur
· Télécharger les ensembles de fichiers et les dépliants comme fichier zip unique qui est produit en marche
· Accomplir les commandes spécifiques sur le serveur (par exemple LS, le goudron, le chmod,…)
· Voir les entrées et éclater les dossiers de fermeture éclair, de choc, de guerre et de gz sur le serveur
· Juste un dossier, très facile à monter (en fait, le copier juste au serveur)
· Disposition personnalisable par l'intermédiaire de dossier de CSS
· Limiter l'accès de dossier par l'intermédiaire du noir ou du whitelist

Il devrait fonctionner avec n'importe quel serveur JSP1.1 compatible (par exemple Tomcat>=3.0), je l'a vérifié sur Tomcat 4.0, la résine 2.1.7 et la jetée.

Ce qu'il y a de neuf dans ce desserrage :

· Une version en lecture seule a été ajoutée.
· Elle est maintenant également utilisable comme téléchargement-centre.
· Des perfectionnements d'un certain UI ont été effectués, comme des shortkeys et une meilleure disposition.
· Il devrait également charger un peu plus rapidement.

le projet de file*HANDLER est principalement un script Perl qui combine quelques ensembles de mesures libres de conversion de médias (cités plus tard) avec un serveur accédant de parties terminales de PostgreSQL pour répertorier et servir la binaire et les fichiers texte dirigent de la base de données. Un dossier simple de cgi avec AJAX encastré fait des appels à ce serveur qui recherche également continuellement l'autre serveur sur Internet vivant de f*H.

Depuis le serveur cache des médias dans la base de données SQL sur demande, car le réseau se développe, le réseau s'améliore.

Son partage à carroyage de répertoire/furetage/recherchant avec le streaming audio/vidéo aussi bien que le texte plat/Doc./pdf/étalage d'image chacun. Son sauvé avec quelques crochets pour les étiquettes qui seraient comprises en votre frontpage réel de sorte que l'UI soit jeter-capable -- n'importe qui peut rapidement récrire [le GT] un UI neuf entier sans devoir s'inquiéter de la syntaxe de la version la plus neuve de dojo.licio.r ou quoi que.

Si vous vouliez ignorer les crochets de JS/HTML/CSS puis vous pouvez facilement employer le système pour effectuer les demandes directes que juste les listes de renvoi ont formatées comme tableau-fuselages de HTML. En d'autres termes, le marge bénéficiaire bénéficiaire EST le marge bénéficiaire bénéficiaire.

En soi, Ive a fouetté vers le haut d'un gadget du Dojo 0.2 qui combine la partie postérieure de portion avec un UI ainsi n'importe qui peut inclure la fonctionnalité de f*H n'importe où, ou personnaliser facilement une page de défaut fournie.

Un serveur de file*HANDLER est réellement quelques composantes Ive attaché pour vous (le sommet avalent) :

· Un page Web local fournissant l'UI (servi par un serveur HTTP de votre choix) qui est produit par une séquence type de cgi avec AJAX encastré.
· Une partie secondaire du même script CGI, agissant en tant que logiciel personnalisé, qui communique, par l'intermédiaire d'AJAX, avec le frontpage local pour réconcilier des demandes asynchrones de Javascript avec la partie postérieure de sous-réseau de file*HANDLER.
· Un serveur du réseau illimité sauvé dans Perl qui sert au front et l'extrémité communique transversal avec chacun le serveur de Perl de partie postérieure de file*HANDLER d'elses supplémentaire, il manage l'indexation des répertoires contents que vous choisissez de servir.
· Une base de données de PostgreSQL qui est consultée seulement par l'intermédiaire des sous-programmes internes de Perl a appelé de votre frontpage.

Tellement par exemple, un utilisateur distant vient à votre site. D'abord, non seulement peuvent ils parcourir et rechercher vos dossiers, mais ils peuvent également parcourir et rechercher les dossiers de n'importe qui accueillant autrement un serveur de file*HANDLER que votre serveur local connaît. (le file*HANDLER recense d'autres serveurs sur le réseau automatiquement). L'usager peut maintenant s'afficher/vue/écoute/montre par le flot n'importe quel contenu qu'ils trouvent du serveur de whomevers. Therese aucun téléchargement, ainsi partage tellement réel de therese, juste couler direct au programme de lecture d'usagers.

Dossier : : PM2File - périmé. Dossier d'usager : : Là où

SYNTHÈSE

file_in_include () # périmé. Remplacer par le dossier : : Là où : : là où ()
pm2file () # périmé. Remplacer par le dossier : : Là où : : where_pm ()
pm2require () # périmé. Remplacer par le dossier : : Là où : : pm2require ()

$File : : PM2File : : warn_obsolete = 1 ; # allume l'alerte périmée

CONDITIONS

Le dossier : : Les subrouitnes de PM2File non utilisé.
Le dossier : : Des sous-routines de PM2File seront remplacées par le dossier approprié : : Là où sous-routine chaque fois qu'un dossier : : La sous-routine de PM2File a besoin de mise à jour comme suit :

Dossier : : PM2File : : dossier de find_in_include () : : Là où : : là où ()
Dossier : : PM2File : : dossier de pm2file : : Là où : : where_pm ()
Dossier : : PM2File : : dossier de pm2require : : Là où : : pm2require

NOTE : Le dossier de sous-routine : : Là où : : là où est presque un direct relâcher dedans pour le dossier : : PM2File : : find_in_include (). La différence est dans un dossier de contexte de choix : : Là où : : là où () renvoie un troisième organe où dossier : : PM2File : : renvois deux de find_in_include () seulement. Les deux premiers organes, bien que, sont identiques.

Dossier : : MMagic est un module de Perl pour estimer le type de fichier.

SYNTHÈSE

dossier d'utilisation : : MMagic ;
employer FileHandle ;

$mm = dossier neuf : : MMagic ; # dossier magique interne d'utilisation
# $mm = dossier : : MMagic->new (/etc/magic) ; # dossier magique externe d'utilisation
# $mm = dossier : : MMagic->new (/usr/share/etc/magic) ; # si vous employez Debian
$res = $mm->checktype_filename (« /somewhere/unknown/file ») ;

$fh = FileHandle neuf « < /somewhere/unknown/file2 » ;
$res = $mm->checktype_filehandle ($fh) ;

$fh->read ($data, 0x8564) ;
$res = $mm->checktype_contents ($data) ;

Dossier : : AnySpec est un module de Perl pour exécuter des fonctionnements sur des noms (lointains) étrangers de dossier.

SYNTHÈSE

# surface adjacente de sous-routine
#
dossier d'utilisation : : Qw d'AnySpec (14h de fspec de fspec_glob de fspec2fspec pm2fspec os2fspec fspec2os) ;

$file = fspec2fspec ($from_fspec, $to_fspec $fspec_file, [$nofile])
$os_file = fspec2os ($fspec, $file, [$no_file])
$fspec_file = os2fspec ($fspec, $file, [$no_file])

14h de $pm = de fspec ($fspec, $require_file)
($abs_file, $inc_path, $require_file) = pm2fspec ($fspec, $pm)

@globed_files = fspec_glob ($fspec, @files)


# surface adjacente de cours
#
dossier d'utilisation : : AnySpec
employer le qw de vars (le @ISA)
@ISA = qw (dossier : : AnySpec)

$file = __PACKAGE__->fspec2fspec ($from_fspec, $to_fspec $fspec_file, [$nofile])
$os_file = __PACKAGE__->fspec2os ($fspec, $file, [$no_file])
$fspec_file = __PACKAGE__->os2fspec ($fspec, $file, [$no_file])

14h de $pm = de __PACKAGE__->fspec ($fspec, $require_file)
($abs_file, $inc_path, $require_file) = __PACKAGE__->pm2fspec ($fspec, $pm)

@globed_files = __PACKAGE__->fspec_glob ($fspec, @files)

Les méthodes en cet ensemble de mesures, exécutent des fonctionnements sur des caractéristiques de dossier pour des systèmes d'exploitation autre puis le site actuel du système d'exploitation. La variable d'entrée $fspec indique aux méthodes en cet ensemble de mesures le cahier des charges de dossier pour des noms de dossier utilisés comme entrée aux méthodes. Ainsi, en employant des méthodes en cet ensemble de mesures, la méthode peut charger jusqu'à deux liment : : Les méthodes de sous-modules de Spéc. et ni l'un ni l'autre de elles n'est un sous-module pour le site actuel du système d'exploitation.

Dossier : : L'utilisation est un dossier facile, polyvalent, portatif traitant le module.

Dossier : : L'utilisation fournit un coffre à outils global d'utilitaires pour automatiser toutes sortes de fonctionnalités usuelles sur le dossier/répertoires. Son but est de faire ainsi de la façon la plus portative possible de sorte que les usagers de ce module ne doivent pas s'inquiéter de si leurs régimes fonctionnent sur d'autres OSes et machines.

SYNTHÈSE

dossier d'utilisation : : Utilisation ;
mon ($f) = dossier : : Util->new () ;

mon ($content) = $f->load_file (foo.txt) ;

=~ s/this/that/g de $content ;

$f->write_file (
=> bar.txt de dossier,
=> content $content,
=> 0644 de bitmask
) ;

$f->write_file (
=> file.bin, => content $binary_content de dossier, --binmode
) ;

mon (@lines) = $f->load_file (randomquote.txt, --comme-lignes) ;
mon ($line) = international (RAND (@lines scalaires));

impression $lines [$line] ;

mon (@files) = $f->list_dir (/var/tmp, qw/ --dossiers-seulement --recurse/) ;
mon (@textfiles) = $f->list_dir (/var/tmp, --pattern=.txt$) ;

si ($f->can_write (wibble.log)) {

mon ($HANDLE) = $f->open_handle (
=> wibble.log de dossier,
le => de mode ajoutent
) ;

monde de l'impression $HANDLE « bonjour ! Son », localtime scalaire ;

$HANDLE proche
}

mon ($log_line_count) = $f->line_count (/var/log/httpd/access_log) ;

estamper « mon dossier a un bitmask de ». $f->bitmask (my.file) ;

estamper « mon dossier est ». joindre (, $f->file_type (my.file)). « dossier. »

avertir que ce dossier est binaire ! si $f->isbin (my.file) ;

estamper « mon dossier était Last modified sur ».
localtime scalaire ($f->last_modified (my.file));

#… et _lots_ davantage

Dossier : : BasicFlock est un module de Perl pour le verrouillement de fichier avec la bande.

SYNTHÈSE

dossier d'utilisation : : BasicFlock ;

blocage ($filename) ;

blocage ($filename, partagé) ;

blocage ($filename, undef, non groupants) ;

blocage ($filename, partagé, non groupant) ;

débloquer ($filename) ;

Verrouiller les dossiers using l'appel de bande (). Le dossier à verrouiller doit déjà exister. C'est très une surface adjacente de chose.

Dossier : : NFSLock est un module de Perl pour faire le verrouillage de NFS (ou pas).

SYNTHÈSE

dossier d'utilisation : : Qw de NFSLock (uncache) ;
employer le qw de Fcntl (LOCK_EX LOCK_NB) ;

mon $file = « somefile » ;

le ### a installé un blocage - bouts jusqu'à ce que l'objectif desserre l'étendue
si (mon $lock = dossier neuf : : NFSLock {
=> $file de dossier,
=> LOCK_EX de lock_type|LOCK_NB,
=> 10 de blocking_timeout, # sec 10
=> de stale_lock_timeout 30 * 60, # mn 30
}) {

### OU
### mon $lock = dossier : : NFSLock->new ($file, LOCK_EX|LOCK_NB, 10.30*60) ;

le ### font la substance protégée en écriture sur $file
le ### en ce point $file est uncached du NFS (le plus récent)
s'ouvrir (DOSSIER, « +<$file ») || mourir $ ! ;

le ### ou l'ouvrent n'importe quelle voie que vous aimez
### mon $fh = E/S : : File->open ($file, w) || mourir $ !

mise à jour de ### (uncache en travers de NFS) d'autres dossiers
uncache (« someotherfile1 ») ;
uncache (« someotherfile2 ») ;
# s'ouvrir (FILE2, « someotherfile1 ») ;

le ### le débloquent
$lock->unlock () ;
### OU
undef $lock de ### ;
Le ### OU a laissé $lock sortent de l'étendue
} autrement {
me mourir « ne pourrait pas verrouiller le dossier [$File : : NFSLock : : errstr] » ;
}

Régime basé du concept de joindre dur des dossiers étant atomiques en travers du NFS. Ce concept a été mentionné dans le courrier : : Cadre : : Casier (qui a été initialement présenté dans le courrier : : Dépliant : : Maildir). Un certain flux courant est pris de là -- en particulier l'idée de produire un fichier local fait au hasard, travaux forcés liant un dossier courant au fichier local, et puis vérifiant le mode de nlink. Quelques idéologies n'étaient pas complètes (mécanisme d'uncache, verrouillage partagé) et du codage était même incorrect (index incorrect de stat). Dossier : : NFSLock a été sauvé pour être la lumière, générique, et rapide.

Ce qu'il y a de neuf dans ce desserrage :

· Perl

Dossier : : FindByRegex est un emballage de Perl pour le dossier : : Trouver qui trouve des arborescences des répertoires et exécute une certaine action pour chaque dossier dont les matchs nommés une expression régulière.

SYNOPSYS

dossier d'utilisation : : FindByRegex ;

$find = dossier : : FindByRegex->new ({

- => de srcdir [C : tmpteradata-SQL],
- => C de tardir : tmpteradata-sqldoc,
- => de trouvaille {=> 1 de no_chdir},

- => de rappels de service
{
qr/.p (l|m|OD|t)$/oi, &treat_pod de =>,
qr/sql.+ ? .sql$/oi, treat_pod de =>,
qr/.html ? $/oi, &treat_html de =>,
&treat_txt de => de qr/.txt$/oi,
qr/. (jpg|GIF|png|véhicule blindé amphibie soviétique d'infanterie|sous-marin de => de tiff) $ {&treat_graphic (@_)}
},

- ignorer le =>
[
qr/par exemple +.sql$/oi, # *.sql dans le répertoire par exemple
qr/java/oi, # tous les dossiers dans le répertoire de Java.
],

- excepte le =>
[
qr/java.* ? .html ? $/oi # n'ignorent pas *.html dans Java
]
}) ;

sous-dossier : : FindByRegex : : treat_pod
{
mon $this = commande des vitesses ;
…
}

sous-dossier : : FindByRegex : : treat_html
{
mon $this = commande des vitesses ;
…
}

sous-dossier : : FindByRegex : : treat_txt
{
mon $this = commande des vitesses ;
…
}

sous-dossier : : FindByRegex : : treat_graphic
{
mon $this = commande des vitesses ;
…
}

$find->travel_tree ;

Dossier : : Repl est un module de Perl qui fournit des utilitaires de réplique de dossier.

SYNTHÈSE

dossier d'utilisation : : Repl ;

%con = {
=> C de dira : /perl,
=> M de dirb : /perl,
=> bavard 1,
=> 10 d'âge,
} ;

$ref=File : : Repl->New (%con) ;
$r1 = $ref->Update (.p (l|m), a<>b, 1) ;
$r2 = $ref->Update (.t.*, a<>b, 1, .tmp$) ;

Le dossier : Repl fournit des utilitaires simples de réplique et de management de dossier. Ses fonctionnements principaux sont

Réplique de dossier

Permettre à deux structures de répertoire d'être mises à jour, assurant les dossiers qui répondent à des critères de logique de sélection sont reflétées et autrement synchronisées.

Renommer en bloc

Laisser lime dans une structure de répertoire à renommer selon la logique de sélection.

Comprimer

Laisser lime dans une structure de répertoire à comprimer selon une logique donnée.

Procédé

Exécuter un procédé courant de Perl contre des dossiers dans une structure de répertoire selon la logique de sélection.

Blanc

Laisser lime dans une structure de répertoire à effacer selon la logique de sélection.

Dossier : : LockDir est un utilitaire fondamental de blocage de nom de fichier-niveau de Perl.

SYNTHÈSE

dossier d'utilisation : : LockDir ;

SURFACE ADJACENTE

neuf

Initialise le cours. Renvoie l'objectif de singleton.

nflock ($file, $nap_till, $locker, $lockhost)

Verrouille le nom de fichier fourni. Seulement $file est exigé.

$file est le dossier à verrouiller ; $nap_till est le nombre de heures total à l'attente avant d'abandonner ; $locker est un nom recensant le casier ; $lockhost est le serveur demandant le blocage.

nunflock ($file)

Débloque le dossier fourni.

nlock_state ($file)

Examine la condition du blocage pour assurer le dossier fourni. Renvoie une liste : le premier organe est vrai si le dossier est débloqué, et trompeur sinon ; le deuxième organe est undef si le dossier est débloqué, et l'identité (nom et serveur) est lui est verrouillée.

DIAGNOSE

%s s'est déjà verrouillé

Vu quand vous avez déjà verrouillé le nom d'accès prié. À titre d'information seulement.

Aucun nom d'accès à verrouiller

Vous n'avez pas fourni un nom d'accès à verrouiller au nflock. Fatal.

les clichés sauvent au répertoire de %s

Le répertoire où le dossier demeure des clichés soit sauvé, ainsi les clichés lockfile soit produit.

les clichés obtiennent %s : %s

Les clichés nommés de blocage soient obtenus : la raison est acceptée. Le défaut se produit après que dix essais pour obtenir le blocage.

%s %s [%s] : verrouiller sur %s maintenu par %s

Le blocage sur le fichier spécifié est aide par le casier remarquable. Message informatif, estampé seulement quand l'élimination des imperfections est allumée.

la fin a échoué pour %s : %s

Le dossier contenant l'information de blocage n'a pas pu être fermé pour la raison montrée.

relâchement du blocage sur %s

Mettre au point le message ; note que le blocage sur le fichier spécifié a été avec succès relâché.

Dossier : : le lockf est une surface adjacente de module de Perl à l'appel système de lockf.

SYNTHÈSE

dossier d'utilisation : : lockf ;

Le Dossier-Lockf est une surface adjacente à l'appel système de lockf. Le Perl supporte l'appel système de bande à la façon des indigènes, mais cela n'acquiert pas des blocages de réseau. Le Perl supporte également l'appel système de fcntl, mais cela est quelque peu laid pour employer. Il y a d'autres modules de verrouillage procurables pour le Perl, mais aucun de eux n'a fourni ce que j'ai voulu -- une surface adjacente simple et propre à l'appel système de lockf, sans tous cloches ou sifflements obtenant de la manière.

Le Dossier-Lockf contient quatre fonctionnements qui tracent directement aux quatre modes du lockf, et une classe d'emballage d'OO cette des encapulates la fonctionnalité de verrouillage fondamentale avec une méthode de service supplémentaire qui essaye itérativement d'acquérir un blocage.

Fonctionnements de blocage

Les fonctionnements suivants renvoient 0 (zéro) sur la réussite, et le numéro d'erreur système de l'errno sur le défaut. Ils chaque prennent un traitement de fichier ouvert comme premier argument, et éventuellement un paramètre de taille. Veuillez voir la votre page de manuel de lockf de système pour plus de groupes au sujet de la fonctionnalité de lockf sur votre système.

$status = dossier : : lockf : : verrouiller (FH, taille = 0)
Ce fonctionnement trace au mode de F_LOCK du lockf.

$status = dossier : : lockf : : tlock (FH, taille = 0)
Ce fonctionnement trace au mode de F_TLOCK du lockf.

$status = dossier : : lockf : : ulock (FH, taille = 0)
Ce fonctionnement trace au mode de F_ULOCK du lockf.

$status = dossier : : lockf : : vérifier (FH, taille = 0)
Ce fonctionnement trace au mode de F_TEST du lockf.

Emballage d'OO

Le Dossier-Lockf fournit également une classe simple d'emballage d'OO autour de la fonctionnalité de verrouillage, qui te permet de produire un objectif de blocage pour un traitement de dossier et puis d'exécuter des fonctionnements de blocage avec elle. Toutes les méthodes renvoient 0 (zéro) sur la réussite, et le numéro d'erreur système de l'errno sur le défaut.

$lock = dossier neuf : : lockf (*FH)

Ce fonctionnement renvoie un objectif neuf de blocage lié au traitement de dossier donné. Noter que vous doivent réussir une référence au traitement de dossier au constructeur, pas le traitement de dossier lui-même.

$status = $lock->lock (taille = 0)
Cette méthode appelle le dossier : : lockf : : verrouiller sur le traitement de dossier attaché.

$status = $lock->tlock (taille = 0)
Cette méthode appelle le dossier : : lockf : : tlock sur le traitement de dossier attaché.

$status = $lock->ulock (taille = 0)
Cette méthode appelle le dossier : : lockf : : ulock sur le traitement de dossier attaché.

$status = $lock->test (taille = 0)
Cette méthode appelle le dossier : : lockf : : vérifier sur le traitement de dossier attaché.

$status = $lock->slock (compte = 5, délai = 2, taille = 0)
Cette méthode essayera de verrouiller les temps attachés de < compte > de traitement de dossier, secondes de < délai > de sommeil après chaque essai. Elle renverra 0 si le blocage réussissait, ou le numéro d'erreur système de l'errno si toutes les tentatives échouent.

Daizu : : Le dossier est une classe de Perl représentant des dossiers dans des copies de fonctionnement.

Chaque objectif de ce cours représente un dossier particulier dans une copie de fonctionnement de CM de Daizu (un procès-verbal dans le tableau wc_file).

MÉTHODES

Noter que tous les fonctionnements qui renvoient la valeur d'une propriété de subversion décolleront le whitespace aboutissant et de remorquage, et traiter une valeur qui est vide ou entièrement whitespace comme si elle n'a pas été réglée du tout.

Daizu : : File->new ($cms, $file_id)

Renvoyer un Daizu neuf : : Limer l'objectif pour le dossier avec le numéro ID spécifique.

$file->data

Renvoyer une référence à une chaîne de caractères contenant les caractéristiques de dossier (contenu).

$file->wc

Renvoyer un Daizu : : Objectif de carte de travail représentant la copie de fonctionnement dans laquelle ce dossier vit.

$file->guid_uri

Renvoyer le GUID URI pour ce dossier.

$file->directory_path

Renvoie le circuit d'un répertoire, de l'un ou l'autre les mêmes que le dossier si son un répertoire lui-même, ou du circuit de son répertoire parent, ou si son au premier niveau.

$file->permalink

Renvoie le premier URL produit par le dossier, qui sera l'URL que vous voulez lier à le plus souvent. Pour des articles ce sera toujours la version HTML normale de l'article, même s'il y a également d'autres URL procurables pour lui, et ce sera toujours la première page des articles de plusieurs pages. Pour des dossiers de non-article il n'y a aucun cautionnement au sujet de ce que ceci renverra, mais plus produira seulement d'un URL unique de toute façon, et pour ceux qui ne font pas les générateurs sont susceptibles de renvoyer l'URL le plus liable d'abord.

L'URL retourné est un Absolute URL fourni comme objectif d'URI.

Ne renvoie rien si le dossier ne produit d'aucun URL.

Il y a quelques cas où être ceci ne pourrait pas ce que vous voulez. Par exemple, le répertoire racine d'un site Web using Daizu : : La GEN ne produira pas d'un URL du tout, ou produira d'un pour un fichier XML de sitemap de Google, ni l'un ni l'autre dont est susceptible d'être utile pour joindre. Pour obtenir l'URL du site Web que vous devriez probablement trouver un dossier appelé quelque chose comme _index.html. D'une part, le Daizu : : GEN : : Le générateur de blog te donnera un URL sensible pour le homepage de blog si vous appelez ceci sur son répertoire racine.

$file->urls_in_db ($method, $argument)

Renvoyer une liste des URL (chaînes de caractères ordinaires, chaque un URI absolu) du dossier qui ont les valeurs spécifiques de méthode et d'argument, tirant du tableau d'URL dans la base de données.

$file->article_urls

Renvoyer les informations sur les URL que le dossier devrait avoir, si c'est un article. Défaille s'il n'est pas.

Dossier : : CounterFile est un contre- cours persistant.

SYNTHÈSE

dossier d'utilisation : : CounterFile ;
$c = dossier : : CounterFile->new (« CONTRE- », « aa00 ») ;

$id = $c->inc ;
s'ouvrir (F, « >F$id ») ;

Ce module met en application un contre- cours persistant. Chaque riposte est représentée par un fichier séparé dans le système de fichiers. Le verrouillement de fichier est appliqué, ainsi les procédés multiples peuvent essayer d'accéder une riposte simultanément sans risque de contre- destruction.

Vous donnez le nom de fichier comme le premier paramètre au constructeur d'objectif (neuf). Le dossier est produit s'il n'existe pas.

Si le nom de fichier ne commence pas par « / » ou « .  », alors il est interprété comme dossier à $File relatif : : CounterFile : : DEFAULT_DIR. La valeur par défaut pour cette variable est initialisée de la variable d'environnement TMPDIR, ou de /usr/tmp si aucune variable d'environnement n'est définie. Vous pouvez vouloir affecter une valeur différente à cette variable avant de produire des ripostes.

Si vous réussissez un deuxième paramètre au constructeur, il règle la valeur initiale pour une riposte neuve. Ce paramètre entre en vigueur seulement quand le dossier est produit (c.-à-d. il n'existe pas avant l'appel).

Quand vous appelez la méthode d'inc. (), vous incrémentez la contre-valeur par une. Quand vous appelez décembre (), la contre-valeur est décrémentée. Dans les deux cas la valeur neuve est retournée. La méthode de décembre () fonctionne seulement pour les ripostes numériques (chiffres seulement).
Vous pouvez jeter un coup d'oeil sur la valeur de la riposte (sans l'incrémenter) en employant la méthode de valeur ().

La riposte peut être verrouillée et débloquée avec le blocage () et débloquer () des méthodes. L'incrémentation et la recherche de valeur sont plus rapides quand la riposte est verrouillée, parce que nous ne devons pas mettre le contre- dossier toute l'heure. Vous pouvez questionner si la riposte est verrouillée avec () la méthode verrouillée.

Il y a également une surface adjacente de surcharge d'opérateurs au dossier : : Objectif de CounterFile. Ceci signifie que vous pouvez employer le conducteur de ++ pour incrémenter et -- le conducteur pour décrémenter la riposte, et vous peut interpoler des ripostes directement dans des chaînes de caractères.

Dossier : : Xcopy peut copier des dossiers après les avoir comparés.

SYNTHÈSE

dossier d'utilisation : : Xcopy ;
mon $fx = dossier neuf : : Xcopy ;
$fx->from_dir (« /from/dir ») ;
$fx->to_dir (« /to/dir ») ;
$fx->fn_pat ((.pl|.txt) $) ; # dossiers avec le pl et les extensions de txt
$fx->param (s, 1) ; # recherche périodiquement pour substrater des dirs
$fx->param (bavard, 1) ; # recherche périodiquement pour substrater des dirs
$fx->param (log_file, /my/log/file.log) ;
mon ($sr, $rr) = $fx->get_stat ;
$fx->xcopy ; # ou
$fx->execute (copie) ;

# les mêmes avec le nom court
$fx->xcp (« from_dir », « to_dir », « file_name_pattern ») ;

Le dossier : : Le module de Xcopy fournit deux fonctionnements fondamentaux, xcopy et xmove, qui sont utiles pour satisfaire et/ou déplacer un dossier ou des dossiers dans un répertoire d'une place à l'autre. Il imite certains de comportements de xcopy dans le DOS mais avec plus de fonctionnements et d'options.

Les différences entre xcopy et la copie sont :

· dossiers xcopy de recherches basés sur la configuration de nom de fichier si la configuration est spécifiée.
· xcopy compare l'horodateur et la taille d'un dossier avant elle copie.
· xcopy prend différentes mesures si vous la dites à.

Le constructeur neuf (%arg)

Sans n'importe quelle entrée, c.-à-d., neuve (), le constructeur produit d'un objectif vide avec des valeurs par défaut pour ses paramètres.

Le cas échéant l'argument est fourni, le constructeur les attend dans les paires de nom et de valeur, c.-à-d., dans un choix d'informations parasites.

Dossier : : LckPwdF est un module de Perl pour verrouiller et débloquer les dossiers de passwd et d'ombre avec le lckpwdf et l'ulckpwdf.

SYNTHÈSE

dossier d'utilisation : : LckPwdF ;

(lock_passwd (15)) || (mourir « le mot de passe biseauté file:n$ de blocage ! arrêté ») ;

#… farcir du dossier de passwd…

(unlock_passwd ()) || (mourir les « clichés débloque le mot de passe file:n$ ! arrêté ») ;

C'est un module de Perl pour employer le lckpwdf (3) et ulckpwdf (3) pour verrouiller les dossiers de /etc/passwd et (si présent) de /etc/shadow.

Les fonctionnements ont exporté automatiquement

lock_passwd ($timeout)

$timeout fonctionne comme suit :

1. Le temps initial est vérifié.

2. Si $timeout est 0, il essaye le lckpwdf () jusqu'à ce qu'il réussisse, attendant un temps fait au hasard dans l'intervalle.

3. Si $timeout est au-dessus de 0, il essaye le lckpwdf () une fois. Si cela (ou tout lckpwdf suivant ()) réussit, il renvoie 1. Il essayera le lckpwdf () jusqu'à ce qu'ou il réussisse ou le temps est plus grand que le temps initial plus $timeout. Dans le dernier cas, il renvoie 0. Il attend un temps fait au hasard entre des essais de lckpwdf ().

La minuterie faite au hasard est contrôlée par $File : : LckPwdF : : Rand_Wait, qui est exporté sur demande. Il est employé par l'intermédiaire de

sommeil international (RAND ($Rand_Wait) + 1) ;

à l'intérieur de l'jusqu'à la boucle. Ce sommeil est seulement fait si $File : : LckPwdF : : Rand_Wait est au-dessus de 0.

défauts de $timeout à $File : : LckPwdF : : Default_Timeout, qui est également exporté sur demande ; le réglage initial de $File : : LckPwdF : : Default_Timeout (le défaut de défaut) est de 15 secondes. Le paramètre par défaut pour $File : : LckPwdF : : Rand_Wait est de 10 secondes.

unlock_passwd ()

Ce fonctionnement emploie l'ulckpwdf (). Si le lock_passwd () a été précédemment employé pour verrouiller le dossier de passwd, et unlock_passwd () n'a pas été employé pour le verrouiller, alors il sera employé pour débloquer le dossier de passwd dans une EXTRÉMITÉ : rapport. (Évidemment, avec beaucoup de réalisations de lckpwdf que () ce n'est pas nécessaire, depuis quand un procédé quitte il détruit le blocage de dossier de passwd ; c'est présent comme mesure de sécurité pour ces systèmes pour lesquels cela ne vaut pas.)

Fonctionnements exportés par demande

ulckpwdf de lckpwdf () ()

Ce sont les versions xs-chargées du lckpwdf (3) et ulckpwdf (3), respectivement.

Dossier : : DirCompare est un module de Perl pour comparer deux répertoires using des rappels de service.

SYNTHÈSE

dossier d'utilisation : : DirCompare ;

# diff simple - r --bref remontage
dossier d'utilisation : : Nom de base de fichier ;
Dossier : : DirCompare->compare ($dir1, $dir2, sous-marin {
mon ($a, $b) = @_ ;
si (! $b) {
printf « seulement dans %s : %sn », dirname ($a), nom de base de fichier ($a) ;
} elsif (! $a) {
printf « seulement dans %s : %sn », dirname ($b), nom de base de fichier ($b) ;
} autrement {
l'impression « lime $a et $b differn » ;
}
}) ;

# le Version-contrôle comme effacé/a ajouté/liste modifié
mon (@listing, @modified) ; # fermeture d'utilisation pour rassembler des résultats
Dossier : : DirCompare->compare (old_tree, new_tree), sous-marin {
mon ($a, $b) = @_ ;
si (! $b) {
pousser @listing, « D $a » ;
} elsif (! $a) {
pousser @listing, « un $b » ;
} autrement {
si (- && de f $a - f $b) {
pousser @listing, « M $b » ;
pousser @modified, $b ;
} autrement {
# un dossier, un répertoire - traiter comme l'effacement + ajoutent
pousser @listing, « D $a » ;
pousser @listing, « un $b » ;
}
}
}) ;

Dossier : : DirCompare est un module de Perl pour comparer deux répertoires using un rappel de service, invoqué pour tous les dossiers qui sont différents entre les deux répertoires, et pour tous les dossiers qui existent seulement dans un ou tout autre répertoire (seuls dossiers).
Dossier : : DirCompare fait comparer à un public unique () la méthode, à la signature suivante :

Dossier : : DirCompare->compare ($dir1, $dir2, $sub, $opts) ;

Les trois premiers arguments sont exigés - $dir1 et $dir2 sont des circuits aux deux répertoires à comparer, et $sub est la référence de sous-routine demandée tous les seuls ou différents dossiers. $opts est un hashref optionnel des options - voir des OPTIONS ci-dessous.

La sous-routine fournie est demandée pour tous les seuls dossiers, et chaque paire de différents dossiers produits, avec la signature suivante :

$sub-> ($file1, $file2)

là où $file1 et $file2 sont les circuits aux deux dossiers. de seuls dossiers c.-à-d. où un dossier existe dans seulement un répertoire, la sous-routine est demandée avec l'autre undef d'argument c.-à-d. pour :

$sub-> ($file1, undef)
$sub-> (undef, $file2)

le premier indique $file1 existe seulement dans le premier répertoire donné ($dir1), et la seconde indique que $file2 existe seulement dans le deuxième répertoire donné ($dir2).