view release on metacpan or  search on metacpan

t/2_blocking.t  view on Meta::CPAN

while (my ($domain, $rule) = each(%rules)) {
	whois $domain, "$host:$port", sub {
		my ($info, $srv) = @_;
		is($info, $rule->{info}, "$domain info");
		ok(time()-$start < $rule->{sleep}+2, "$domain was not blocked ");
		$cv->end;
	};
}

$cv->recv;

 view release on metacpan or  search on metacpan

lib/AnyEvent/XMPP/Error/MUC.pm  view on Meta::CPAN

   my ($self) = @_;
   if ($self->{presence_error}) {
      my %mapping = (
         'not-authorized' => 'password_required',
         'forbidden'      => 'banned',
         'item-not-found' => 'room_locked',
         'not-allowed'    => 'room_not_creatable',
         'not-acceptable' => 'use_reserved_nick',
         'registration-required' => 'not_on_memberlist',
         'conflict'              => 'nickname_in_use',
         'service-unavailable'   => 'room_full',

lib/AnyEvent/XMPP/Error/MUC.pm  view on Meta::CPAN

Entering a room Inform user that he or she is banned from the room

(Condition: forbidden, Code: 403)

=item room_locked

Entering a room Inform user that the room does not exist and someone
is currently creating it.

(Condition: item-not-found, Code: 404)

 view release on metacpan or  search on metacpan

ASP.pm  view on Meta::CPAN

	$status = $response->{Status};
    }

    # X: we DESTROY in register_cleanup, but if we are filtering, and we 
    # handle a virtual request to an asp app, we need to free up the 
    # the locked resources now, or the session requests will collide
    # a performance hack would be to share an asp object created between
    # virtual requests, but don't worry about it for now since using SSI
    # is not really performance oriented anyway.
    # 
    # If we are not filtering, we let RegisterCleanup get it, since

ASP.pm  view on Meta::CPAN

a time may run, per user $Session, with sessions allowed.

Serialized requests to the session object is the Microsoft ASP way, 
but is dangerous in a production environment, where there is risk
of long-running or run-away processes.  If these things happen,
a session may be locked for an indefinite period of time.  A user
STOP button should safely quit the session however.

  PerlSetVar SessionSerialize 0

=item SessionCount

ASP.pm  view on Meta::CPAN

  $Session->{count}++;
  $Session->{count}++;
  $Session->{count}++;
  $Session->UnLock();  

This sequence causes $Session to be locked and unlocked only
1 time, instead of the 6 times that it would be locked otherwise,
2 for each increment with one to read and one to write.

Because of flushing issues with SDBM_File and DB_File databases,
each lock actually ties fresh to the database, so the performance
savings here can be considerable.  

Note that if you have SessionSerialize set, $Session is
already locked for each script invocation automatically, as if
you had called $Session->Lock() in Script_OnStart.  Thus you 
do not need to worry about $Session locking for performance.
Please read the section on SessionSerialize for more info.

=item $Session->UnLock()

API Extension. Unlocks the $Session explicitly.  If you do not call this,
$Session will be unlocked automatically at the end of the 
script.

=back

=head2 $Response Object

ASP.pm  view on Meta::CPAN

=item $Application->Lock()

Locks the Application object for the life of the script, or until
UnLock() unlocks it, whichever comes first.  When $Application
is locked, this guarantees that data being read and written to it 
will not suddenly change on you between the reads and the writes.

This and the $Session object both lock automatically upon
every read and every write to ensure data integrity.  This 
lock is useful for concurrent access control purposes.

ASP.pm  view on Meta::CPAN

Be careful to not be too liberal with this, as you can quickly 
create application bottlenecks with its improper use.

=item $Application->UnLock()

Unlocks the $Application object.  If already unlocked, does nothing.

=item $Application->GetSession($sess_id)

This NON-PORTABLE API extension returns a user $Session given
a session id.  This allows one to easily write a session manager if

ASP.pm  view on Meta::CPAN

 +$Server->HTMLEncode(\$data) API extension, now can take
  scalar ref, which can give a 5% improvement in benchmarks
  for data 100K in size.

 -Access to $Application is locked when Application_OnEnd & 
  Application_OnStart is called, creating a critical section
  for use of $Application

 ++MLDBM::Sync used now for core DBM support in Apache::ASP::State.
  This drastically simplifies/stabilizes the code in there

 view release on metacpan or  search on metacpan

Client/Client.pm  view on Meta::CPAN

					{
						$self->{_requests}->{$index}->{data} .= $buf;
					}
				} else #no data to read yet
				{
					if($! == EAGAIN()) #socket would have blocked
					{
						#keep going until there is more data on the socket
					} else
					{
						$self->{_requests}->{$index}->{status} = REQ_SUCCESS;

 view release on metacpan or  search on metacpan

lib/Apache/AppSamurai.pm  view on Meta::CPAN

=head3 I<IPFailures> C<COUNT:SECONDS>

(Defualt: undef)
Block further login attempts from IPs that send C<COUNT> failures with
no more than C<SECONDS> seconds between each subsequent failure.  Once
blocked, the block will remain in effect till at least C<SECONDS> has
elapsed since the last connection attempt.

=head3 I<AuthUnique> C<0|1>

(Default: 0)

 view release on metacpan or  search on metacpan

AuthChecker.pm  view on Meta::CPAN

            
        $r->log_error("Stats IP: $remote_ip Attempts: $failed_attempts")
            if ($debug);
        
        if ($failed_attempts >= $max_failed_attempts) {
            $r->log_error("IP: $remote_ip is blocked. ".
                          "Auth attempts: $failed_attempts");
            $ignore_this_request = 1;
        }
    } else {
        $r->log_error("IP: $remote_ip not found in DB.")

AuthChecker.pm  view on Meta::CPAN

Apache::AuthChecker - mod_perl based authentication module used to prevent
brute force attacks via HTTP authorization. It remembers IP addresses of any
user trying to authenticate for certain period of time. If user
runs out limit of failed attempts to authenticate - all his authentication
requests will be redirected to some URI (like this: /you_are_blocked.html).

Requirements: 

 1. Apache 1.3.x (2.x) with mod_perl 1.2x (2.x) enabled 
 2. IPC::Shareable perl module version 0.60 by BSUGARS. Probably it

AuthChecker.pm  view on Meta::CPAN

 AuthUserFile       - path to your passwords htpasswd-made file (REQUIRED).
 MaxFailedAttempts  - Maximum attempts we give user to mistype password 
                      (OPTIONAL, default - 8).
 RedirectURI        - URI (not URL!) to redirect attacker then he runs out 
                      attempts limit ((OPTIONAL, default - /). 
                      For example: /you_are_blocked.html


=head1 DESCRIPTION

Apache::AuthChecker - mod_perl based authentication module used to prevent
brute force attacks via HTTP authorization. It remembers IP addresses of any
user trying to authenticate for certain period of time. If user from this IP
runs out limit of failed attempts to authenticate - all his authentication
requests will be redirected to some URI (like this: /you_are_blocked.html).

=head1 PREREQUISITES

 1. Apache 1.3.x with mod_perl 1.2x enabled 
 2. IPC::Shareable perl module version 0.60 by BSUGARS. Probably it

 view release on metacpan or  search on metacpan

AuthCookiePAM.pm  view on Meta::CPAN

        return undef;
    } 
    else { # Now check if account is valid
        $res = $pamh->pam_acct_mgmt();
	if ( $res == PAM_ACCT_EXPIRED() ) {
           $r->log_error("ERROR: Account for $user is locked. Contact your Administrator.\n");
           $r->subprocess_env('AuthenReason', 'Account for $user is locked. Contact your Administrator.');
           return 'bad';
	}
	if ( $res == PAM_NEW_AUTHTOK_REQD() ) {
           $r->log_error("ERROR: PAssword for $user expired. Change Password\n");
           $r->subprocess_env('AuthenReason', 'Password Expired. Please Change your password.');

 view release on metacpan or  search on metacpan

AuthCookieURL.pm  view on Meta::CPAN

    # Or return a flag that authen_ses_key can look for
    return 'invalid:account_expired';

    # Or return a message that will be placed in a 'Reason' cookie
    return ('','User Blocked');

}    

sub authen_ses_key ($$$) {
    my ($self, $r, $session) = @_;

 view release on metacpan or  search on metacpan

lib/Apache/AxKit/Plugin/Upload.pm  view on Meta::CPAN

    $destdir = $r->document_root.'/'.$destdir if substr($destdir,0,1) ne '/';
    my $format = lc($r->dir_config('AxUploadFormat')) || 'html';
    $file = $destdir."/".$upload_id.".".$format;
    local (*FH);
    sysopen(FH,$file.".lck",O_RDWR) || return undef;
    my $unlocked = flock(FH,LOCK_EX|LOCK_NB);
    close(FH);
    return !$unlocked;
}

sub upload_handler_html {
    my ($upload, $buf, $len, $hook_data) = @_;
    my ($sizedone, $lasttime) = @$hook_data;

lib/Apache/AxKit/Plugin/Upload.pm  view on Meta::CPAN

    $location = "$destloc/$upload_id.$format";
    return OK unless $upload_id;
    return OK unless $r->method eq 'POST';
    $lock = new IO::Handle;
    sysopen($lock,$file.".lck",O_RDWR|O_CREAT) || return OK;
    my $unlocked = flock($lock,LOCK_EX|LOCK_NB);
    return OK if !$unlocked;

    $running = $upload_id;
    # from Apache::RequestNotes
    my $maxsize   = $r->dir_config('MaxPostSize') || 1024;
    my $uploads   = $r->dir_config('DisableUploads') =~ m/Off/i ? 0 : 1;

 view release on metacpan or  search on metacpan

lib/Apache/Cache.pm  view on Meta::CPAN

C<default_lock_timeout> optional, integer

Number of second(s) to wait for locks used each time manipulating data in the shared memory.

Defaults to not waiting. This means a get() - for expample - on a temporary locked
key - certainely by another process - will return a FAILED status.

=back

Additionnaly, all Apache::SharedMem parameters are also customizable. See L<Apache::SharedMem>.

 view release on metacpan or  search on metacpan

bin/mysql/addreversezone.pl  view on Meta::CPAN

    print "needed to be a number\n";
    $dbh->disconnect();
    exit 1;
}

print "Do you want the SOA to be locked (n): ";
my $answer = <>;
chomp($answer);
my $lock = 0;
$lock = 1 if $answer =~ /^y$/i;

bin/mysql/addreversezone.pl  view on Meta::CPAN

$dbh->disconnect();


sub rec_lock {
    my $lock = 0;
    print "Do you want this record to be locked (n): ";
    my $answer = <>;
    chomp($answer);
    $lock = 1 if $answer =~ /^y$/i;
    return $lock;
}

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	- Rob Bloodgood and Damyan Ivanov complained about "uninitialized value" warnings from unused
	  HTTP headers, and about pack mode "c", which generated warnings on their systems (running -w).
	  I failed to reproduce the effect of pack mode, but decided to change the mode to "C"
	  because it has been reported as a clean solution for both Rob and Damyan from one side,
	  and this should not effect the packed code (as I understand it) from the other side.
	  "Uninitialized value" warnings were blocked in accordance with the patch provided by Rob Bloodgood.
	  All changes were manually double-checked with the patch provided by Damyan Ivanov.
	- partial code revision has been done in order to prepare the further structural changes.
	  30927 Jul 20 01:09 Apache-Dynagzip-0.10.tar.gz

0.09  Sun Jan 05 01:45:00 2003

 view release on metacpan or  search on metacpan

lib/Apache/ForwardedFor.pm  view on Meta::CPAN

By using either the B<PerlSetVar> or B<PerlAddVar> directive you can
list hosts for which we will only be allowing handling of Forwarded headers from.

That means if you put one host in this list then all non-listed hosts
will be blocked.

B<Netblocks> are not supported at this time - you must supply the
full IP address.

=head2 ForwardedForDeny

 view release on metacpan or  search on metacpan

lib/Apache/HTTunnel.pm  view on Meta::CPAN

# that will be used byb the Apache children to communicate with the "keeper"
# process.
PerlSetVar		HTTunnelFifo				/var/lib/httunnel/httunnel.sock

# The maximum connect timeout that may be specified by the client. This value
# should be kept low (< 60) since that Apache children maybe be blocked up 
# to that ammount of time.
# In seconds.
PerlSetVar		HTTunnelMaxConnectTimeout	15

# The maximum read length that may be specified by the client.
# In bytes.
PerlSetVar		HTTunnelMaxReadLength		131072

# The maximum read timeout that may be specified by the client. This value
# should be kept low (< 60) since that Apache children maybe be blocked up 
# to that ammount of time.
# In seconds.
PerlSetVar		HTTunnelMaxReadTimeout		15

# Connections that remain inactive after this amount of time will be closed.

 view release on metacpan or  search on metacpan

lib/Apache/JumpByReferer.pm  view on Meta::CPAN

 http://malicious\.site\.example\.com/ http://goodbye.example.com/
 http://another\.malicious\.site/      forbidden
 http://ime\.nu/                       forbidden
 http://[^.]+\.google\.([^/]+)/        /hello_googler.html
 http://[^.]+\.yahoo\.([^/]+)/         /do_you_yahoo/?
 "Field blocked by"                    /do/not/block/the/field/

=head1 DESCRIPTION

Apache::JumpByReferer is an access phase handler of Apache + mod_perl.
You can block or let the user jump to another URL if the user was

 view release on metacpan or  search on metacpan

DBI.pm  view on Meta::CPAN

drivers may attempt to implement this method by executing
"C<select max($field) from $table>". Drivers using any approach
like this should issue a warning if C<AutoCommit> is true because
it is generally unsafe - another process may have modified the table
between your insert and the select. For situations where you know
it is safe, such as when you have locked the table, you can silence
the warning by passing C<Warn> => 0 in \%attr.

B<*> If no insert has been performed yet, or the last insert failed,
then the value is implementation defined.

 view release on metacpan or  search on metacpan

lib/Apache/SdnFw/db/install/pg.sql  view on Meta::CPAN

	login			varchar(255) unique not null,
	passwd			varchar(32) not null,
	name			varchar(255) not null,
	email			varchar(255),
	passwd_expire	timestamp,
	locked_out		boolean,
	remote_addr		inet,
	last_bad_pass	date,
	bad_pass_count	int4,
	cookie			varchar(32) unique,
	created_ts		timestamp not null default now(),

lib/Apache/SdnFw/db/install/pg.sql  view on Meta::CPAN

GRANT ALL ON employee_groups TO sdnfw;
CREATE INDEX employee_groups_employee_id ON employee_groups (employee_id);
CREATE INDEX employee_groups_group_id ON employee_groups (group_id);

CREATE VIEW employees_v_login (employee_id, login, cookie, passwd, name, email,
	password_expired, locked_out, account_expired, groups, admin) AS
SELECT e.employee_id, e.login, e.cookie, e.passwd, e.name, e.email,
	CASE WHEN passwd_expire < now() THEN TRUE ELSE NULL END as password_expired,
	e.locked_out,
	CASE WHEN expired_ts < now() THEN TRUE ELSE NULL END as account_expired,
	concat(eg.group_id) as groups,
	CASE WHEN count(g.admin) > 0 THEN TRUE ELSE NULL END as admin
FROM employees e
	LEFT JOIN employee_groups eg ON e.employee_id=eg.employee_id

 view release on metacpan or  search on metacpan

lib/Apache/Session/Counted.pm  view on Meta::CPAN

    }
    "$dir/$file";
  }
}

