locked results from the CPAN

Changes view on Meta::CPAN

    - %events bootstrap loop is now capped at SHM_CREATE_RETRIES (100)
      attempts and croaks with the last underlying error instead of
      spinning forever when shmget fails persistently
    - All reads/writes to %events now go through _events_read (LOCK_SH) /
      _events_write (LOCK_EX) to synchronize access across processes
    - events() now returns a read-locked deep copy snapshot; mutations to
      the returned hashref do not affect the live %events
    - info() now returns a shallow copy snapshot, consistent with events()
    - _rand_shm_key() now generates hex strings within the 32-bit SHM key
      range (0x0â€“0x7FFFFFFF), replacing the 12 random letters which also
      removes the srand()-in-a-loop pattern

    - Fix shared memory leak on SIGINT/SIGTERM: install signal handlers
      that run _end() cleanup before re-raising; _end() now unconditionally
      stops children and removes protected segments instead of skipping
      when _event_count > 0
    - Fix _end() SIGALRM deadlock: clear SA_RESTART via POSIX::sigaction so
      the alarm actually interrupts blocked semop(); split the single 2s alarm
      into per-phase evals so each cleanup step runs even when an earlier one
      times out; add @all_pids fallback so children are killed even when the
      %events read-lock is stuck
    - Add 'error' and 'waiting' fields to events() and info() snapshots
    - Add wait() method that polls until the event is dormant (optional

view all matches for this distribution

Async-Interrupt

3 results

Interrupt.pm view on Meta::CPAN


Calls the callback if the object is pending.

This method does not need to be called normally, as it will be invoked
automatically. However, it can be used to force handling of outstanding
interrupts while the object is blocked.

One reason why one might want to do that is when you want to switch
from asynchronous interruptions to synchronous one, using e.g. an event
loop. To do that, one would first C<< $async->block >> the interrupt
object, then register a read watcher on the C<pipe_fileno> that calls C<<

view all matches for this distribution

Async-Microservice

1 match

root/static/edit.html view on Meta::CPAN

  }
  </script>

  <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="position:absolute;width:0;height:0">
    <defs>
      <symbol viewBox="0 0 20 20" id="unlocked">
            <path d="M15.8 8H14V5.6C14 2.703 12.665 1 10 1 7.334 1 6 2.703 6 5.6V6h2v-.801C8 3.754 8.797 3 10 3c1.203 0 2 .754 2 2.199V8H4c-.553 0-1 .646-1 1.199V17c0 .549.428 1.139.951 1.307l1.197.387C5.672 18.861 6.55 19 7.1 19h5.8c.549 0 1.428-.13...
      </symbol>

      <symbol viewBox="0 0 20 20" id="locked">
        <path d="M15.8 8H14V5.6C14 2.703 12.665 1 10 1 7.334 1 6 2.703 6 5.6V8H4c-.553 0-1 .646-1 1.199V17c0 .549.428 1.139.951 1.307l1.197.387C5.672 18.861 6.55 19 7.1 19h5.8c.549 0 1.428-.139 1.951-.307l1.196-.387c.524-.167.953-.757.953-1.306V9.199...
      </symbol>

      <symbol viewBox="0 0 20 20" id="close">
        <path d="M14.348 14.849c-.469.469-1.229.469-1.697 0L10 11.819l-2.651 3.029c-.469.469-1.229.469-1.697 0-.469-.469-.469-1.229 0-1.697l2.758-3.15-2.759-3.152c-.469-.469-.469-1.228 0-1.697.469-.469 1.228-.469 1.697 0L10 8.183l2.651-3.031c.469-.46...

view all matches for this distribution

Async-Redis

10 results


# Convert a raw RESP pub/sub frame into a message hashref and deliver it.
# In callback mode, invokes _on_message via _invoke_user_callback and
# returns its result (which may be a Future for consumer-side backpressure).
# In iterator mode, queues the message into _pending_messages and signals
# _message_waiter so a blocked next() can wake up.
#
# Non-message frames (subscribe confirmations, etc.) return undef and
# take no action â€” the driver loop will read the next frame.
sub _dispatch_frame {
    my ($self, $frame) = @_;

        type    => $msg->{type},
    };
}

