Result:
found more than 700 distributions - search limited to the first 2001 files matching your query
( run in 1.077 )
Compress-BGZF
view release on metacpan or search on metacpan
lib/Compress/BGZF.pm view on Meta::CPAN
__END__
=head1 NAME
Compress::BGZF - Read/write blocked GZIP (BGZF) files
=head1 SYNOPSIS
use Compress::BGZF::Writer;
use Compress::BGZF::Reader;
Compress-Bzip2
view release on metacpan or search on metacpan
- fix a couple if dangling else corner cases
format string errors, and unused variables.
- [cpan #82576] fix pod formatting errors
- [cpan #48128] support memBunzip BZh header w/o extra size prefix
and grow dest buf dynamically. Tests in t/040-memory.t
- [cpan #40741] fix bzreadline blocked on the broken bz2 files
- [cpan #84223] fix ignored bzinflateInit args
- [cpan #48124] Multiple issues with bzinflate
support PV ref as bzinflate() buffer arg as documented.
support status checks in chunked bzinflate() calls. t/060-inflate.t
- [cpan #49618] fix for win32 nmake + gcc
Compress-Deflate7
view release on metacpan or search on metacpan
7zip/CPP/7zip/Archive/7z/7zDecode.cpp view on Meta::CPAN
#ifndef _NO_CRYPTO
passwordIsDefined = false;
#endif
CObjectVector< CMyComPtr<ISequentialInStream> > inStreams;
CLockedInStream lockedInStream;
lockedInStream.Init(inStream);
for (int j = 0; j < folderInfo.PackStreams.Size(); j++)
{
CLockedSequentialInStreamImp *lockedStreamImpSpec = new
CLockedSequentialInStreamImp;
CMyComPtr<ISequentialInStream> lockedStreamImp = lockedStreamImpSpec;
lockedStreamImpSpec->Init(&lockedInStream, startPos);
startPos += packSizes[j];
CLimitedSequentialInStream *streamSpec = new
CLimitedSequentialInStream;
CMyComPtr<ISequentialInStream> inStream = streamSpec;
streamSpec->SetStream(lockedStreamImp);
streamSpec->Init(packSizes[j]);
inStreams.Add(inStream);
}
int numCoders = folderInfo.Coders.Size();
Compress-Raw-Bzip2
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
Compress-Raw-Lzma
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
Compress-Raw-Zlib
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
Compress-Snappy
view release on metacpan or search on metacpan
src/csnappy_compress.c view on Meta::CPAN
* *** DO NOT CHANGE THE VALUE OF kBlockSize ***
* New Compression code chops up the input into blocks of at most
* the following size. This ensures that back-references in the
* output never cross kBlockSize block boundaries. This can be
* helpful in implementing blocked decompression. However the
* decompression code should not rely on this guarantee since older
* compression code may not obey it.
*/
#define kBlockLog 15
#define kBlockSize (1 << kBlockLog)
Compress-Stream-Zstd
view release on metacpan or search on metacpan
ext/zstd/programs/fileio.c view on Meta::CPAN
ZSTD_frameProgression previous_zfp_correction = { 0, 0, 0, 0, 0, 0 };
typedef enum { noChange, slower, faster } speedChange_e;
speedChange_e speedChange = noChange;
unsigned flushWaiting = 0;
unsigned inputPresented = 0;
unsigned inputBlocked = 0;
unsigned lastJobID = 0;
UTIL_time_t lastAdaptTime = UTIL_getTime();
U64 const adaptEveryMicro = REFRESH_RATE;
UTIL_HumanReadableSize_t const file_hrs = UTIL_makeHumanReadableSize(fileSize);
ext/zstd/programs/fileio.c view on Meta::CPAN
CHECK_V(stillToFlush, ZSTD_compressStream2(ress.cctx, &outBuff, &inBuff, directive));
AIO_ReadPool_consumeBytes(ress.readCtx, inBuff.pos - oldIPos);
/* count stats */
inputPresented++;
if (oldIPos == inBuff.pos) inputBlocked++; /* input buffer is full and can't take any more : input speed is faster than consumption rate */
if (!toFlushNow) flushWaiting = 1;
/* Write compressed stream */
DISPLAYLEVEL(6, "ZSTD_compress_generic(end:%u) => input pos(%u)<=(%u)size ; output generated %u bytes \n",
(unsigned)directive, (unsigned)inBuff.pos, (unsigned)inBuff.size, (unsigned)outBuff.pos);
ext/zstd/programs/fileio.c view on Meta::CPAN
unsigned long long newlyProduced = zfp.produced - previous_zfp_update.produced;
unsigned long long newlyFlushed = zfp.flushed - previous_zfp_update.flushed;
assert(zfp.produced >= previous_zfp_update.produced);
assert(prefs->nbWorkers >= 1);
/* test if compression is blocked
* either because output is slow and all buffers are full
* or because input is slow and no job can start while waiting for at least one buffer to be filled.
* note : exclude starting part, since currentJobID > 1 */
if ( (zfp.consumed == previous_zfp_update.consumed) /* no data compressed : no data available, or no more buffer to compress to, OR compression is really slow (compression of a single block is slower than update rate)*/
&& (zfp.nbActiveWorkers == 0) /* confirmed : no compression ongoing */
ext/zstd/programs/fileio.c view on Meta::CPAN
if (zfp.currentJobID > lastJobID) {
DISPLAYLEVEL(6, "compression level adaptation check \n")
/* check input speed */
if (zfp.currentJobID > (unsigned)(prefs->nbWorkers+1)) { /* warm up period, to fill all workers */
if (inputBlocked <= 0) {
DISPLAYLEVEL(6, "input is never blocked => input is slower than ingestion \n");
speedChange = slower;
} else if (speedChange == noChange) {
unsigned long long newlyIngested = zfp.ingested - previous_zfp_correction.ingested;
unsigned long long newlyConsumed = zfp.consumed - previous_zfp_correction.consumed;
unsigned long long newlyProduced = zfp.produced - previous_zfp_correction.produced;
unsigned long long newlyFlushed = zfp.flushed - previous_zfp_correction.flushed;
previous_zfp_correction = zfp;
assert(inputPresented > 0);
DISPLAYLEVEL(6, "input blocked %u/%u(%.2f) - ingested:%u vs %u:consumed - flushed:%u vs %u:produced \n",
inputBlocked, inputPresented, (double)inputBlocked/inputPresented*100,
(unsigned)newlyIngested, (unsigned)newlyConsumed,
(unsigned)newlyFlushed, (unsigned)newlyProduced);
if ( (inputBlocked > inputPresented / 8) /* input is waiting often, because input buffers is full : compression or output too slow */
&& (newlyFlushed * 33 / 32 > newlyProduced) /* flush everything that is produced */
&& (newlyIngested * 33 / 32 > newlyConsumed) /* input speed as fast or faster than compression speed */
) {
DISPLAYLEVEL(6, "recommend faster as in(%llu) >= (%llu)comp(%llu) <= out(%llu) \n",
newlyIngested, newlyConsumed, newlyProduced, newlyFlushed);
speedChange = faster;
}
}
inputBlocked = 0;
inputPresented = 0;
}
if (speedChange == slower) {
DISPLAYLEVEL(6, "slower speed , higher compression \n")
Compress-Zstd
view release on metacpan or search on metacpan
ext/zstd/programs/fileio.c view on Meta::CPAN
ZSTD_frameProgression previous_zfp_correction = { 0, 0, 0, 0, 0, 0 };
typedef enum { noChange, slower, faster } speedChange_e;
speedChange_e speedChange = noChange;
unsigned flushWaiting = 0;
unsigned inputPresented = 0;
unsigned inputBlocked = 0;
unsigned lastJobID = 0;
DISPLAYLEVEL(6, "compression using zstd format \n");
/* init */
ext/zstd/programs/fileio.c view on Meta::CPAN
size_t const toFlushNow = ZSTD_toFlushNow(ress.cctx);
CHECK_V(stillToFlush, ZSTD_compressStream2(ress.cctx, &outBuff, &inBuff, directive));
/* count stats */
inputPresented++;
if (oldIPos == inBuff.pos) inputBlocked++; /* input buffer is full and can't take any more : input speed is faster than consumption rate */
if (!toFlushNow) flushWaiting = 1;
/* Write compressed stream */
DISPLAYLEVEL(6, "ZSTD_compress_generic(end:%u) => input pos(%u)<=(%u)size ; output generated %u bytes \n",
(unsigned)directive, (unsigned)inBuff.pos, (unsigned)inBuff.size, (unsigned)outBuff.pos);
ext/zstd/programs/fileio.c view on Meta::CPAN
unsigned long long newlyProduced = zfp.produced - previous_zfp_update.produced;
unsigned long long newlyFlushed = zfp.flushed - previous_zfp_update.flushed;
assert(zfp.produced >= previous_zfp_update.produced);
assert(prefs->nbWorkers >= 1);
/* test if compression is blocked
* either because output is slow and all buffers are full
* or because input is slow and no job can start while waiting for at least one buffer to be filled.
* note : exclude starting part, since currentJobID > 1 */
if ( (zfp.consumed == previous_zfp_update.consumed) /* no data compressed : no data available, or no more buffer to compress to, OR compression is really slow (compression of a single block is slower than update rate)*/
&& (zfp.nbActiveWorkers == 0) /* confirmed : no compression ongoing */
ext/zstd/programs/fileio.c view on Meta::CPAN
if (zfp.currentJobID > lastJobID) {
DISPLAYLEVEL(6, "compression level adaptation check \n")
/* check input speed */
if (zfp.currentJobID > (unsigned)(prefs->nbWorkers+1)) { /* warm up period, to fill all workers */
if (inputBlocked <= 0) {
DISPLAYLEVEL(6, "input is never blocked => input is slower than ingestion \n");
speedChange = slower;
} else if (speedChange == noChange) {
unsigned long long newlyIngested = zfp.ingested - previous_zfp_correction.ingested;
unsigned long long newlyConsumed = zfp.consumed - previous_zfp_correction.consumed;
unsigned long long newlyProduced = zfp.produced - previous_zfp_correction.produced;
unsigned long long newlyFlushed = zfp.flushed - previous_zfp_correction.flushed;
previous_zfp_correction = zfp;
assert(inputPresented > 0);
DISPLAYLEVEL(6, "input blocked %u/%u(%.2f) - ingested:%u vs %u:consumed - flushed:%u vs %u:produced \n",
inputBlocked, inputPresented, (double)inputBlocked/inputPresented*100,
(unsigned)newlyIngested, (unsigned)newlyConsumed,
(unsigned)newlyFlushed, (unsigned)newlyProduced);
if ( (inputBlocked > inputPresented / 8) /* input is waiting often, because input buffers is full : compression or output too slow */
&& (newlyFlushed * 33 / 32 > newlyProduced) /* flush everything that is produced */
&& (newlyIngested * 33 / 32 > newlyConsumed) /* input speed as fast or faster than compression speed */
) {
DISPLAYLEVEL(6, "recommend faster as in(%llu) >= (%llu)comp(%llu) <= out(%llu) \n",
newlyIngested, newlyConsumed, newlyProduced, newlyFlushed);
speedChange = faster;
}
}
inputBlocked = 0;
inputPresented = 0;
}
if (speedChange == slower) {
DISPLAYLEVEL(6, "slower speed , higher compression \n")
Concierge-Auth
view release on metacpan or search on metacpan
examples/08-advanced-usage.pl view on Meta::CPAN
# Implement rate limiting for authentication attempts
my %failed_attempts;
my $MAX_ATTEMPTS = 3;
my $LOCKOUT_DURATION = 300; # 5 minutes
sub is_locked_out {
my ($username) = @_;
return unless exists $failed_attempts{$username};
my $attempts = $failed_attempts{$username};
examples/08-advanced-usage.pl view on Meta::CPAN
}
sub secure_authenticate {
my ($auth, $username, $password) = @_;
# Check if user is locked out
if (is_locked_out($username)) {
return (0, 'Account temporarily locked due to failed attempts');
}
# Attempt authentication
my $success = $auth->checkPwd($username, $password);
examples/08-advanced-usage.pl view on Meta::CPAN
printf " Attempt %d: %s - %s\n", $attempt,
$success ? "✓ success" : "✗ failed", $message;
}
print "\nAttempt with correct password after lockout:\n";
my ($locked_success, $locked_message) = secure_authenticate($rate_auth, 'testuser', 'correct_password');
printf " Correct password: %s - %s\n",
$locked_success ? "✓ success" : "✗ failed", $locked_message;
print "\n--- Custom Password Policy ---\n";
# Implement custom password policy
sub validate_password_policy {
Concierge-Users
view release on metacpan or search on metacpan
lib/Concierge/Users/Meta.pm view on Meta::CPAN
# Check if field is protected; only format_as and label may be overridden
if ( $field_name =~ /^(?:user_id|last_login_date|last_mod_date|created_date)$/) {
my %allowed = map { $_ => 1 } qw/format_as label/;
my @apply = grep { $allowed{$_} } keys %$override;
my @blocked = grep { !$allowed{$_} && $_ ne 'field_name' } keys %$override;
carp "Field '$field_name' is protected; ignoring: " . join(', ', sort @blocked)
if @blocked;
$merged_definitions{$field_name}{$_} = $override->{$_} for @apply;
next;
}
# Check if field exists in merged_definitions
lib/Concierge/Users/Meta.pm view on Meta::CPAN
required => 1,
label => 'Work Email',
},
],
B<Protected fields> (structural attributes blocked; C<format_as> and
C<label> are allowed): C<user_id>, C<last_login_date>, C<last_mod_date>,
C<created_date>.
B<Protected attributes> that cannot be changed: C<field_name>,
C<category>.
Config-Hierarchical
view release on metacpan or search on metacpan
lib/Config/Hierarchical.pm view on Meta::CPAN
This sub will be used when a warning is displayed. e.g. a configuration that is refused or an override.
=item DIE
Used when an error occurs. E.g. a locked variable is set.
=item DEBUG
If this option is set, Config::Hierarchical will call the sub before and after acting on the configuration.
This can act as a breakpoint in a debugger or allows you to pinpoint a configuration problem.
lib/Config/Hierarchical.pm view on Meta::CPAN
{
$self->{INTERACTION}{DIE}->("$self->{NAME}: Invalid 'EVALUATOR' definition, expecting a sub reference at '$location'!") ;
}
}
# temporarely remove the locked categories till we have handled INITIAL_VALUES
my $category_locks ;
if(exists $self->{LOCKED_CATEGORIES})
{
if('ARRAY' ne ref $self->{LOCKED_CATEGORIES})
lib/Config/Hierarchical.pm view on Meta::CPAN
Extra validators that will only be used during this call to B<Set>.
=item * FORCE_LOCK
If a variable is locked, trying to set it will generate an error. It is possible to temporarily force
the lock with this option. A warning is displayed when a lock is forced.
=item * LOCK
Will lock the variable if set to 1, unlock if set to 0.
lib/Config/Hierarchical.pm view on Meta::CPAN
) ;
}
if(exists $self->{LOCKED_CATEGORIES}{$options{CATEGORY}})
{
$self->{INTERACTION}{DIE}->("$self->{NAME}: Variable '$options{CATEGORY}::$options{NAME}', category '$options{CATEGORY}' was locked at '$location'.\n") ;
}
if
(
exists $self->{CATEGORIES}{$options{CATEGORY}}{$options{NAME}}
lib/Config/Hierarchical.pm view on Meta::CPAN
{
# not the same value
unless(exists $config_variable->{LOCKED})
{
#~ Not locked, set
$set_status .= 'OK.' ;
}
else
{
if($options->{FORCE_LOCK})
{
$set_status .= 'OK, forced lock.' ;
$self->{INTERACTION}{WARN}->("$self->{NAME}: Forcing locked variable '$options->{CATEGORY}::$options->{NAME}' at '$location'.\n") ;
}
else
{
$self->{INTERACTION}{DIE}->("$self->{NAME}: Variable '$options->{CATEGORY}::$options->{NAME}' was locked and couldn't be set at '$location'.\n") ;
}
}
}
else
{
lib/Config/Hierarchical.pm view on Meta::CPAN
sub LockCategories
{
=head2 LockCategories(@categories)
Locks the categories passed as argument. A variable in a locked category can not be set.
An attempt to set a locked variable will generate an error. B<FORCE_LOCK> has no effect on locked categories.
$config->LockCategories('PARENT', 'OTHER') ;
I<Arguments>
lib/Config/Hierarchical.pm view on Meta::CPAN
sub Lock
{
=head2 Lock(NAME => $variable_name, CATEGORY => $category)
Locks a variable in the default category or an explicit category. A locked variable can not be set.
To set a locked variable, B<FORCE_LOCK> can be used. B<FORCE_LOCK> usually pinpoints a problem
in your configuration.
$config->Lock(NAME => 'CC') ;
$config->Lock(NAME => 'CC', CATEGORY => 'PARENT') ;
lib/Config/Hierarchical.pm view on Meta::CPAN
if($self->{VERBOSE})
{
$self->{INTERACTION}{INFO}->("$self->{NAME}: Checking Lock of '$options{CATEGORY}::$options{NAME}' at '$location'.\n") ;
}
my $locked = undef ;
if(exists $self->{CATEGORIES}{$options{CATEGORY}}{$options{NAME}})
{
if(exists $self->{CATEGORIES}{$options{CATEGORY}}{$options{NAME}}{LOCKED})
{
$locked = 1 ;
}
else
{
$locked = 0 ;
}
}
return($locked) ;
}
#-------------------------------------------------------------------------------
sub Exists
Config-IPFilter
view release on metacpan or search on metacpan
lib/Config/IPFilter.pm view on Meta::CPAN
=head1 Description
# Example of a "ipfilter.dat" file
#
# All entered IP ranges will be blocked in both directions. Be careful
# what you enter here. Wrong entries may totally block access to the
# network.
#
# Format:
# IP-Range , Access Level , Description
#
# Access Levels:
# 127 blocked
# >=127 permitted
064.094.089.000 - 064.094.089.255 , 000 , Gator.com
This entry will block the IPs from 064.094.089.000 to 064.094.089.255, i.e.
Config-Inetd
view release on metacpan or search on metacpan
- Some inefficiency cleaned up.
0.07 2004/01/25
- inetd.conf is locked.
0.03 2004/01/21
- bin/inetd.pl added.
Config-Model-Systemd
view release on metacpan or search on metacpan
lib/Config/Model/models/Systemd/Common/Exec.pl view on Meta::CPAN
]
},
'SecureBits',
{
'description' => 'Controls the secure bits set for the executed process. Takes a space-separated combination of
options from the following list: C<keep-caps>, C<keep-caps-locked>,
C<no-setuid-fixup>, C<no-setuid-fixup-locked>, C<noroot>, and
C<noroot-locked>. This option may appear more than once, in which case the secure bits are
ORed. If the empty string is assigned to this option, the bits are reset to 0. This does not affect commands
prefixed with C<+>. See L<capabilities(7)> for
details.',
'type' => 'leaf',
'value_type' => 'uniline'
lib/Config/Model/models/Systemd/Common/Exec.pl view on Meta::CPAN
{
'description' => 'Takes a boolean argument. If set, writes to the hardware clock or system clock will
be denied. Defaults to off. Enabling this option removes C<CAP_SYS_TIME> and
C<CAP_WAKE_ALARM> from the capability bounding set for this unit, installs a system
call filter to block calls that can set the clock, and C<DeviceAllow=char-rtc r> is
implied. Note that the system calls are blocked altogether, the filter does not take into account
that some of the calls can be used to read the clock state with some parameter combinations.
Effectively, C</dev/rtc0>, C</dev/rtc1>, etc. are made read-only
to the service. See
L<systemd.resource-control(5)>
for the details about C<DeviceAllow>.
lib/Config/Model/models/Systemd/Common/Exec.pl view on Meta::CPAN
option. Specifically, it is recommended to combine this option with
C<SystemCallArchitectures=native> or similar.
Note that strict system call filters may impact execution and error handling code paths of the
service invocation. Specifically, access to the execve() system call is required
for the execution of the service binary \x{2014} if it is blocked service invocation will necessarily fail.
Also, if execution of the service binary fails for some reason (for example: missing service
executable), the error handling logic might require access to an additional set of system calls in
order to process and log this failure correctly. It might be necessary to temporarily disable system
call filters in order to allow debugging of such failures.
lib/Config/Model/models/Systemd/Common/Exec.pl view on Meta::CPAN
call may be used to execute operations similar to what can be done with the older
kill() system call, hence blocking the latter without the former only provides
weak protection. Since new system calls are added regularly to the kernel as development progresses,
keeping system call deny lists comprehensive requires constant work. It is thus recommended to use
allow-listing instead, which offers the benefit that new system calls are by default implicitly
blocked until the allow list is updated.
Also note that a number of system calls are required to be accessible for the dynamic linker to
work. The dynamic linker is required for running most regular programs (specifically: all dynamic ELF
binaries, which is how most distributions build packaged programs). This means that blocking these
system calls (which include open(), openat() or
Config-Patch
view release on metacpan or search on metacpan
lib/Config/Patch.pm view on Meta::CPAN
my($self) = @_;
# Ignore if locking wasn't requested
return if ! $self->{flock};
# Already locked?
if($self->{locked}) {
$self->{locked}++;
return 1;
}
open my $fh, "+<$self->{file}" or
LOGDIE "Cannot open $self->{file} ($!)";
flock($fh, LOCK_EX);
$self->{fh} = $fh;
$self->{locked} = 1;
}
###########################################
sub unlock {
###########################################
my($self) = @_;
# Ignore if locking wasn't requested
return if ! $self->{flock};
if(! $self->{locked}) {
# Not locked?
return 1;
}
if($self->{locked} > 1) {
# Multiple lock released?
$self->{locked}--;
return 1;
}
# Release the last lock
flock($self->{fh}, LOCK_UN);
$self->{locked} = undef;
1;
}
# LEGACY METHODS
Config-Simple
view release on metacpan or search on metacpan
unless ( sysopen(FH, $file, O_WRONLY|O_CREAT, 0666) ) {
$self->error("'$file' couldn't be opened for writing: $!");
return undef;
}
unless ( flock(FH, LOCK_EX) ) {
$self->error("'$file' couldn't be locked: $!");
return undef;
}
unless ( truncate(FH, 0) ) {
$self->error("'$file' couldn't be truncated: $!");
return undef;
Config-Std
view release on metacpan or search on metacpan
lib/Config/Std.pm view on Meta::CPAN
open my $fh, '>', $filename
or croak "Can't open config file '$filename' for writing (\L$!\E)";
flock($fh,LOCK_EX|LOCK_NB)
|| croak "Can't write to locked config file '$filename'"
if ! ref $filename;
my $first = 1;
for my $block ( @{$array_rep_for{$hash_ref}} ) {
print {$fh} $block->serialize($first, scalar caller, $post_gap);
lib/Config/Std.pm view on Meta::CPAN
my ($filename, $hash_ref) = @_;
open my $fh, '<', $filename
or croak "Can't open config file '$filename' (\L$!\E)";
flock($fh,LOCK_SH|LOCK_NB)
|| croak "Can't read from locked config file '$filename'"
if !ref $filename;
my $text = do{local $/; <$fh>};
flock($fh,LOCK_UN) if !ref $filename;
my @config_file = Config::Std::Block->new({ name=>q{}, first=>1 });
lib/Config/Std.pm view on Meta::CPAN
You tried to read in a configuration file, but the file you specified
didn't exist. Perhaps the filepath you specified was wrong. Or maybe
your application didn't have permission to access the file you specified.
=item Can't read from locked config file '$filename'
You tried to read in a configuration file, but the file you specified
was being written by someone else (they had a file lock active on it).
Either try again later, or work out who else is using the file.
lib/Config/Std.pm view on Meta::CPAN
You tried to update or create a configuration file, but the file you
specified could not be opened for writing (for the reason given in the
parentheses). This is often caused by incorrect filepaths or lack of
write permissions on a directory.
=item Can't write to locked config file '%s'
You tried to update or create a configuration file, but the file you
specified was being written at the time by someone else (they had a file
lock active on it). Either try again later, or work out who else is
using the file.
Config-Trivial
view release on metacpan or search on metacpan
lib/Config/Trivial.pm view on Meta::CPAN
config_file => '/path/to/somewhere/else',
configuration => $settings);
The method returns true on success. If the file already exists
then it is backed up first. The write is not 'atomic' or
locked for reading in anyway. If the file cannot be written to
then it will die.
Configuration data passed by this method is only written to
file, it is not stored in the internal configuration object.
To store data in the internal use the set_configuration data
Const-Common
view release on metacpan or search on metacpan
lib/Const/Common.pm view on Meta::CPAN
sub import {
my $pkg = caller;
shift;
my %constants = @_ == 1 ? %{ $_[0] } : @_;
Data::Lock::dlock my $locked = \%constants;
{
no strict 'refs';
${ "$pkg\::_constants" } = $locked;
for my $method (qw/const constants constant_names/) {
*{ "$pkg\::$method" } = \&{ __PACKAGE__ . "::$method" };
}
push @{"$pkg\::ISA"}, ('Exporter');
push @{"$pkg\::EXPORT"}, (keys %$locked);
}
require constant;
@_ = ('constant', $locked);
goto constant->can('import');
}
sub const {
my ($pkg, $constant_name) = @_;
Control-CLI-AvayaData
view release on metacpan or search on metacpan
lib/Control/CLI/AvayaData.pm view on Meta::CPAN
ersbanner => "\x0d* Ethernet Routing Switch",
passportbanner => "\x0d* Passport 8",
pp1600banner => "\x0d* Passport 16", # The 6 ensures this does not trigger on old Accelar 1x00
vspbanner => "All Rights Reserved.\n\x0dVirtual Services Platform",
consoleLogMsg1 => "connected via console port", #On serial port: GlobalRouter SW INFO user rwa connected via console port
consoleLogMsg2 => "Blocked unauthorized ACLI access",
more1 => '----More (q=Quit, space/return=Continue)----',
more2 => '--More--',
wlan9100banner => 'Avaya Wi-Fi Access Point',
);
my %Prm = ( # Hash containing list of named parameters returned by attributes
lib/Control/CLI/AvayaData.pm view on Meta::CPAN
. '|(?:parameter|object) .+? is out of range'
. ')',
$Prm{sr} => '^('
. '\s+\^\n.+'
. '|Error : Command .+? does not exist'
. '|Config is locked by some other user'
. ')',
$Prm{trpz} => '^('
. '\s+\^\n.+'
. '|Unrecognized command:.+'
. '|Unrecognized command in this mode:.+'
Control-CLI-Extreme
view release on metacpan or search on metacpan
lib/Control/CLI/Extreme.pm view on Meta::CPAN
passportbanner => "\x0d* Passport 8",
pp1600banner => "\x0d* Passport 16", # The 6 ensures this does not trigger on old Accelar 1x00
vspbanner => "All Rights Reserved.\n\x0dVirtual Services Platform",
fabengbanner => "Extreme Networks Fabric Engine",
consoleLogMsg1 => "connected via console port", #On serial port: GlobalRouter SW INFO user rwa connected via console port
consoleLogMsg2 => "Blocked unauthorized ACLI access",
more1 => '----More (q=Quit, space/return=Continue)----',
more2 => '--More--',
wlan9100banner => 'Avaya Wi-Fi Access Point',
xos => 'ExtremeXOS',
switchEngine => 'Extreme Networks Switch Engine',
lib/Control/CLI/Extreme.pm view on Meta::CPAN
. '|(?:parameter|object) .+? is out of range'
. ')',
$Prm{sr} => '^('
. '\s+\^\n.+'
. '|Error : Command .+? does not exist'
. '|Config is locked by some other user'
. ')',
$Prm{trpz} => '^('
. '\s+\^\n.+'
. '|Unrecognized command:.+'
. '|Unrecognized command in this mode:.+'
Convert-Binary-C
view release on metacpan or search on metacpan
tests/include/pdclib/functions/_tzcode/_PDCLIB_localtime_tzset.c
tests/include/pdclib/functions/_tzcode/_PDCLIB_mktime_tzname.c
tests/include/pdclib/functions/_tzcode/_PDCLIB_timesub.c
tests/include/pdclib/functions/_tzcode/_PDCLIB_tzload.c
tests/include/pdclib/functions/_tzcode/_PDCLIB_tzparse.c
tests/include/pdclib/functions/_tzcode/_PDCLIB_tzset_unlocked.c
tests/include/pdclib/functions/_tzcode/_PDCLIB_update_tzname_etc.c
tests/include/pdclib/functions/_tzcode/Readme.txt
tests/include/pdclib/functions/ctype/isalnum.c
tests/include/pdclib/functions/ctype/isalpha.c
tests/include/pdclib/functions/ctype/isblank.c
Convert-Pheno
view release on metacpan or search on metacpan
lib/Convert/Pheno/Utils/Default.pm view on Meta::CPAN
};
# Lock the hash recursively to make it read-only
lock_hash_recurse(%DEFAULT);
# Function to get a reference to the locked default values
sub get_defaults {
return \%DEFAULT;
}
1;
Convert-UUlib
view release on metacpan or search on metacpan
uulib/config.h.in view on Meta::CPAN
* if you don't have these functions
*/
#undef strerror
#undef tempnam
/* Define if you have the fgetc_unlocked function. */
#undef HAVE_FGETC_UNLOCKED
/* Define if you have the gettimeofday function. */
#undef HAVE_GETTIMEOFDAY
Convos
view release on metacpan or search on metacpan
lib/Convos.pm view on Meta::CPAN
$redis->lrange('convos:secrets', 0, -1, $delay->begin);
$redis->getset('convos:secrets:lock' => 1, $delay->begin);
$redis->expire('convos:secrets:lock' => 5);
},
sub {
my ($delay, $secrets, $locked) = @_;
$secrets ||= $self->config->{secrets};
return $self->app->secrets($secrets) if $secrets and @$secrets;
return $self->_set_secrets if $locked;
$secrets = [md5_sum rand . $$ . time];
$self->app->secrets($secrets);
$redis->lpush('convos:secrets', $secrets->[0]);
$redis->del('convos:secrets:lock');
},
Coro-Mysql
view release on metacpan or search on metacpan
}
$DBH
}
=item $bool = Coro::Mysql::is_unblocked $DBH
Returns true iff the database handle was successfully patched for
non-blocking operations.
=cut
sub is_unblocked {
my ($DBH) = @_;
if ($DBH) {
my $mariadb = $DBH->{Driver}{Name} eq "MariaDB";
if ($mariadb or $DBH->{Driver}{Name} eq "mysql") {
Coro
view release on metacpan or search on metacpan
print "3\n";
cede; # and again
# use locking
my $lock = new Coro::Semaphore;
my $locked;
$lock->down;
$locked = 1;
$lock->up;
=head1 DESCRIPTION
For a tutorial-style introduction, please read the L<Coro::Intro>
=item Coro::on_enter BLOCK, Coro::on_leave BLOCK
These function install enter and leave winders in the current scope. The
enter block will be executed when on_enter is called and whenever the
current coro is re-entered by the scheduler, while the leave block is
executed whenever the current coro is blocked by the scheduler, and
also when the containing scope is exited (by whatever means, be it exit,
die, last etc.).
I<Neither invoking the scheduler, nor exceptions, are allowed within those
BLOCKs>. That means: do not even think about calling C<die> without an
The reason this function exists is that many event libraries (such as
the venerable L<Event|Event> module) are not thread-safe (a weaker form
of reentrancy). This means you must not block within event callbacks,
otherwise you might suffer from crashes or worse. The only event library
currently known that is safe to use without C<unblock_sub> is L<EV> (but
you might still run into deadlocks if all event loops are blocked).
Coro will try to catch you when you block in the event loop
("FATAL: $Coro::idle blocked itself"), but this is just best effort and
only works when you do not run your own event loop.
This function allows your callbacks to block by executing them in another
coro where it is safe to block. One example where blocking is handy
is when you use the L<Coro::AIO|Coro::AIO> functions to save results to
Corona
view release on metacpan or search on metacpan
lib/Corona.pm view on Meta::CPAN
Corona is a Coro based Plack web server. It uses L<Net::Server::Coro>
under the hood, which means we have coroutines (threads) for each
socket, active connections and a main loop.
Because it's Coro based your web application can actually block with
I/O wait as long as it yields when being blocked, to the other
coroutine either explicitly with C<cede> or automatically (via Coro::*
magic).
# your web application
use Coro::LWP;
Couchbase
view release on metacpan or search on metacpan
lib/Couchbase/Test/ClientSync.pm view on Meta::CPAN
my $doc = Couchbase::Document->new("GETL", "value");
$o->remove($doc); # Ensure it's gone
$o->insert($doc);
ok($o->get_and_lock($doc, {lock_duration=>10}), "Locked OK");
ok($o->unlock($doc), "Unlocked OK");
#ok($o->unlock($doc), "Unlock again fails");
#
#print Dumper($doc);
#
#is(COUCHBASE_ETMPFAIL, $doc->errnum, "Temporary failure returned for re-locking");
# Unlock while locked, but with bad CAS
my $doc2 = $doc->copy();
ok($o->get_and_lock($doc2, {lock_duration=>10}));
$doc->_cas(0xdeadbeef);
ok((!$o->unlock($doc)), "Can't unlock with stale CAS");
( run in 1.077 second using v1.01-cache-2.11-cpan-bbe5e583499 )