# Counted is locked by definition
sub release_all_locks {
  return;
}

*get_lock_manager = \&release_all_locks;

 view release on metacpan or  search on metacpan

lib/Apache/Session/Lock/File.pm  view on Meta::CPAN

Windows cannot escalate lock, so all locks will be exclusive.

release_read_lock not supported - it is not used by Apache::Session.

When deleting files, they are not locked (Win32 only).

=head1 AUTHOR

This module was written by Jeffrey William Baker <jwbaker@acm.org>.

 view release on metacpan or  search on metacpan

lib/Apache/SharedMem.pm  view on Meta::CPAN

C<wait> optional

Defined the locking status of the request. If you must get the value, and can't continue without it, set
this argument to constant WAIT, unless you can set it to NOWAIT. 

If the key is locked when you are tring to get the value, NOWAIT return status FAILURE, and WAIT hangup
until the value is unlocked. An alternative is to setup a WAIT timeout, see below.

NOTE: you needs :wait tag import: 

    use Apache::SharedMem qw(:wait)

 view release on metacpan or  search on metacpan

lib/Apache/Session/DBIBase64Store.pm  view on Meta::CPAN

	id	    CHAR(32) PRIMARY KEY,
	length	    INT,
	a_session   TEXT,
	created	    TIMESTAMP DEFAULT 'now()',
	last_update TIMESTAMP DEFAULT 'now()'
	locked_by   INT
    );


