view release on metacpan or  search on metacpan

include/ppport.h  view on Meta::CPAN

GETPWENT_R_PROTO|5.008000|5.008000|Vn
getpwnam|5.009000||Viu
GETPWNAM_R_HAS_BUFFER|5.008000||Viu
GETPWNAM_R_HAS_PTR|5.008000||Viu
GETPWNAM_R_PROTO|5.008000|5.008000|Vn
getpwuid|5.009000||Viu
GETPWUID_R_HAS_PTR|5.008000||Viu
GETPWUID_R_PROTO|5.008000|5.008000|Vn
get_quantifier_value|5.033006||Viu
get_re_arg|||xciu
get_re_gclass_nonbitmap_data|5.031011||Viu

include/ppport.h  view on Meta::CPAN

KEY_getprotobyname|5.003007||Viu
KEY_getprotobynumber|5.003007||Viu
KEY_getprotoent|5.003007||Viu
KEY_getpwent|5.003007||Viu
KEY_getpwnam|5.003007||Viu
KEY_getpwuid|5.003007||Viu
KEY_getservbyname|5.003007||Viu
KEY_getservbyport|5.003007||Viu
KEY_getservent|5.003007||Viu
KEY_getsockname|5.003007||Viu
KEY_getsockopt|5.003007||Viu

 view release on metacpan or  search on metacpan

build/lib/src/dotdir.c  view on Meta::CPAN

            return -1;
        }

        struct passwd pwd;
        struct passwd *result = NULL;
        int err = getpwuid_r(geteuid(), &pwd, pwbuf, pwbufsize, &result);
        if (err != 0)
        {
            errno = err;
            goto cleanup;
        }

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

GETPWENT_R_PROTO|5.008000|5.008000|Vn
getpwnam|5.009000||Viu
GETPWNAM_R_HAS_BUFFER|5.008000||Viu
GETPWNAM_R_HAS_PTR|5.008000||Viu
GETPWNAM_R_PROTO|5.008000|5.008000|Vn
getpwuid|5.009000||Viu
GETPWUID_R_HAS_PTR|5.008000||Viu
GETPWUID_R_PROTO|5.008000|5.008000|Vn
get_quantifier_value|5.033006||Viu
get_re_arg|||xciu
get_re_gclass_nonbitmap_data|5.031011||Viu

ppport.h  view on Meta::CPAN

KEY_getprotobyname|5.003007||Viu
KEY_getprotobynumber|5.003007||Viu
KEY_getprotoent|5.003007||Viu
KEY_getpwent|5.003007||Viu
KEY_getpwnam|5.003007||Viu
KEY_getpwuid|5.003007||Viu
KEY_getservbyname|5.003007||Viu
KEY_getservbyport|5.003007||Viu
KEY_getservent|5.003007||Viu
KEY_getsockname|5.003007||Viu
KEY_getsockopt|5.003007||Viu

 view release on metacpan or  search on metacpan

lib/Net/Amazon/MechanicalTurk/OSUtil.pm  view on Meta::CPAN