# Intentional teardown: marks the subscription closed and wakes any
# blocked next() with undef. Clears the parent _subscription slot
# with an identity guard so a stale _close cannot evict a newer
# subscription object that reused the same slot.
sub _close {
    my ($self) = @_;
    return if $self->{_closed};

        $f->cancel unless $f->is_ready;
    }
}

# Unrecoverable failure: marks the subscription closed with a typed
# error. Any blocked next() will die with that error. The error is
# preserved for callers who call next() after the fact.
# In callback mode, fires on_error if registered; dies otherwise.
sub _fail_fatal {
    my ($self, $typed_error) = @_;
    return if $self->{_closed};

documented here for maintainers.

=head2 _close

Intentional teardown. Marks the subscription closed and wakes any
blocked C<next()> with C<undef>. Clears the parent C<_subscription>
slot on the L<Async::Redis> object with an identity guard â€” a stale
C<_close> call from an earlier subscription object cannot evict a newer
one that has since taken the slot.

=head2 _fail_fatal($typed_error)

Unrecoverable failure. Marks the subscription closed with a typed error
object. Any blocked C<next()> call will C<die> with that error. The
error is preserved for callers who call C<next()> after the fact.
Routes through C<_close>'s identity guard for parent-slot clearing.

=head2 _pause_for_reconnect

view all matches for this distribution

Async-Template

2 results

lib/Async/Template.pm view on Meta::CPAN

      # may be redefined at the process() function
      DONE => sub{ my $output = shift; $cv->send; },
   }) || die Async::Template->error();


   # single blocked process

   my $tt = Async::Template->new({}) || die Async::Template->error();
   $tt->process($template, $vars, \$output)


   # nonblocked multiple procesess

   my $cv = AnyEvent->condvar;
   $cv->begin;
   my $tt2 = Async::Template->new({
      DONE => sub{ my $output = shift; $cv->end; },

view all matches for this distribution

Async-Trampoline

8 results

lib/Async/Trampoline/Scheduler.pm view on Meta::CPAN


=head2 enqueue

    $scheduler->enqueue($task)

    $scheduler->enqueue($task => @blocked)

Add a I<$task> to the runnable queue.

B<$task>:
A task to be scheduled at some point in the future.

B<@blocked>:
Any number of tasks that depend on the I<$task>.
The blocked tasks will be added to the runnable queue
once the I<$task> is completed.

=head2 dequeue

    ($task) = $scheduler->dequeue

view all matches for this distribution

At

15 results

share/lexicons/app/bsky/actor/defs.json view on Meta::CPAN

        "muted": { "type": "boolean" },
        "mutedByList": {
          "type": "ref",
          "ref": "app.bsky.graph.defs#listViewBasic"
        },
        "blockedBy": { "type": "boolean" },
        "blocking": { "type": "string", "format": "at-uri" },
        "blockingByList": {
          "type": "ref",
          "ref": "app.bsky.graph.defs#listViewBasic"
        },

view all matches for this distribution

Attribute-Handlers-Clean

1 match

lib/Attribute/Handlers/Clean.pm view on Meta::CPAN

    my ($class) = $AUTOLOAD =~ m/(.*)::/g;
    $AUTOLOAD =~ m/_ATTR_(.*?)_(.*)/ or croak "Can't locate class method '$AUTOLOAD' via package '$class'";
    croak "Attribute handler '$2' doesn't handle $1 attributes";
}

my $builtin = qr/lvalue|locked|unique|shared/; # Method left out on purpose.


sub _gen_handler_AH_() {
    sub {
        _resolve_lastattr if _delayed_name_resolution;

view all matches for this distribution

Attribute-Handlers

2 results

lib/Attribute/Handlers.pm view on Meta::CPAN

	croak "Attribute handler '$2' doesn't handle $1 attributes";
}

my $builtin = $] ge '5.027000'
    ? qr/lvalue|method|shared/
    : qr/lvalue|method|locked|shared|unique/;

sub _gen_handler_AH_() {
	return sub {
	    _resolve_lastattr if _delayed_name_resolution;
	    my ($pkg, $ref, @attrs) = @_;

view all matches for this distribution

Audio-LibSampleRate

1 match

libsamplerate/Cfg/ltmain.sh view on Meta::CPAN

    fi

    $opt_dry_run || {
      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"

      # Unlock the critical section if it was locked
      if test no != "$need_locks"; then
	removelist=$lockfile
        $RM "$lockfile"
      fi
    }

view all matches for this distribution

Audio-Play-MPG123

1 match

mpg123/audio_nas.c view on Meta::CPAN

                              AuUnlimitedSamples,  /* num samples */
                              0,                   /* num actions */
                              NULL);               /* actions */
    AuSetElements(info.aud,                        /* Au server */
                  info.flow,                       /* flow ID */
                  AuTrue,                          /* clocked */
                  2,                               /* num elements */
                  elements,                        /* elements */
                  NULL);                           /* return status */

    AuRegisterEventHandler(info.aud,               /* Au server */

view all matches for this distribution

Audio-StreamGenerator

1 match

lib/Audio/StreamGenerator.pm view on Meta::CPAN

    my $streamer_sub = $streamer->get_streamer(0.5);

    $loop->recurring(0.05 => $streamer_sub);
    $loop->start;

Note: event loop will be blocked for up to 0.5 seconds every time the timer is done. The timer/streamer ratio should be sizeable enough for the loop to run smoothly, including the mixing process. This may vary depending on the speed of the machine wh...

=head2 skip

    $streamer->skip();

view all matches for this distribution

Audio

1 match

Play/config/mmsystem.h view on Meta::CPAN

#ifndef _WIN32_VXD
typedef HWAVEIN *LPHWAVEIN;
typedef HWAVEOUT *LPHWAVEOUT;
#endif
typedef struct wavehdr_tag {
    LPSTR       lpData;                 /* pointer to locked data buffer */
    DWORD       dwBufferLength;         /* length of data buffer */
    DWORD       dwBytesRecorded;        /* used for input only */
    DWORD       dwUser;                 /* for client's use */
    DWORD       dwFlags;                /* assorted flags (see defines) */
    DWORD       dwLoops;                /* loop control counter */

view all matches for this distribution

Audit-DBI-TT2

4 results

examples/css/jquery-ui-1.10.2.custom.css view on Meta::CPAN

.ui-icon-suitcase { background-position: -112px -96px; }
.ui-icon-comment { background-position: -128px -96px; }
.ui-icon-person { background-position: -144px -96px; }
.ui-icon-print { background-position: -160px -96px; }
.ui-icon-trash { background-position: -176px -96px; }
.ui-icon-locked { background-position: -192px -96px; }
.ui-icon-unlocked { background-position: -208px -96px; }
.ui-icon-bookmark { background-position: -224px -96px; }
.ui-icon-tag { background-position: -240px -96px; }
.ui-icon-home { background-position: 0 -112px; }
.ui-icon-flag { background-position: -16px -112px; }
.ui-icon-calendar { background-position: -32px -112px; }

view all matches for this distribution

Auth-ActiveDirectory

1 match

lib/Auth/ActiveDirectory.pm view on Meta::CPAN

    '531' => { error => 'not permitted to logon at this workstation' },
    '532' => { error => 'password expired' },
    '533' => { error => 'data 533' },
    '701' => { error => 'account expired' },
    '773' => { error => 'user must reset password' },
    '775' => { error => 'user account locked' },
    '534' => {
        error       => 'account disabled',
        description => 'The user has not been granted the requested logon type at this machine'
    },
};

view all matches for this distribution

Authen-Krb5-Admin

1 match

Admin.pm view on Meta::CPAN

The period after which the bad preauthentication count will be reset.

=item * pw_lockout_duration {KADM5_PW_LOCKOUT_DURATION}

The period in which lockout is enforced; a duration of zero means that
the principal must be manually unlocked.

=item * pw_min_classes {KADM5_PW_MIN_CLASSES}

Number (between 1 and 5, inclusive) of required character classes
represented in a password

view all matches for this distribution

Authen-PluggableCaptcha

2 results

lib/Authen/PluggableCaptcha/Tutorial.pm view on Meta::CPAN

	my 	$captcha_embed= "<img src="/path/to/captcha/handler?section=registration" />";

then set up a sub / handler to generate the captcha on a url mapping

in this example, the captcha generator is in a central location -- /service/captcha/ -- so we supply the section name as a query arg.  
if the captcha generator were locked into a page, then you could just hardcode the section name
	
	sub render_image {
		my 	( $self )= @_ ;
	
		my 	$sectionName= $self->{'PageUser'}{'ApacheRequest'}->param('section');

lib/Authen/PluggableCaptcha/Tutorial.pm view on Meta::CPAN

  
  in my setup:

    $seed= $url . $session{'id'}
    
  That makes sure that only 1 captcha is made for a certain URL and a certain session_id ( locked to that time - since the time is used to create the public key,  something 1 second later or earlier would be different )
  
  The drawback is that anyone with the same session_id (which can be spoofed / hijacked) can use that same captcha url for the time window
  
  If you're comfortable storing session data, this might be better for you:

view all matches for this distribution

Authen-Radius

2 results

raddb/dictionary.shiva view on Meta::CPAN

VALUE	Shiva-Disconnect-Reason Dialback		6
VALUE	Shiva-Disconnect-Reason Virtual-Connection	7
VALUE	Shiva-Disconnect-Reason Bandwidth-On-Demand	8
VALUE	Shiva-Disconnect-Reason Failed-Authentication	9
VALUE	Shiva-Disconnect-Reason Preempted		10
VALUE	Shiva-Disconnect-Reason Blocked			11
VALUE	Shiva-Disconnect-Reason Tariff-Management	12
VALUE	Shiva-Disconnect-Reason Backup			13

#	Shiva Function Values

view all matches for this distribution

Authen-SimplePam

1 match

SimplePam.pm view on Meta::CPAN

  elsif ( $result == 5  ) { return "user unknown"                            }
  elsif ( $result == 6  ) { return "maximum tries"                           }
  elsif ( $result == 7  ) { return "unknown error"                           }
  elsif ( $result == 8  ) { return "authentication error"                    }
  elsif ( $result == 9  ) { return "authentication information cannot be recovered" }
  elsif ( $result == 10 ) { return "authentication locked busy"              }
  elsif ( $result == 11 ) { return "authentication aging disable"            }
  elsif ( $result == 12 ) { return "permission denied"                       }
  elsif ( $result == 13 ) { return "try again"                               }
  elsif ( $result == 14 ) { return "dlopen error"                            }
  elsif ( $result == 15 ) { return "symbol not found"                        }

view all matches for this distribution

Authen-TacacsPlus

1 match

tacpluslib/utils.c view on Meta::CPAN


/* Lock a file descriptor using fcntl. Returns 1 on successfully
   acquiring the lock. The lock dies when we close the file, so
   there's currently no separate unlock procedure.

   Note that if the locked file is on an NFS-mounted partition, you
   are at the mercy of SUN's lockd, which is probably a bad idea */

int
tac_lockfd(filename,lockfd)
char *filename;

view all matches for this distribution

AutoLoader

2 results

lib/AutoSplit.pm view on Meta::CPAN

sub test6       { return join ":", __FILE__,__LINE__; }
package Yet::Another::AutoSplit;
sub testtesttesttest4_1 ($)  { "another test 4\n"; }
sub testtesttesttest4_2 ($$) { "another duplicate test 4\n"; }
package Yet::More::Attributes;
sub test_a1 ($) : locked :locked { 1; }
sub test_a2 : locked { 1; }

view all matches for this distribution

AxKit2

1 match

plugins/aio/uri_to_file view on Meta::CPAN

    my ($volume, $dir, $file) = splitpath($self->config->docroot, 1);
    my @path = (splitdir($dir),split(/\//,$uri));

    my $i = -1;

    # save these so they get locked in for the closure.
    my $client   = $self->client;
    my $config   = $self->config;
    my $dirindex = $self->config('dirindex');

# $self->log(LOGCRIT, __LINE__ . " ...");

view all matches for this distribution

Azure-AD-Auth

1 match

lib/Azure/AD/DeviceLogin.pm view on Meta::CPAN

is normally sent in the Authentication header of HTTPS requests as a Bearer token.

The call to access_token will start the Device Login flow, which involves transmitting
a message to the user (see message_handler attribute). The user will have to visit a 
URL with a browser, insert the code in the message, authorize the application, and then 
the authentication will proceed. Meanwhile the call to access_code will be blocked,
awaiting the user to complete the flow. Once the user completes the instructions the access_code
will be returned.

The access_token is cached in the object as long as it's valid, so subsequent calls
to access_token will return the appropriate token without reauthenticating to Azure AD.

view all matches for this distribution

B-C

1 match

ramblings/5.22-problems.md view on Meta::CPAN

[here](https://github.com/perl11/cperl/commit/309dc8e9649acda055a86514ca334bdfea31c0f8)
and for perlall
[here](https://github.com/rurban/App-perlall/commit/4907abb6dfa86bc5d2572d523e75462a18705aec),
and my perlbug report did not get through.

I can only guess that p5p blocked me again, because they didn't like
me to call them incompetent.  Blocking bug reports and fixes is worse
than just incompetence, but I got used to that recently. They blocked
my simple fix for the horrific double-readonly system, and they
proudly announced last week some
[new optimization](http://perl5.git.perl.org/perl.git/commitdiff/230ee21f3e366901ce5769d324124c522df7ce8a)
regarding faster arithmetic, but didn't have a look into
[my fast arithmetic optimizations](https://github.com/perl11/cperl/commit/8b6139a5cbb3307067daf51503fdee2771595afb)

view all matches for this distribution

B-DeparseTree

1 match

lib/B/DeparseTree/TreeMain.pm view on Meta::CPAN

	$proto .= "(". $cv->PV . ")";
    }
    if ($cv->CvFLAGS & (CVf_METHOD|CVf_LOCKED|CVf_LVALUE)) {
        $proto .= ":";
        $proto .= " lvalue" if $cv->CvFLAGS & CVf_LVALUE;
        $proto .= " locked" if $cv->CvFLAGS & CVf_LOCKED;
        $proto .= " method" if $cv->CvFLAGS & CVf_METHOD;
    }

    local($self->{'curcv'}) = $cv;
    local($self->{'curcvlex'});

view all matches for this distribution

B-Hooks-AtRuntime-OnlyCoreDependencies

1 match

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

view all matches for this distribution

B-Hooks-AtRuntime

1 match

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

view all matches for this distribution

BATsh

4 results

lib/BATsh/SH.pm view on Meta::CPAN

}

# _sh_store_scalar(NAME, VALUE): the single choke point for a plain scalar
# assignment.  Honours the readonly attribute (refused, status source
# returns 0) and the integer attribute (VALUE evaluated as arithmetic).
# Returns 1 when the value was stored, 0 when a readonly variable blocked
# it.  All the ordinary assignment paths (VAR=val, prefix VAR=val cmd,
# export VAR=val) funnel through here so the attributes are enforced
# uniformly.
sub _sh_store_scalar {
    my ($name, $val) = @_;

view all matches for this distribution

BDB

3 results