The previous SQL statement is valid for PostgreSQL. Adapt for your
specific DBMS.

 view release on metacpan or  search on metacpan

lib/Apache2/API/Status.pm  view on Meta::CPAN

        # Humour: April's fool
        # <https://en.wikipedia.org/wiki/Hyper_Text_Coffee_Pot_Control_Protocol>
        418 => "I'm a teapot",
        421 => "Misdirected Request",
        422 => "Unprocessable entity!",
        423 => "Resource locked!",
        424 => "Failed dependency!",
        425 => "Too early!",
        426 => "Upgrade Required!",
        428 => "Precondition Required",
        429 => "Too many requests!",

lib/Apache2/API/Status.pm  view on Meta::CPAN

    414 => "request_uri_too_large",
    415 => "unsupported_media_type",
    416 => "range_not_satisfiable",
    417 => "expectation_failed",
    422 => "unprocessable_entity",
    423 => "locked",
    424 => "failed_dependency",
    425 => "too_early",
    426 => "upgrade_required",
    429 => "too_many_requests",
    431 => "request_header_fields_too_large",

lib/Apache2/API/Status.pm  view on Meta::CPAN

=head2 HTTP_LOCKED (423)

See L<rfc 4918 on WebDAV|https://tools.ietf.org/html/rfc4918>