sub homeDirectory {
    my $homeDir;
    eval {
        # Looks up home directory for effective user id
        $homeDir = [getpwuid($>)]->[7];
    };
    if ($@) {
        # getpwuid doesn't seem to work on ActivePerl
        # Try using the Windows API to get the home directory.
        eval {
            require Win32;
            $homeDir = Win32::GetFolderPath(Win32::CSIDL_PROFILE());
        };

 view release on metacpan or  search on metacpan

lib/Net/Async/IRC.pm  view on Meta::CPAN

{
   my $self = shift;
   $self->SUPER::_init( @_ );

   $self->{user} = $ENV{LOGNAME} ||
      ( HAVE_MSWIN32 ? Win32::LoginName() : getpwuid($>) );

   our $VERSION;
   $self->{realname} = "Net::Async::IRC client $VERSION";
}

lib/Net/Async/IRC.pm  view on Meta::CPAN

=item realname => STRING

Connection details. See also C<connect>, C<login>.

If C<user> is not supplied, it will default to either C<$ENV{LOGNAME}> or the
current user's name as supplied by C<getpwuid()> or C<Win32::LoginName()>.

If unconnected, changing these properties will set the default values to use
when logging in.

If logged in, changing the C<nick> property is equivalent to calling

 view release on metacpan or  search on metacpan

lib/Net/Connection.pm  view on Meta::CPAN

	if (
		$args{'uid_resolve'} &&
		defined( $self->{'uid'} )
		){
		eval{
			my @pwline=getpwuid( $self->{'uid'} );
			if ( defined( $pwline[0] ) ){
				$self->{'username'}=$pwline[0];
			}
		}
	}elsif (

 view release on metacpan or  search on metacpan

_Deparsed_XSubs.pm  view on Meta::CPAN

  sub getpayload;
  sub getpgrp;
  sub getpid;
  sub getppid;
  sub getpwnam;
  sub getpwuid;
  sub gets;
  sub getuid;
  sub gmtime;
  sub hypot;
  sub ilogb;

 view release on metacpan or  search on metacpan

lib/Net/DNS/Create/Route53.pm  view on Meta::CPAN

    for my $domain (@domain) {
        my $zone = hosted_zone(full_host($domain->{name}));
        if (!$zone && scalar @{$domain->{entries}}) {
            my $hostedzone = Net::Amazon::Route53::HostedZone->new(route53 => r53,
                                                                   name => $domain->{name},
                                                                   comment=>(getpwuid($<))[0].'/'.__PACKAGE__,
                                                                   callerreference=>__PACKAGE__."-".localtime."-".($counter++));
            print "New Zone: $domain->{name}...";
            $hostedzone->create();
            $zone = $hostedzone;
            print "Created. Nameservers:\n".join('', map { "  $_\n" } @{$zone->nameservers});

 view release on metacpan or  search on metacpan

lib/Net/Delicious.pm  view on Meta::CPAN

                if ($user_cfg) {
                        $self->{'__updates'} = $user_cfg;
                }
                
                elsif (-d (getpwuid($EUID))[7]) {
                        $self->{'__updates'} = (getpwuid($EUID))[7];
                }
                
        
                else {
                        $self->{'__updates'} = File::Temp::tempdir();

 view release on metacpan or  search on metacpan

dropbear/cli-kex.c  view on Meta::CPAN

	
	homedir = getenv("HOME");

	if (!homedir) {
		struct passwd * pw = NULL;
		pw = getpwuid(getuid());
		if (pw) {
			homedir = pw->pw_dir;
		}
	}

 view release on metacpan or  search on metacpan

t/05-api_key.t  view on Meta::CPAN

    like $@, qr/doesn't exist/, "...and error message is sane";
}

# api_key_set() croak if can't write file (only run if not root user)
if ($^O !~ /win/i) {
    if (getpwuid($<) ne 'root') {
        open my $fh, '>', $file or die "Can't open $file for creation: $!";
        chmod(0400, $file) or die "Can't set permissions on $file: $!";
        close $fh;

        is eval {

 view release on metacpan or  search on metacpan

lib/Net/FTPServer/Full/DirHandle.pm  view on Meta::CPAN

    # handle, then $dev will be undefined. Return dummy status
    # information.
    return ("d", 0000, 1, "-", "-", 0, 0) unless defined $dev;

    # Generate printable user/group.
    my $user = getpwuid ($uid) || "-";
    my $group = getgrgid ($gid) || "-";

    # Permissions from mode.
    my $perms = $mode & 0777;

 view release on metacpan or  search on metacpan

lib/Net/Flickr/Backup.pm  view on Meta::CPAN

  if (! $triples) {
    return undef;
  }

  my $user_id     = (getpwuid($>))[0];
  my $os_uri      = sprintf("x-urn:%s:",$^O);
  my $user_uri    = $os_uri."user";

  my $creator_uri = sprintf("x-urn:%s#%s", $self->hostname_short, $user_id);

lib/Net/Flickr/Backup.pm  view on Meta::CPAN

    push @$triples, [$uri, $self->uri_shortform("rdfs", "seeAlso"), $photo];
    push @$triples, [$uri, $self->uri_shortform("dc", "creator"), $creator_uri];
    push @$triples, [$uri, $self->uri_shortform("dcterms", "created"), _w3cdtf() ];
  }

  push @$triples, [$creator_uri, $self->uri_shortform("foaf", "name"), (getpwuid($>))[6]];
  push @$triples, [$creator_uri, $self->uri_shortform("foaf", "nick"), $user_id];
  push @$triples, [$creator_uri, $self->uri_shortform("rdf", "type"), "computer:user"];

  return $triples;
}

 view release on metacpan or  search on metacpan

Connection/Connection.pm  view on Meta::CPAN

	# Set client_user
	if ($opt->{client_user}) {
		$self->setClientUser ($opt->{client_user});
	} else {
		$self->setClientUser (scalar (getpwuid ($>)));
	}

	# Set freedb_host
	if ($opt->{freedb_host}) {
		$self->setFreeDBHost ($opt->{freedb_host});

Connection/Connection.pm  view on Meta::CPAN

The hostname of the client. Defaults to C<&Sys::Hostname::hostname ()>.

=item client_user

The user of the client. Defaults to C<scalar (getpwuid ($E<gt>))>;

=item freedb_host

The FreeDB/CDDB host. Defaults to C<freedb.freedb.org>.

 view release on metacpan or  search on metacpan

lib/Net/FullAuto.pm  view on Meta::CPAN

=item

   use Net::FullAuto;

   my $ip_or_hostname = $ARGV[0] || 'localhost';
   my $username       = $ARGV[1] || getlogin || getpwuid($<);
   my $identity_file  = $ARGV[2] || ''; # required unless password or
                                        # or key-based login
   my $password       = $ARGV[3] || ''; # required unless identity file
                                        # or key-based login
   my $remote_host_block={

lib/Net/FullAuto.pm  view on Meta::CPAN

=item

   use Net::FullAuto;

   my $ip_or_hostname = $ARGV[0] || 'localhost';
   my $username       = $ARGV[1] || getlogin || getpwuid($<);
   my $identity_file  = $ARGV[2] || ''; # required unless password or
                                        # or key-based login
   my $password       = $ARGV[3] || ''; # required unless identity file
                                        # or key-based login

lib/Net/FullAuto.pm  view on Meta::CPAN

=item

   use Net::FullAuto;

   my $ip_or_hostname = $ARGV[0] || 'localhost';
   my $username       = $ARGV[1] || getlogin || getpwuid($<);
   my $identity_file  = $ARGV[2] || ''; # required unless password or
                                        # or key-based login
   my $password       = $ARGV[3] || ''; # required unless identity file
                                        # or key-based login

 view release on metacpan or  search on metacpan

Hesiod.pm  view on Meta::CPAN

#Some convenient tags
%EXPORT_TAGS =
(	'resolve' => [qw( hesiod_init hesiod_end hesiod_resolve)],
	'all' => [ qw(  hesiod_init hesiod_end hesiod_resolve
			hesiod_to_bind hesiod_getpwnam hesiod_getpwuid
			hesiod_getservbyname hesiod_getmailhost) ]
);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

@EXPORT_OK = qw( hesiod_init hesiod_end hesiod_resolve
			hesiod_to_bind hesiod_getpwnam hesiod_getpwuid
			hesiod_getservbyname hesiod_getmailhost);

$VERSION = '1.11';

sub AUTOLOAD {

Hesiod.pm  view on Meta::CPAN

	}
	my $name=shift;
	return hesiod_getpwnam($context,$name);
}

sub getpwuid($$)
{	my $context = shift;
	if ( ! ref($context) )
	{	croak "Net::Hesiod::getpwuid called as class method.";
	}
	my $uid=shift;
	return hesiod_getpwuid($context,$uid);
}

sub getservbyname($$$)
{	my $context = shift;
	if ( ! ref($context) )

Hesiod.pm  view on Meta::CPAN

=head2 Non-OO interface

  use Net::Hesiod qw( 
		 hesiod_init hesiod_end hesiod_to_bind hesiod_resolve
		 hesiod_getpwnam hesiod_getpwuid 
		 hesiod_getservbyname hesiod_getmailhost );

  $res=hesiod_init($context);

  $bindname = hesiod_to_bind($context,$name,$type);
  @results = hesiod_resolve($context,$name,$type);

  @pwent = hesiod_getpwnam($context,$username);
  @pwent = hesiod_getpwuid($context,$uid);

  @servent = hesiod_getservbyname($context,$servicename,$proto);

  @mhent = hesiod_getmailhost($context,$username);

Hesiod.pm  view on Meta::CPAN

  $bindname = $ctxt->to_bind($name,$type);
  @results = $ctxt->resolve($name,$type);

  @pwent = $ctxt->getpwnam($username);
  @pwent = $ctxt->getpwuid($uid);

  @servent = $ctxt->getservbyname($servicename,$proto);
  @mhent = $ctxt->getmailhost($username);

  $results = $ctxt->query($name,$type,$delim);

Hesiod.pm  view on Meta::CPAN

The C<hesiod_resolve> routine and the C<resolve> method perform an actual
query.  As with all DNS queries, multiple records can be returned, each of
which is returned as separate items in returned list.  Usually, only the
first item is relevant.  

The routines C<hesiod_getpwnam>, C<hesiod_getpwuid>, C<hesiod_getservbyname>,
and the related methods (C<getpwnam>, C<getpwuid>, and C<getservbyname>), are
hesiod versions of the Core Perl routines C<getpwnam>, C<getpwuid>, and
C<getservbyname>.  The arrays returned have the same structure as the Core
routines.  B<NOTE>: The service entry returned by C<hesiod_getservbyname> and
the related method has the port number in host-byte order, not network-byte
order as the standard C servent structure does.  This is consistent with the
CORE C<getservbyname> and related functions.

Hesiod.pm  view on Meta::CPAN

=item hesiod_to_bind

=item hesiod_getpwnam

=item hesiod_getpwuid

=item hesiod_getservbyname

=item hesiod_getmailhost

Hesiod.pm  view on Meta::CPAN

L<hesiod>

L<hesiod_init>, L<hesiod_end>, L<hesiod_to_bind>, L<hesiod_resolve>

L<hesiod_getpwnam>, L<hesiod_getpwuid>, L<hesiod_getservbyname>, L<hesiod_getmailhost>

MIT's Athena Project 
	http://web.mit.edu/is/athena/

=back

 view release on metacpan or  search on metacpan

Connection.pm  view on Meta::CPAN

  
  my $self = {                # obvious defaults go here, rest are user-set
    _debug      => $_[0]->{_debug},
    _port       => 6667,
    # Evals are for non-UNIX machines, just to make sure.
    _username   => eval { scalar getpwuid($>) } || $ENV{USER} || $ENV{LOGNAME} || "japh",
    _ircname    => $ENV{IRCNAME} || eval { (getpwuid($>))[6] } || "Just Another Perl Hacker",
    _nick       => $ENV{IRCNICK} || eval { scalar getpwuid($>) } || $ENV{USER} || $ENV{LOGNAME} || "WankerBot",
    _ignore     => {},
    _handler    => {},
    _verbose    =>  0,       # Is this an OK default?
    _parent     =>  shift,
    _frag       =>  '',

Connection.pm  view on Meta::CPAN

      croak "No server address specified in connect()";
    }
    $self->server( $ENV{IRCSERVER} );
  }
  unless ($self->nick) {
    $self->nick($ENV{IRCNICK} || eval { scalar getpwuid($>) }
                || $ENV{USER} || $ENV{LOGNAME} || "WankerBot");
  }
  unless ($self->port) {
    $self->port($ENV{IRCPORT} || 6667);
  }
  unless ($self->ircname)  {
    $self->ircname($ENV{IRCNAME} || eval { (getpwuid($>))[6] }
                   || "Just Another Perl Hacker");
  }
  unless ($self->username) {
    $self->username(eval { scalar getpwuid($>) } || $ENV{USER}
                    || $ENV{LOGNAME} || "japh");
  }
  
  # Now for the socket stuff...
  if ($self->connected) {

 view release on metacpan or  search on metacpan

t/apache.t  view on Meta::CPAN

    print "# identd tells us we're $username\n";
    print $accept "you are $username\n";
    close $accept;
    close $listen;

    # if you think the above is an extremely silly way to do getpwuid($<),
    # think again. Just for fun, let's compare the ID we got with getpwuid
    # and co... sometimes it IS different (for privacy-enhanced identd)
    if (   ( getpwuid($<) && $username ne getpwuid($<) )
        && ( getlogin() && $username ne getlogin() )
        && ( $ENV{USER} && $username ne $ENV{USER} ) ) {
        print "# Hmm... that doesn't look like getpwuid(\$<) = \"", getpwuid($<) || "(undef)", "\"\n";
        print "# nor like getlogin() = \"",                         getlogin()   || "(undef)", "\"\n";
        print "# nor like $ENV{USER} = \"",                         $ENV{USER}   || "(undef)", "\"\n";
    }

    # let apache warm up some more, if necessary

 view release on metacpan or  search on metacpan

IdentServer.pm  view on Meta::CPAN

        $this->not_found(@_);

        return;
    }

    my $name = getpwuid( $found );
    unless( $name =~ m/\w/ ) {
        # This can happen if a deleted user has a socket open.  'u' might be a better choice. 
        # I happen to think hidden user is a nice choice here.  

        $this->log(2, "lookup from $rem_addr for $local_port, $rem_port: found uid, but no pwent");

 view release on metacpan or  search on metacpan

LPR.pm  view on Meta::CPAN

    my $user;
    
    if ($^O eq 'MSWin32') {
    	$user = getlogin();
    } else {
    	$user = scalar(getpwuid($>));
    }
    
    $self->{Jobs}->{$jobkey} = {
        JobID => $jobid,
        Jobname => $jobname,

 view release on metacpan or  search on metacpan

easyxs/ppport.h  view on Meta::CPAN

GETPWENT_R_PROTO|5.008000|5.008000|Vn
getpwnam|5.009000||Viu
GETPWNAM_R_HAS_BUFFER|5.008000||Viu
GETPWNAM_R_HAS_PTR|5.008000||Viu
GETPWNAM_R_PROTO|5.008000|5.008000|Vn
getpwuid|5.009000||Viu
GETPWUID_R_HAS_PTR|5.008000||Viu
GETPWUID_R_PROTO|5.008000|5.008000|Vn
get_quantifier_value|5.033006||Viu
get_re_arg|||xciu
get_re_gclass_nonbitmap_data|5.031011||Viu

easyxs/ppport.h  view on Meta::CPAN

KEY_getprotobyname|5.003007||Viu
KEY_getprotobynumber|5.003007||Viu
KEY_getprotoent|5.003007||Viu
KEY_getpwent|5.003007||Viu
KEY_getpwnam|5.003007||Viu
KEY_getpwuid|5.003007||Viu
KEY_getservbyname|5.003007||Viu
KEY_getservbyport|5.003007||Viu
KEY_getservent|5.003007||Viu
KEY_getsockname|5.003007||Viu
KEY_getsockopt|5.003007||Viu

 view release on metacpan or  search on metacpan

Lyskom.pm  view on Meta::CPAN

    my $name =
      $arg{Name} ||
        $ENV{USER} ||
          $ENV{LOGNAME} ||
            ((getpwuid($<))[0]);

    $self->{refno} = 1;

    $self->{socket} = IO::Socket::INET->new(
                                            PeerAddr => $host,

 view release on metacpan or  search on metacpan

make_cron  view on Meta::CPAN

$time = "0:01" unless $time;

#
#  Default user
#
my $user = $opts{"u"} || (getpwuid($<))[0];
my $wuser = (getpwuid($<))[0];

#
#  Store information as follows:
#
#  $cron->{user}->{host}->{ cron }->[ min hour day mon weekday args ]

 view release on metacpan or  search on metacpan

lib/Net/OpenSSH/More.pm  view on Meta::CPAN

use Time::HiRes        ();
use Term::ANSIColor    ();


my %defaults = (
    'user'                 => $ENV{'USER'} || getpwuid($>),
    'port'                 => 22,
    'use_persistent_shell' => 0,
    'output_prefix'        => '',
    'home'                 => File::HomeDir->my_home,
    'retry_interval'       => 6,

 view release on metacpan or  search on metacpan

lib/Net/OpenSSH.pm  view on Meta::CPAN

    push @ssh_opts, -l => $user if defined $user;
    push @ssh_opts, -p => $port if defined $port;

    my $home = do {
	local ($@, $SIG{__DIE__});
	eval { Cwd::realpath((getpwuid $>)[7]) }
    };

    if (${^TAINT}) {
	($home) = $home =~ /^(.*)$/;
	Scalar::Util::tainted($ENV{PATH}) and

 view release on metacpan or  search on metacpan

lib/Net/Printer.pm  view on Meta::CPAN

        my $myname = hostname();
        my $snum   = int(rand 1000);

        # Fill up hash
        $chash{'1H'} = $myname;
        $chash{'2P'} = getlogin || getpwuid($<) || "nobody";
        $chash{'3J'} = $self->{filename};
        $chash{'4C'} = $myname;
        $chash{'5f'} = sprintf("dfA%03d%s", $snum, $myname);
        $chash{'6U'} = sprintf("cfA%03d%s", $snum, $myname,);
        $chash{'7N'} = $self->{filename};

 view release on metacpan or  search on metacpan

lib/Net/RDAP.pm  view on Meta::CPAN

use Net::RDAP::Registry;
use Net::RDAP::SearchResult;
use Net::RDAP::Service;
use Net::RDAP::Values;
use Net::RDAP::JCard;
use POSIX qw(getpwuid);
use vars qw($VERSION);
use constant DEFAULT_CACHE_TTL => 3600;
use strict;
use warnings;

lib/Net/RDAP.pm  view on Meta::CPAN

            '%s-%s.json',
            ref($self),
            sha256_hex(join(chr(0), (
                $VERSION,
                $url->as_string,
                getpwuid($<)
            )))
        )
    );

    #

 view release on metacpan or  search on metacpan

lib/Net/RRP/Toolkit.pm  view on Meta::CPAN

$Net::RRP::Toolkit::VERSION = (split " ", '# 	$Id: Toolkit.pm,v 1.3 2000/10/04 08:05:37 mkul Exp $	')[3];

sub decodeTilde
{
    my $path = shift || return undef;
    $path =~ s/^~([^\/]*)/$1 ? (getpwnam($1))[7] : (getpwuid($>))[7]/e;
    $path;
}

sub safeCall
{

 view release on metacpan or  search on metacpan

t/pam.t  view on Meta::CPAN

diag("\nFurther testing requires credentials to login to this box");
if ($ENV{NRS_INTERACTIVE} and prompt(q{Run this test? [y/n]: }, -yes))
{
    sleep 1;
    diag("\nWe need a username to test");
    my $login = getpwuid($<);
    my $user = prompt(qq{Username [$login]: }, -d => $login);

    sleep 1;
    diag("\nWe need the user's password to test authentication");
    my $pass = prompt(qq{Password for $user: }, -e => '*');

 view release on metacpan or  search on metacpan

lib/Net/SFTP/Foreign/Backend/Net_SSH2.pm  view on Meta::CPAN

	my $port = delete $opts->{port} || 22;
	%$opts and return;

        unless (defined $auth_args{username}) {
            local $SIG{__DIE__};
            $auth_args{username} = eval { scalar getpwuid $< };
            defined $auth_args{username} or croak "required option 'user' missing";
        }

	$ssh2 = $self->{_ssh2} = Net::SSH2->new();
        $debug and $debug & 131072 and $ssh2->debug(1);