view release on metacpan or search on metacpan
lib/Apache/FilteringProxy.pm view on Meta::CPAN
$r->warn("FilteringProxyResourceDomain set to '$resource_domain'");
}
### XML CONFIGURATION
# get the modification time of the configuration file
# dev,ino,mode,nlink,uid,gid,rdev,size,atime,mtime,ctime,blksize,blocks
my @stat;
unless ((-r $config_file) and (@stat = stat($config_file))) {
$r->warn("could not stat '$config_file' ( FilteringProxyConfig )");
} else {
$r->warn("DEBUG: entering XML configuration");
view release on metacpan or search on metacpan
lib/Apache/HTTunnel/Keeper.pm view on Meta::CPAN
my $slog = $s->log() ;
my $tree = Apache2::Directive::conftree() ;
my $apache_user = $tree->lookup('User') ;
my $apache_uid = getpwnam($apache_user) ;
my $apache_group = $tree->lookup('Group') ;
my $apache_gid = getgrnam($apache_group) ;
my $fifo = $s->dir_config('HTTunnelFifo') or die("HTTunnelFifo not defined in Apache configuration file") ;
my $conn_timeout = $s->dir_config('HTTunnelConnectionTimeout') || 900 ;
# Setup File::FDkeeper
lib/Apache/HTTunnel/Keeper.pm view on Meta::CPAN
# Setup proper permissions on the fifo...
if (($apache_user)||($apache_group)){
if (! defined($apache_uid)){
$apache_uid = -1 ;
}
if (! defined($apache_gid)){
$apache_gid = -1 ;
}
$slog->debug("HTTunnel Keeper: Apache User is '$apache_user' ($apache_uid)") ;
$slog->debug("HTTunnel Keeper: Apache Group is '$apache_group' ($apache_gid)") ;
chown($apache_uid, $apache_gid, $fifo) or die("Can't chown '$fifo': $!") ;
chmod(0600, $fifo) or die("Can't chmod '$fifo': $!") ;
}
# Now that everything is all set, we can fork and let the child do the work.
view release on metacpan or search on metacpan
t/lib/Apache/test.pm view on Meta::CPAN
# Get default user (apache doesn't like to run as root, special-case it)
my $defuser = ($< && getpwuid $<) || 'nobody';
$conf{user} = _ask("User to run tests under", $defuser);
my $defgroup = ($defuser eq 'nobody' ? 'nobody' : getgrgid((getpwnam $conf{user})[3]));
$conf{group} = _ask("Group to run tests under", $defgroup);
$conf{port} = _ask("Port to run tests under", 8228);
return %conf;
view release on metacpan or search on metacpan
lib/Apache/Logmonster.pm view on Meta::CPAN
# this will fail unless we're root, but that should not matter much
print "\t setting permissions on temp dir..." if $debug > 1;
$util->chown( $tmpdir,
uid => $conf->{'log_user'} || 'www',
gid => $conf->{'log_group'} || 'www',
debug => $debug > 1 ? 1 : 0,
fatal => 0,
);
print "done.\n" if $debug > 1;
}
view release on metacpan or search on metacpan
lib/Apache/MONITOR.pm view on Meta::CPAN
}
elsif( $mon_string =~ /^mtime:(.+)$/ )
{
my $filename = $1;
print "$monitored_uri: checking file mtime of $filename\n";
my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks) = stat($filename);
$modified_time = $mtime;
}
else
{
view release on metacpan or search on metacpan
NNTPGateway.pm view on Meta::CPAN
# Prepare new subject
my $subject = $Article->{Header}{subject};
$subject = "Re: $subject" unless $subject =~ /^re\s*:/i;
# Add references
my $refs = $Article->{Header}{references};
my $msgid = $Article->{Header}{'message-id'};
$refs .= $msgid;
# Quote body
my $body = "\n " . &message( 'msg_cite', $msgid, $Article->{Header}{from} ) . ":\n\n";
$Article->{Body} =~ s/^\s*(.*)$/ > $1/gm;
$body .= $Article->{Body} . "\n\n";
# Print a form for user to edit fields and post.
&print_html_post_form( $r, $subject, $body, $refs );
# The remaining, that is the real NNTP posting is handled by
view release on metacpan or search on metacpan
lib/Apache/PageKit.pm view on Meta::CPAN
$server || die 'must specify $server variable in startup. Usage: Apache::PageKit->startup($pkit_root, $server)';
}
# get user and group as specified by User and Group directives
my $uid = $s->uid;
my $gid = $s->gid;
# include user defined classes (Model) in perl search path
unshift(@INC,"$pkit_root/Model");
my $config_dir = $pkit_root . '/Config';
view release on metacpan or search on metacpan
PrettyPerl.pm view on Meta::CPAN
chroot close closedir connect continue cos
crypt dbmclose dbmopen defined delete die
dump each endgrent endhostent endnetent
endprotoent endpwent endservent eof eval
exec exists exit exp fcntl fileno flock
fork format formline getc getgrent getgrgid
getgrnam gethostbyaddr gethostbyname gethostent
getlogin getnetbyaddr getnetbyname getnetent
getpeername getpgrp getppid getpriority
getprotobyname getprotobynumber getprotoent
getpwent getpwnam getpwuid getservbyname
view release on metacpan or search on metacpan
lib/Apache/Roaming.pm view on Meta::CPAN
if (! -f $file) {
$self->{'status'} = Apache::Constants::NOT_FOUND();
die "No such file: $file";
}
# return Apache::DECLINED();
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime) = stat _;
my $fh = Symbol::gensym();
if (!open($fh, "<$file") || !binmode($fh)) {
die "Failed to open file $file: $!";
}
$r->set_last_modified($mtime);
view release on metacpan or search on metacpan
lib/Apache/SMTP.pm view on Meta::CPAN
my $mailhost = $session->get_mailhost();
my $mailport = $session->get_mailport();
my $mailip = $session->get_local_ip();
return(0, 554, 'Error: no valid recipients')
unless(@recipients);
my $msgid = add_queue({mailhost => $mailhost,
mailport => $mailport,
mailip => $mailip,
sender => $sender,
recipients => \@recipients,
data => $$data});
return(0) unless defined $msgid;
return(1, 250, "message queued $msgid");
}
sub add_queue {
my $args = shift;
my @recipients = @{$args->{recipients}};
lib/Apache/SMTP.pm view on Meta::CPAN
return undef unless $smtp->data();
return undef unless $smtp->datasend($args->{data});
return undef unless $smtp->dataend();
return undef unless $smtp->quit;
}
return (localtime())[0]; # lies that we tell - not a real msgid
}
1;
lib/Apache/SMTP.pm view on Meta::CPAN
=item queue_message
sub queue_message {
my($session, $data) = @_;
my $msgid = add_queue({mailhost => 'hostname',
mailport => '25',
mailip => '127.0.0.1',
sender => 'foo@example.com',
recipients => \('bar@example.com'),
data => $$data});
return(1, 250, "message queued $msgid");
}
=item add_queue
my $msgid = add_queue({mailhost => 'hostname',
mailport => '25',
mailip => '127.0.0.1',
sender => 'foo@example.com',
recipients => \('bar@example.com'),
data => 'somestuff'});
view release on metacpan or search on metacpan
t/lib/Apache/test.pm view on Meta::CPAN
# Get default user (apache doesn't like to run as root, special-case it)
my $defuser = ($< && getpwuid $<) || 'nobody';
$conf{user} = _ask("User to run tests under", $defuser);
my $defgroup = ($defuser eq 'nobody' ? 'nobody' : getgrgid((getpwnam $conf{user})[3]));
$conf{group} = _ask("Group to run tests under", $defgroup);
$conf{port} = _ask("Port to run tests under", 8228);
return %conf;
view release on metacpan or search on metacpan
lib/Apache/SWIT/Security/Role/Manager.pm view on Meta::CPAN
}, $class);
}
sub check_user {
my ($self, $user, $req) = @_;
my %gids = map { ($_, 1) } ($user ? $user->role_ids : ());
my $res;
for my $p (@{ $self->{_perms} }) {
last if ($p == -1*Apache::SWIT::Security::Role::Manager::ALL);
if ($p == Apache::SWIT::Security::Role::Manager::ALL) {
$res = 1;
last;
}
next unless $gids{ abs($p) };
$res = 1 if $p > 0;
last;
}
return $res if $res;
my $hf = $self->{_hook_func} or return;
view release on metacpan or search on metacpan
lib/Apache/SdnFw/lib/Core.pm view on Meta::CPAN
$s->_set_default_access($s->{object},$f);
}
}
my %existing = $s->db_q("
SELECT a.a_function, a.action_id, concat(ga.group_id) as gids
FROM actions_v a
LEFT JOIN group_actions_v ga ON a.action_id=ga.action_id
WHERE a.a_object=?
GROUP BY 1,2
",'hashhash',
k => 'a_function',
v => [ $s->{object} ]);
foreach my $f (keys %existing) {
foreach my $id (split ',', $existing{$f}{gids}) {
$existing{$f}{groupids}{$id} = $id;
}
}
my @groups = $s->db_q("
view release on metacpan or search on metacpan
## groups
$gsth = $dbh->prepare(<<'ENDSQL');
INSERT INTO groups VALUES (?, ?)
ENDSQL
for $gid (keys %groups) {
$gsth->execute($gid, $dbh->quote($groups{$gid}));
}
## authen-methods
$asth = $dbh->prepare(<<'ENDSQL');
INSERT INTO authens VALUES (?, ?, ?)
## process default group in groups and usergroup tables
$gsth->execute($uid, "Default group: $defgrp");
$ugsth->execute($uid, $defgrp);
## process other group memberships
if (defined($gref = $urec->{groups})) {
for $gid (@{$gref}) {
$ugsth->execute($uid, $gid);
}
}
## process authentication methods
for $auth (keys %authens) {
next unless $urec->{$auth};
view release on metacpan or search on metacpan
lib/Apache/Test.pm view on Meta::CPAN
push @SkipReasons, "$module version $version or higher is required";
return 0;
}
sub need_cgi {
return _need_multi(qw(cgi.c cgid.c));
}
sub need_cache_disk {
return _need_multi(qw(cache_disk.c disk_cache.c));
}
lib/Apache/Test.pm view on Meta::CPAN
=item need_cgi
plan tests => 5, need_cgi;
Requires mod_cgi or mod_cgid to be installed.
=item need_cache_disk
plan tests => 5, need_cache_disk
lib/Apache/Test.pm view on Meta::CPAN
=item need_module
plan tests => 5, need_module 'CGI';
plan tests => 5, need_module qw(CGI Find::File);
plan tests => 5, need_module ['CGI', 'Find::File', 'cgid'];
Requires Apache C and Perl modules. The function accept a list of
arguments or a reference to a list.
In case of C modules, depending on how the module name was passed it
lib/Apache/Test.pm view on Meta::CPAN
{ "perl >= 5.8.0 and w/ithreads is required" =>
($Config{useperlio} && $] >= 5.008) },
{ "not Win32" => sub { $^O eq 'MSWin32' },
"foo is disabled" => \&is_foo_enabled,
},
'cgid';
need() is more generic function which can impose multiple requirements
at once. All requirements must be satisfied.
need()'s argument is a list of things to test. The list can include
lib/Apache/Test.pm view on Meta::CPAN
at the time of check and its return value is used to check the
condition. If the condition check fails, the provided (in a key)
reason is used to tell user why the test was skipped.
In the presented example, we require the presence of the C<LWP> Perl
module, C<mod_cgid>, that we run under perl E<gt>= 5.7.3 on Win32.
It's possible to put more than one requirement into a single hash
reference, but be careful that the keys will be different.
It's also important to mention to avoid using:
view release on metacpan or search on metacpan
lib/Apache/VMonitor.pm view on Meta::CPAN
### generic process info
my $proc_info;
# UID and STATE
my $state = $gtop->proc_state($pid);
$proc_info->{uid} = scalar getpwuid $state->uid;
$proc_info->{gid} = scalar getgrgid $state->gid;
$proc_info->{state} = $state->state;
# TTY
my $proc_uid = $gtop->proc_uid($pid);
my $tty = $proc_uid->tty;
$tty = 'None' if $tty == -1;
lib/Apache/VMonitor.pm view on Meta::CPAN
PROCESS single_httpd_process IF rec.is_httpd_proc;
"<hr><b>General process info:</b>\n";
USE format_proc_item = format(" <b>%-25s</b> : %s\n");
format_proc_item("UID", proc.uid);
format_proc_item("GID", proc.gid);
format_proc_item("State", proc.state);
format_proc_item("TTY", proc.tty);
format_proc_item("Command line arguments", proc.argv);
# memory usage
view release on metacpan or search on metacpan
lib/Apache/Voodoo/Constants.pm view on Meta::CPAN
foreach (keys %h) {
$self->{$_} = $h{$_};
}
}
sub apache_gid { return $_[0]->{APACHE_GID}; }
sub apache_uid { return $_[0]->{APACHE_UID}; }
sub code_path { return $_[0]->{CODE_PATH}; }
sub conf_file { return $_[0]->{CONF_FILE}; }
sub conf_path { return $_[0]->{CONF_PATH}; }
sub install_path { return $_[0]->{INSTALL_PATH}; }
view release on metacpan or search on metacpan
lib/Apache/WebDAV.pm view on Meta::CPAN
}
my %wanted_properties = $self->get_wanted_properties($r);
# The list of properties in order which a stat() call must return.
my @properties = qw(dev ino mode nlink uid gid rdev getcontentlength
atime getlastmodified creationdate);
# Loop through all the files and call stat() on each one. Keep track of
# which properties the client requested.
my @results;
view release on metacpan or search on metacpan
Wyrd/DBL.pm view on Meta::CPAN
db_password
db_username
dba
dev
file_path
gid
globals
ino
logfile
loglevel
mode
Wyrd/DBL.pm view on Meta::CPAN
}
=pod
=item (scalar) C<gid> (void)
the numeric group ID of file's owner of the file currently being served.
Derived from Apache::Wyrd::Handler, by default compatible with the C<stat()>
builtin function.
=cut
sub gid {
my ($self) = @_;
return $self->{'gid'};
}
=pod
view release on metacpan or search on metacpan
lib/DBIx/UserDB.pm view on Meta::CPAN
=head2 Users and Groups
Users are represented as hash and as one SQL table. They have a unique
username and a unique uid. Group have also a unique name and a unique
gid. A user may be a members of many groups.
=head2 ACLs
UserDB can also be used to manage complex ACL (Acccess Control Lists).
Access to resources is determined by the tuple (user,target,privilege)
lib/DBIx/UserDB.pm view on Meta::CPAN
username CHAR(32) UNIQUE,
password CHAR(32)
);
CREATE TABLE groupdb (
gid SERIAL PRIMARY KEY,
groupname CHAR(32) UNIQUE
);
CREATE TABLE groupmembers (
gid INT REFERENCES groupdb,
uid INT REFERENCES userdb,
PRIMARY KEY (gid,uid)
);
CREATE TABLE user_acl (
uid INT REFERENCES userdb,
target CHAR(128),
lib/DBIx/UserDB.pm view on Meta::CPAN
negated BOOL DEFAULT 0,
PRIMARY KEY (uid,target,privilege)
);
CREATE TABLE group_acl (
gid INT REFERENCES groupdb,
target CHAR(128),
privilege CHAR(32),
negated BOOL DEFAULT 0,
PRIMARY KEY (gid,target,privilege)
);
CREATE TABLE default_acl (
target CHAR(128),
privilege CHAR(32),
lib/DBIx/UserDB.pm view on Meta::CPAN
keys => [qw( uid )],
table => "userdb",
},
groupdb =>
{
query => q{ SELECT m.gid,uid,groupname FROM groupdb, groupmembers m
WHERE uid = ? },
params => [ qw( uid ) ],
fields => [ qw( groupname ) ],
keys => [ qw( gid )],
table => "groupdb",
} ,
}
You may add any fields to the groupdb and userdb tables as long as you
lib/DBIx/UserDB.pm view on Meta::CPAN
This method creates a new group in the database. At least the
I<groupname> key should be set in the hash.
This methods returns false if there is already a group with the same
groupname. It returns true if the creation succeeded. Additionnaly, on
return, the key I<gid> will be set in the original group's hash.
=cut
sub group_create {
my ( $self, $group ) = @_;
lib/DBIx/UserDB.pm view on Meta::CPAN
sub load_group {
my ( $self, $group ) = @_;
$group->{members} =
$self->{DB}->sql_search( q{ SELECT uid FROM groupmembers WHERE gid = ? },
$group->{gid} );
return $group;
}
=pod
lib/DBIx/UserDB.pm view on Meta::CPAN
return $groups;
}
=pod
=head2 group_get ( $gid_or_name )
This method takes a gid or groupname and will fetch the corresponding
group. It returns the corresponding group or undef if there is no such
group. Additionnaly there is a key I<members> defined in the resulting
hash which contains in an array the name of all members of the group.
=cut
sub group_get {
my ( $self, $gidorname ) = @_;
my $group;
if ( $gidorname =~ /\d+/ ) {
$group = $self->{DB}->record_get( $self->{group_profile}, $gidorname );
return undef unless $group;
} else {
my $groups = $self->{DB}->record_search( $self->{group_profile},
{ groupname => $gidorname } );
return undef unless @$groups;
$group = $groups->[0];
}
lib/DBIx/UserDB.pm view on Meta::CPAN
sub group_delete {
my ( $self, $group ) = @_;
my $DB = $self->{DB};
$DB->sql_delete( q{ DELETE FROM groupmembers WHERE gid = ? },
$group->{gid} );
$DB->record_delete( $self->{group_profile}, $group->{gid} );
}
=pod
=head2 group_update ( \%group )
lib/DBIx/UserDB.pm view on Meta::CPAN
sub group_add_user {
my ( $self, $group, $user ) = @_;
my $DB = $self->{DB};
$DB->sql_insert( q{ INSERT INTO groupmembers (gid,uid)
VALUES (?,?) },
$group->{gid}, $user->{uid} );
push @{$group->{members}}, $user->{uid};
}
=pod
lib/DBIx/UserDB.pm view on Meta::CPAN
sub group_remove_user {
my ( $self, $group, $user ) = @_;
my $DB = $self->{DB};
$DB->sql_insert( q{ DELETE FROM groupmembers WHERE gid = ? AND uid = ?) },
$group->{gid}, $user->{uid} );
$group->{members} = [ grep { $_ != $user->{uid} } @{$group->{members} } ];
}
lib/DBIx/UserDB.pm view on Meta::CPAN
WHERE uid = ? AND target = ?
AND privilege = ? },
$negated, $whom->{uid}, $target, $priv );
} else {
$rv = $DB->sql_updated( q{ UPDATED group_acl SET negated = ?
WHERE gid = ? AND target = ?
AND privilege = ? },
$negated, $whom->{gid}, $target, $priv );
}
unless ( $rv ) {
if ( not ref $whom) {
$DB->sql_insert( q{ INSERT INTO default_acl
(target,privilege,negated)
lib/DBIx/UserDB.pm view on Meta::CPAN
(uid,target,privilege,negated)
VALUES (?,?,?,?) },
$whom->{uid}, $target, $priv, $negated );
} else {
$DB->sql_insert( q{ INSERT INTO group_acl
(gid,target,privilege,negated)
VALUES (?,?,?,?) },
$whom->{gid}, $target, $priv, $negated );
}
}
}
=pod
lib/DBIx/UserDB.pm view on Meta::CPAN
$DB->sql_delete( q{ DELETE FROM user_acl
WHERE uid = ? AND target = ? AND privilege = ? },
$whom->{uid}, $target, $priv );
} else {
$DB->sql_delete( q{ DELETE FROM group_acl
WHERE gid = ? AND target = ? AND privilege = ? },
$whom->{gid}, $target, $priv );
}
}
=pod
lib/DBIx/UserDB.pm view on Meta::CPAN
return not $user_policy->{negated} if $user_policy;
# Now check the group in which this user is.
# All the group policy must match for this to be returned as
# a result. If there is a conflict, we use the default policy.
my $groups = join ",", map { $_->{gid} } @{$user->{groups}};
my $group_policy =
$DB->sql_search( qq{ SELECT DISTINCT negated FROM group_acl
WHERE gid IN ( $groups ) AND
target = ? AND privilege = ?},
$target, $priv );
return not $group_policy->[0]{negated} if @$group_policy == 1;
# Use the default policy
view release on metacpan or search on metacpan
lib/Apache2/API/Status.pm view on Meta::CPAN
414 => "¡El URI enviado es demasiado largo!",
415 => "¡Tipo de medio no soportado!",
416 => "Rango no satisfacible!",
417 => "Expectativa no satisfecha!",
418 => "Soy una tetera",
421 => "Solicitud mal dirigida",
422 => "¡Entidad no procesable!",
423 => "Recurso bloqueado!",
424 => "¡Dependencia fallida!",
425 => "¡Demasiado pronto!",
426 => "¡Actualización requerida!",
lib/Apache2/API/Status.pm view on Meta::CPAN
305 => "Usar proxy",
307 => "Redirecionamento temporário!",
308 => "Redirecionamento permanente!",
400 => "Pedido incorreto!",
401 => "Autenticação necessária!",
402 => "Pagamento exigido!",
403 => "Acesso proibido!",
404 => "Objeto não encontrado!",
405 => "Método não permitido!",
406 => "Não aceitável!",
407 => "Autenticação de proxy necessária!",
view release on metacpan or search on metacpan
lib/Apache2/Archive.pm view on Meta::CPAN
$t->{filename} = $r->filename;
unless (-e $t->{filename} && -r $t->{filename}) {
return Apache2::Const::NOT_FOUND;
}
my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks)=stat($t->{filename});
($t->{FileInfo}->{'name'}) = $t->{filename} =~ m!(([^/\\]|\\\/)+)$!;
$t->{FileInfo}->{'date'} = &getDatestring($mtime, $r->dir_config('Months'));
$t->{FileInfo}->{'rawsize'} = -s $t->{filename};
$t->{FileInfo}->{'size'} = &getSizestring($t->{FileInfo}->{'rawsize'});
view release on metacpan or search on metacpan
lib/Apache2/AuthenNIS.pm view on Meta::CPAN
"$status, $error_msg", $r->uri );
return Apache2::Const::HTTP_UNAUTHORIZED;
}
}
my( $user, $hash, $uid, $gid, $gecos, $dir, $shell ) = split( /:/, $entry );
if ( crypt( $sent_pwd, $hash ) eq $hash ) {
return Apache2::Const::OK;
} else {
if ( lc( $allowaltauth ) eq "yes" ) {
view release on metacpan or search on metacpan
smb/smbval/smblib-priv.h view on Meta::CPAN
char service[80], username[80], password[80], desthost[80], sock_options[80];
char address[80], myname[80];
SMB_Tree_Handle first_tree, last_tree; /* List of trees on this server */
int gid; /* Group ID, do we need it? */
int mid; /* Multiplex ID? We might need one per con */
int pid; /* Process ID */
int uid; /* Authenticated user id. */
view release on metacpan or search on metacpan
examples/fakeup.pl view on Meta::CPAN
use strict;
use Data::Dumper;
use constant PRINTF => '%y\t%m\t%M\t%n\t%U\t%u\t%G\t%g\t%s\t%TY-%Tm-%Td '.
'%TH:%TM\t%T@\t%CY-%Cm-%Cd %CH:%CM\t%C@\t%h\t%f\t%p\n';
use constant PRINTF_FIELDS => qw(type mode perms links uid owner gid
group size mtime unixmtime ctime unixctime path filename absfile);
my %data;
my $cmd = sprintf('find . -printf "%s"',PRINTF);
view release on metacpan or search on metacpan
t/conf/extra.last.conf.in view on Meta::CPAN
LoadModule proxy_module @src_dir@/mod_proxy.so
LoadModule proxy_http_module @src_dir@/mod_proxy_http.so
LoadModule proxy_connect_module @src_dir@/mod_proxy_connect.so
<IfModule !mod_fcgid.c>
LoadModule fcgid_module @src_dir@/mod_fcgid.so
#ScriptSock @t_logs@/cgisock
#FcgidIPCDir @t_logs@/fcgidsock
FcgidIPCDir /tmp/apache-test-fcgid
FcgidProcessTableFile @t_logs@/fcgid_shm
</IfModule>
<IfModule !mod_cgi.c>
LoadModule cgi_module @src_dir@/mod_cgi.so
#ScriptSock @t_logs@/cgisock
t/conf/extra.last.conf.in view on Meta::CPAN
#PerlSetVar RemoteFirst on
<Directory "@DocumentRoot@">
AllowOverride all
AddHandler cgi-script .cgi
AddHandler fcgid-script .fcgi
Options Indexes ExecCGI MultiViews
#DirectoryIndex index
</Directory>
view release on metacpan or search on metacpan
lib/Apache2/PageKit.pm view on Meta::CPAN
$server || die 'must specify $server variable in startup. Usage: Apache2::PageKit->startup($pkit_root, $server)';
}
# get user and group as specified by User and Group directives
# my $uid = $s->uid;
# my $gid = $s->gid;
# include user defined classes (Model) in perl search path
unshift(@INC,"$pkit_root/Model");
my $config_dir = $pkit_root . '/Config';
view release on metacpan or search on metacpan
chdir chmod chomp chop chown chr chroot close closedir
connect continue cos crypt dbmclose dbmopen defined
delete die do dump each endgrent endhostent endnetent
endprotoent endpwent endservent eof eval exec exists
exit exp fcntl fileno flock fork format formline getc
getgrent getgrgid getgrnam gethostbyaddr gethostbyname
gethostent getlogin getnetbyaddr getnetbyname getnetent
getpeername getpgrp getppid getpriority getprotobyname
getprotobynumber getprotoent getpwent getpwnam getpwuid
getservbyname getservbyport getservent getsockname
getsockopt glob gmtime goto grep hex import index int
view release on metacpan or search on metacpan
lib/Apache2/Protocol/ESMTP.pm view on Meta::CPAN
my $date = strftime('%Y-%m-%d %H:%M:%S', localtime);
open(LOG, ">>$self->{_log_filename}") or die "Can't open log $self->{_log_filename}: $!";
flock(LOG, LOCK_EX);
seek(LOG, 0, 2);
$data = "$self->{_msgid} $data" if $self->{_msgid};
$data .= " [$self->{_log_remotehost}]" if $self->{_log_remotehost};
print LOG "$date $data\n";
flock(LOG, LOCK_UN);
close(LOG);
}
view release on metacpan or search on metacpan
lib/Apache2/SSI/Finfo.pm view on Meta::CPAN
{
return( $self->{filepath} );
}
}
sub gid { return( shift->group ); }
sub group
{
my $self = shift( @_ );
my $f = $self->apr_finfo;
lib/Apache2/SSI/Finfo.pm view on Meta::CPAN
{
# File does not exist
}
# Same as $finfo->filepath
print "File path is: ", $finfo->fname;
print "File group id is: ", $finfo->gid;
# Can also use $finfo->group which will yield the same result
$finfo->ino;
# or $finfo->inode;
if( $finfo->is_block )
{
lib/Apache2/SSI/Finfo.pm view on Meta::CPAN
=head2 fname
Returns the file path as a string. Same as L</filepath>
=head2 gid
Returns the numeric group ID of file's owner. Same as L</group>
=head2 group
Returns the numeric group ID of file's owner. Same as L</gid>
=for Pod::Coverage ino
=head2 inode