This is returned under the WebDav protocol when one tries to make change to a locked resource.

=head2 HTTP_FAILED_DEPENDENCY (424)

See L<rfc 4918 on WebDAV|https://tools.ietf.org/html/rfc4918>

lib/Apache2/API/Status.pm  view on Meta::CPAN

This status code has been chosen on purpose, for its relation with the book L<Fahrenheit 451|https://en.wikipedia.org/wiki/Fahrenheit_451> from Ray Bradbury. In his book, the central theme is the censorship of literature. The book title itself "Fahre...

For example:

    HTTP/1.1 451 Unavailable For Legal Reasons
    Link: <https://example.org/legal>; rel="blocked-by"
    Content-Type text/plain
    Content-Length: 48

    You are prohibited from accessing this resource.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	* First release

0.20	2023/01/03

	* Fiddle with sqlite autocommit to possibly resolve a locked db issue

	* Pass a copy of the cas attributes data structure to consumers so
	  they can't change the master session values

0.30	2024/11/15

 view release on metacpan or  search on metacpan

lib/Apache2/SSI/SharedMem.pm  view on Meta::CPAN

    $self->{size}       = SHM_BUFSIZ;
    $self->{_init_strict_use_sub} = 1;
    $self->SUPER::init( @_ ) || return;
    $self->{addr}       = undef();
    $self->{id}         = undef();
    $self->{locked}     = 0;
    $self->{owner}      = $$;
    $self->{removed}    = 0;
    $self->{semid}      = undef();
    return( $self );
}

