view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

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

ppport.h  view on Meta::CPAN

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

ppport.h  view on Meta::CPAN

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

 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)

 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")

 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")

 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 {

 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

 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.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

 - Some inefficiency cleaned up.

0.07 2004/01/25

 - inetd.conf is locked.

0.03 2004/01/21

 - bin/inetd.pl added.

 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

 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

 view release on metacpan or  search on metacpan

Simple.pm  view on Meta::CPAN

  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;

 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.

 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

 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) = @_;

 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:.+'

 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:.+'

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

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

 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;

 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

 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');
    },

 view release on metacpan or  search on metacpan

Mysql.pm  view on Meta::CPAN

   }

   $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") {

 view release on metacpan or  search on metacpan

Coro.pm  view on Meta::CPAN

  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>

Coro.pm  view on Meta::CPAN

=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

Coro.pm  view on Meta::CPAN

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

 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;

 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");

 view release on metacpan or  search on metacpan

lib/Courier/Filter/Module/SPFout.pm  view on Meta::CPAN

=item B<trusting>

I<Disabled>.  Since I<outbound> SPF checking, as opposed to I<inbound> SPF
checking, is applied to trusted (authenticated) messages only, setting this
module to be B<trusting> does not make sense.  This property is thus locked to
B<false>.  Also see the description of
L<< Courier::Message's C<trusted> property | Courier::Message/trusted >>.

=item B<match_on>

 view release on metacpan or  search on metacpan

t/data/stress-test/mbox_mime_virus-mcgraw-hill.txt  view on Meta::CPAN

We have received a message with your e-mail address (tomcat-user@jakarta.apache.org) as the sender, with the following as the Subject:
"TEST" .

Due to security standards maintained on the McGraw-Hill corporate network, one or more of the attachments contained in your
message fall into the category of files that could potentially contain harmful or malicious coding such as viruses. Therefore
the entire message was blocked and NOT delivered.

If you are in fact the sender of this message, please contact the intended recipient(s):
stan@mcgrawhill.ca to make alternate arrangements for delivering the attachments. If you did NOT send the message, no
further action is required on your part.

 view release on metacpan or  search on metacpan

t/12_blessed.t  view on Meta::CPAN

my $o5 = bless \(my $dummy4 = ""), "Verbatim"; # with stringification empty string result

if (eval 'require Hash::Util') {
  if ($Hash::Util::VERSION > 0.05) {
    Hash::Util::lock_ref_keys($o1);
    print "# blessed hash is locked\n";
  }
  else {
    Hash::Util::lock_hash($o1);
    print "# hash is locked\n";
  }
}
else {
  print "# locked hashes are not supported\n";
};

my $js = Cpanel::JSON::XS->new;

eval { $js->encode ($o1) }; ok ($@ =~ /allow_blessed/, 'error no allow_blessed');

 view release on metacpan or  search on metacpan

include/cryptoki/pkcs11t.h  view on Meta::CPAN

 * incorrect user login PIN has been entered at least once
 * since the last successful authentication. */
#define CKF_USER_PIN_COUNT_LOW       0x00010000

/* CKF_USER_PIN_FINAL_TRY if new for v2.10. If it is true,
 * supplying an incorrect user PIN will it to become locked. */
#define CKF_USER_PIN_FINAL_TRY       0x00020000

/* CKF_USER_PIN_LOCKED if new for v2.10. If it is true, the
 * user PIN has been locked. User login to the token is not
 * possible. */
#define CKF_USER_PIN_LOCKED          0x00040000

/* CKF_USER_PIN_TO_BE_CHANGED if new for v2.10. If it is true,
 * the user PIN value is the default value set by token

include/cryptoki/pkcs11t.h  view on Meta::CPAN

 * incorrect SO login PIN has been entered at least once since
 * the last successful authentication. */
#define CKF_SO_PIN_COUNT_LOW         0x00100000

/* CKF_SO_PIN_FINAL_TRY if new for v2.10. If it is true,
 * supplying an incorrect SO PIN will it to become locked. */
#define CKF_SO_PIN_FINAL_TRY         0x00200000

/* CKF_SO_PIN_LOCKED if new for v2.10. If it is true, the SO
 * PIN has been locked. SO login to the token is not possible.
 */
#define CKF_SO_PIN_LOCKED            0x00400000

/* CKF_SO_PIN_TO_BE_CHANGED if new for v2.10. If it is true,
 * the SO PIN value is the default value set by token

 view release on metacpan or  search on metacpan

lib/Crypt/Diceware/Wordlist/Common.pm  view on Meta::CPAN

  financier finery finesse finger finish finisher finite fireman fireplace
  fires firm first fiscal fishbone fishery fishes fissure fisting fit fitful
  fitted fix fixes fixture fizzles fjord flag flagpole flagrant flags flame
  flamed flanker flare flared flash flasher flatboat flaunted flavor flawless
  fleck flection fledged fledgling fleece fleeting fleshing flexible flicked
  flicks flimsy flippant flirts flit floating flocked floe flogged floods
  floozie flora floral florid florist flout flowing flu fluctuate flue fluent
  fluential fluffier fluidly fluke flunk flush fluted flutist flux fly flyer
  focal focally focus foe fog foggy foible foist folds foliage folic folio
  fond fondle fondly fondness foolery foolishly foolproof footed foothill
  footless footloose footprint footrest foppery foppish foray forby forces

 view release on metacpan or  search on metacpan

lib/Crypt/HSM/Slot.pm  view on Meta::CPAN

True if an incorrect user login PIN has been entered at least once since the last successful authentication.

=item * C<user-pin-final-try>

True if supplying an incorrect user PIN will cause it to become locked.

=item * C<user-pin-locked>

True if the user PIN has been locked. User login to the token is not possible.

=item * C<user-pin-to-be-changed>

True if the user PIN value is the default value set by token initialization or manufacturing, or the PIN has been expired by the card.

lib/Crypt/HSM/Slot.pm  view on Meta::CPAN

True if an incorrect SO login PIN has been entered at least once since the last successful authentication.

=item * C<so-pin-final-try>

True if supplying an incorrect SO PIN will cause it to become locked.

=item * C<so-pin-locked>

True if the SO PIN has been locked. SO login to the token is not possible.

=item * C<so-pin-to-be-changed>

True if the SO PIN value is the default value set by token initialization or manufacturing, or the PIN has been expired by the card.