lib/Apache2/SSI/SharedMem.pm  view on Meta::CPAN

    my $type = shift( @_ );
    my $timeout = shift( @_ );
    # $type = LOCK_EX if( !defined( $type ) );
    $type = LOCK_SH if( !defined( $type ) );
    return( $self->unlock ) if( ( $type & LOCK_UN ) );
    return( 1 ) if( $self->locked & $type );
    $timeout = 0 if( !defined( $timeout ) || $timeout !~ /^\d+$/ );
    # If the lock is different, release it first
    $self->unlock if( $self->locked );
    my $semid = $self->semid ||
        return( $self->error( "No semaphore id set yet." ) );
    local $@;
    # try-catch
    my $rv = eval

lib/Apache2/SSI/SharedMem.pm  view on Meta::CPAN

    {
        return( $self->error( "Unable to set a lock: $@" ) );
    }
    if( $rv )
    {
        $self->locked( $type );
    }
    else
    {
        return( $self->error( "Failed to set a lock on semaphore id \"$semid\": $!" ) );
    }
    return( $self );
}

sub locked { return( shift->_set_get_scalar( 'locked', @_ ) ); }

sub mode { return( shift->_set_get_scalar( 'mode', @_ ) ); }

sub op
{

lib/Apache2/SSI/SharedMem.pm  view on Meta::CPAN

sub supported { return( $SYSV_SUPPORTED ); }

sub unlock
{
    my $self = shift( @_ );
    return( 1 ) if( !$self->locked );
    my $semid = $self->semid;
    return( $self->error( "No semaphore set yet. You must open the shared memory first to unlock semaphore." ) ) if( !length( $semid ) );
    my $type = $self->locked | LOCK_UN;
    $type ^= LOCK_NB if( $type & LOCK_NB );
    if( defined( $self->op( @{$SEMOP_ARGS->{ $type }} ) ) )
    {
        $self->locked( 0 );
    }
    return( $self );
}

sub write

 view release on metacpan or  search on metacpan

lib/Apache2/xForwardedFor.pm  view on Meta::CPAN

		if ( exists $ips_deny{$remote_ip} ) {
			$_accept= -1;
		}

	if 	( $_accept < 0 ) {
		DEBUG && print STDERR "\n ip in blocked list";
		return FORBIDDEN;
	}
	elsif ( !$_accept && $require_header) {
		DEBUG && print STDERR "\n ip not passed, and header required";
		return FORBIDDEN;

 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

lib/App/AltSQL.pm  view on Meta::CPAN

All of the shells that we used on a daily basis allow you to abandon the half-written statement on the prompt by typing Ctrl-C.  Spending all day in shells, you expect this behavior to be consistent, but you do this in mysql and you will be thrown to...

=item Wide output wraps

We are grateful that mysql at least uses ASCII art for table formatting (unlike C<sqlite3> for some reason).  But there are some tables that I work with that have many columns, with long names (it's often easier to keep adding columns to a table over...

Suffice it to say, it's a much better experience if, just like with C<git diff>, wide output is left wide, and you are optionally able to scroll horizontally with your arrow keys like you wanted in the first place.

=item Color

 view release on metacpan or  search on metacpan

lib/BS/Ext/User.pm  view on Meta::CPAN

#method $filter_output : common {
#    ...;
#};

#multi sub is_locked ($pacman_dir = "") {
#  BS::Ext::pacman->sync
#}

 view release on metacpan or  search on metacpan

lib/App/Base/Daemon.pm  view on Meta::CPAN

Writes PID of the daemon into specified file, by default writes pid into /var/run/__PACKAGE__.pid

=head2 --no-pid-file

Do not write pid file, and do not check if it is exist and locked.

=head2 --no-warn

Do not produce warnings, silent mode

lib/App/Base/Daemon.pm  view on Meta::CPAN

            option_type   => 'string',
            documentation => "Use specified file to save PID",
        },
        {
            name          => 'no-pid-file',
            documentation => "Do not check if pidfile exists and locked",
        },
        {
            name          => 'user',
            documentation => "User to run as",
        },