AFS-PAG
view release on metacpan or search on metacpan
kafs/kafs.c view on Meta::CPAN
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <config.h>
#include <portable/kafs.h>
#include <portable/system.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#ifdef HAVE_SYS_IOCCOM_H
# include <sys/ioccom.h>
#endif
#include <sys/ioctl.h>
#include <sys/stat.h>
/* Used for unused parameters to silence gcc warnings. */
#define UNUSED __attribute__((__unused__))
kafs/kafs.c view on Meta::CPAN
# include <kafs/sys-darwin8.c>
#elif defined(HAVE_KAFS_DARWIN10)
# include <kafs/sys-darwin10.c>
#elif defined(HAVE_KAFS_LINUX)
# include <kafs/sys-linux.c>
#elif defined(HAVE_KAFS_SOLARIS)
# include <kafs/sys-solaris.c>
#elif defined(HAVE_KAFS_SYSCALL)
# include <kafs/sys-syscall.c>
#else
# error "Unknown AFS system call implementation"
#endif
/*
* On some platforms, k_hasafs needs to try a system call. This attempt may
* fail with SIGSYS. We therefore set a signal handler that changes a static
* variable if SIGSYS is received.
*
* It's really ugly to do this in library or PAM module in so many ways.
* Static variables are evil, changing signal handlers out from under an
* application is evil, and the interaction of signals and threads is probably
kafs/kafs.c view on Meta::CPAN
/*
* The other system calls are implemented in terms of k_pioctl. This
* interface assumes that all pointers can be represented in a long, but then
* so does the whole AFS system call interface.
*/
int
k_pioctl(char *path, int cmd, struct ViceIoctl *cmarg, int follow)
{
int err, rval;
rval = k_syscall(20, (long) path, cmd, (long) cmarg, follow, &err);
if (rval != 0)
err = rval;
return err;
}
/*
* Probe to see if AFS is available and we can make system calls successfully.
* This just attempts the set token system call with an empty token structure,
* which will be a no-op in the kernel.
*/
int
k_hasafs(void)
{
struct ViceIoctl iob;
int rval, saved_errno, okay;
void (*saved_func)(int);
saved_errno = errno;
#ifdef SIGSYS
saved_func = signal(SIGSYS, sigsys_handler);
#endif
iob.in = NULL;
iob.in_size = 0;
iob.out = NULL;
iob.out_size = 0;
rval = k_pioctl(NULL, _IOW('V', 3, struct ViceIoctl), &iob, 0);
#ifdef SIGSYS
signal(SIGSYS, saved_func);
#endif
okay = (syscall_okay && rval == -1 && errno == EINVAL);
errno = saved_errno;
return okay;
}
/*
* The setpag system call. This is special in that it's not a pioctl;
* instead, it's a separate system call done directly through the afs_syscall
* function.
*/
int
k_setpag(void)
{
int err, rval;
rval = k_syscall(21, 0, 0, 0, 0, &err);
if (rval != 0)
err = rval;
return err;
}
/*
* The unlog system call. This destroys any tokens in the current PAG.
*/
int
k_unlog(void)
{
struct ViceIoctl iob;
kafs/sys-darwin10.c view on Meta::CPAN
unsigned int syscall;
unsigned int retval;
};
/*
* The workhorse function that does the actual system call. All the values
* are passed as longs to match the internal OpenAFS interface, which means
* that there's all sorts of ugly type conversion happening here.
*
* Returns -1 and sets errno to ENOSYS if attempting a system call fails and 0
* otherwise. If the system call was made, its return status will be stored
* in rval.
*/
static int
k_syscall(long call, long param1, long param2, long param3, long param4,
int *rval)
{
int fd, code, oerrno;
fd = open("/dev/openafs_ioctl", O_RDWR);
if (fd < 0) {
errno = ENOSYS;
return -1;
}
if (sizeof(param1) == 8) {
struct afssysargs64 syscall_data;
syscall_data.syscall = call;
syscall_data.param1 = param1;
syscall_data.param2 = param2;
syscall_data.param3 = param3;
kafs/sys-darwin10.c view on Meta::CPAN
syscall_data.param2 = param2;
syscall_data.param3 = param3;
syscall_data.param4 = param4;
syscall_data.param5 = 0;
syscall_data.param6 = 0;
code = ioctl(fd, _IOWR('C', 1, struct afssysargs), &syscall_data);
if (code == 0)
*rval = syscall_data.retval;
}
oerrno = errno;
close(fd);
errno = oerrno;
return code;
}
kafs/sys-darwin8.c view on Meta::CPAN
unsigned int param6;
unsigned int retval;
};
/*
* The workhorse function that does the actual system call. All the values
* are passed as longs to match the internal OpenAFS interface, which means
* that there's all sorts of ugly type conversion happening here.
*
* Returns -1 and sets errno to ENOSYS if attempting a system call fails and 0
* otherwise. If the system call was made, its return status will be stored
* in rval.
*/
static int
k_syscall(long call, long param1, long param2, long param3, long param4,
int *rval)
{
struct afssysargs syscall_data;
int fd, code, oerrno;
fd = open("/dev/openafs_ioctl", O_RDWR);
if (fd < 0) {
errno = ENOSYS;
return -1;
}
syscall_data.syscall = call;
syscall_data.param1 = param1;
syscall_data.param2 = param2;
syscall_data.param3 = param3;
syscall_data.param4 = param4;
syscall_data.param5 = 0;
syscall_data.param6 = 0;
code = ioctl(fd, _IOWR('C', 1, struct afssysargs), &syscall_data);
if (code == 0)
*rval = syscall_data.retval;
oerrno = errno;
close(fd);
errno = oerrno;
return code;
}
kafs/sys-linux.c view on Meta::CPAN
/*
* The workhorse function that does the actual system call. All the values
* are passed as longs to match the internal OpenAFS interface, which means
* that there's all sorts of ugly type conversion happening here.
*
* The first path we attempt is the OpenAFS path; the second is the one used
* by Arla (at least some versions).
*
* Returns -1 and sets errno to ENOSYS if attempting a system call fails and 0
* otherwise. If the system call was made, its return status will be stored
* in rval.
*/
static int
k_syscall(long call, long param1, long param2, long param3, long param4,
int *rval)
{
struct afsprocdata syscall_data;
int fd, oerrno;
fd = open("/proc/fs/openafs/afs_ioctl", O_RDWR);
if (fd < 0)
fd = open("/proc/fs/nnpfs/afs_ioctl", O_RDWR);
if (fd < 0) {
errno = ENOSYS;
return -1;
}
syscall_data.syscall = call;
syscall_data.param1 = param1;
syscall_data.param2 = param2;
syscall_data.param3 = param3;
syscall_data.param4 = param4;
*rval = ioctl(fd, _IOW('C', 1, void *), &syscall_data);
oerrno = errno;
close(fd);
errno = oerrno;
return 0;
}
kafs/sys-solaris.c view on Meta::CPAN
uint64_t param1;
uint32_t syscall;
};
/*
* The workhorse function that does the actual system call. All the values
* are passed as longs to match the internal OpenAFS interface, which means
* that there's all sorts of ugly type conversion happening here.
*
* Returns -1 and sets errno to ENOSYS if attempting a system call fails and 0
* otherwise. If the system call was made, its return status will be stored
* in rval.
*/
static int
k_syscall(long call, long param1, long param2, long param3, long param4,
int *rval)
{
int fd, code, oerrno, callnum;
#ifdef _ILP32
struct afssysargs syscall_data;
syscall_data.syscall = call;
syscall_data.param1 = param1;
syscall_data.param2 = param2;
syscall_data.param3 = param3;
syscall_data.param4 = param4;
syscall_data.param5 = 0;
kafs/sys-solaris.c view on Meta::CPAN
syscall_data.param2 = param2;
syscall_data.param3 = param3;
syscall_data.param4 = param4;
syscall_data.param5 = 0;
syscall_data.param6 = 0;
callnum = _IOW('C', 1, struct afssysargs64);
#endif
fd = open("/dev/afs", O_RDWR);
if (fd < 0) {
errno = ENOSYS;
return -1;
}
*rval = ioctl(fd, callnum, &syscall_data);
oerrno = errno;
close(fd);
errno = oerrno;
return 0;
}
lib/AFS/PAG.pm view on Meta::CPAN
throws an exception on failure.
=back
=head1 DIAGNOSTICS
=over 4
=item PAG creation failed: %s
setpag() failed. The end of the error message will be a translation of
the system call error number.
=item Token deletion failed: %s
unlog() failed. The end of the error message will be a translation of
the system call error number.
=back
=head1 RESTRICTIONS
This module currently doesn't provide the k_pioctl() or pioctl() function
to make lower-level AFS system calls. It also doesn't provide the libkafs
functions to obtain AFS tokens from Kerberos tickets directly without using
an external ticket cache. This prevents use of internal Kerberos ticket
caches (such as memory caches), since the Kerberos tickets used to generate
lib/AFS/PAG.xs view on Meta::CPAN
*/
#include <glue/config.h>
#include <portable/kafs.h>
#include <portable/system.h>
#include <EXTERN.h>
#include <perl.h>
#include <XSUB.h>
#include <errno.h>
/* XS code below this point. */
MODULE = AFS::PAG PACKAGE = AFS::PAG
PROTOTYPES: DISABLE
void
hasafs()
PPCODE:
lib/AFS/PAG.xs view on Meta::CPAN
else
XSRETURN_UNDEF;
void
setpag()
PPCODE:
if (k_setpag() == 0)
XSRETURN_YES;
else
croak("PAG creation failed: %s", strerror(errno));
void
unlog()
PPCODE:
if (k_unlog() == 0)
XSRETURN_YES;
else
croak("Token deletion failed: %s", strerror(errno));
portable/kafs.h view on Meta::CPAN
#ifndef PORTABLE_KAFS_H
#define PORTABLE_KAFS_H 1
#include <config.h>
#ifdef HAVE_KRB5
# include <portable/krb5.h>
#endif
#include <portable/macros.h>
#include <errno.h>
#ifdef HAVE_SYS_IOCCOM_H
# include <sys/ioccom.h>
#endif
#include <sys/ioctl.h>
BEGIN_DECLS
/* Assume we have some AFS support available and #undef below if not. */
#define HAVE_KAFS 1
portable/kafs.h view on Meta::CPAN
#elif HAVE_LSETPAG
# if HAVE_AFS_AFSSYSCALLS_H
# include <afs/afssyscalls.h>
# else
int lsetpag(void);
int lpioctl(char *, int, void *, int);
# endif
# define k_hasafs() (1)
# define k_pioctl(p, c, a, f) lpioctl((p), (c), (a), (f))
# define k_setpag() lsetpag()
# define k_unlog() (errno = ENOSYS, -1)
int k_haspag(void) __attribute__((__visibility__("hidden")));
/* We're using our local kafs replacement. */
#elif HAVE_KAFS_REPLACEMENT
# define HAVE_K_PIOCTL 1
struct ViceIoctl {
void *in, *out;
short in_size;
portable/kafs.h view on Meta::CPAN
int k_unlog(void);
/* Undo default visibility change. */
#pragma GCC visibility pop
/* We have no kafs implementation available. */
#else
# undef HAVE_KAFS
# define k_hasafs() (0)
# define k_haspag() (0)
# define k_pioctl(p, c, a, f) (errno = ENOSYS, -1)
# define k_setpag() (errno = ENOSYS, -1)
# define k_unlog() (errno = ENOSYS, -1)
#endif
END_DECLS
#endif /* PORTABLE_KAFS_H */
t/data/perlcriticrc view on Meta::CPAN
# This problem was fixed in Perl 5.14, which now properly preserves the value
# of $@ even if destructors run at exit from the eval block.
[-ErrorHandling::RequireCheckingReturnValueOfEval]
# The default of 9 is too small and forces weird code contortions.
[InputOutput::RequireBriefOpen]
lines = 25
# This is correct 80% of the time, but it isn't correct for a lot of scripts
# inside packages, where maintaining $VERSION isn't worth the effort.
# Unfortunately, there's no way to override it, so it gets turned off
# globally.
[-Modules::RequireVersionVar]
# This sounds interesting but is actually useless. Any large blocks of
# literal text, which does not add to the complexity of the regex, will set it
# off.
[-RegularExpressions::ProhibitComplexRegexes]
# I generally don't want to require Readonly as a prerequisite for all my Perl
# modules.
t/docs/pod-spelling.t view on Meta::CPAN
#!/usr/bin/perl
#
# Check for spelling errors in POD documentation.
#
# The canonical version of this file is maintained in the rra-c-util package,
# which can be found at <http://www.eyrie.org/~eagle/software/rra-c-util/>.
#
# Written by Russ Allbery <eagle@eyrie.org>
# Copyright 2013, 2014
# The Board of Trustees of the Leland Stanford Junior University
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
t/docs/pod.t view on Meta::CPAN
#!/usr/bin/perl
#
# Check all POD documents for POD formatting errors.
#
# The canonical version of this file is maintained in the rra-c-util package,
# which can be found at <http://www.eyrie.org/~eagle/software/rra-c-util/>.
#
# Written by Russ Allbery <eagle@eyrie.org>
# Copyright 2012, 2013, 2014
# The Board of Trustees of the Leland Stanford Junior University
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
t/docs/synopsis.t view on Meta::CPAN
#!/usr/bin/perl
#
# Check the SYNOPSIS section of the documentation for syntax errors.
#
# The canonical version of this file is maintained in the rra-c-util package,
# which can be found at <http://www.eyrie.org/~eagle/software/rra-c-util/>.
#
# Written by Russ Allbery <eagle@eyrie.org>
# Copyright 2013, 2014
# The Board of Trustees of the Leland Stanford Junior University
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
t/lib/Test/RRA.pm view on Meta::CPAN
$version = shift(@imports);
}
# Get caller information to put imports in the correct package.
my ($package) = caller;
# Do the import with eval, and try to isolate it from the surrounding
# context as much as possible. Based heavily on Test::More::_eval.
## no critic (BuiltinFunctions::ProhibitStringyEval)
## no critic (ValuesAndExpressions::ProhibitImplicitNewlines)
my ($result, $error, $sigdie);
{
local $@ = undef;
local $! = undef;
local $SIG{__DIE__} = undef;
$result = eval qq{
package $package;
use $module $version \@imports;
1;
};
$error = $@;
$sigdie = $SIG{__DIE__} || undef;
}
# If the use failed for any reason, skip the test.
if (!$result || $error) {
my $name = length($version) > 0 ? "$module $version" : $module;
plan skip_all => "$name required for test";
}
# If the module set $SIG{__DIE__}, we cleared that via local. Restore it.
## no critic (Variables::RequireLocalizedPunctuationVars)
if (defined($sigdie)) {
$SIG{__DIE__} = $sigdie;
}
return;
t/lib/Test/RRA/Config.pm view on Meta::CPAN
our @CRITIC_IGNORE;
our $LIBRARY_PATH;
our $MINIMUM_VERSION = '5.008';
our %MINIMUM_VERSION;
our @POD_COVERAGE_EXCLUDE;
our @STRICT_IGNORE;
our @STRICT_PREREQ;
# Load the configuration.
if (!do($PATH)) {
my $error = $@ || $! || 'loading file did not return true';
BAIL_OUT("cannot load data/perl.conf: $error");
}
1;
__END__
=for stopwords
Allbery rra-c-util Automake perlcritic .libs namespace subdirectory
sublicense MERCHANTABILITY NONINFRINGEMENT
=head1 NAME
t/style/critic.t view on Meta::CPAN
#!/usr/bin/perl
#
# Check for perlcritic errors in all code.
#
# If author tests are enabled, check all Perl code in blib/lib, examples, usr,
# t, and Build.PL for problems uncovered by perlcritic, ignoring template
# files, junk, and any files explicitly configured to be ignored.
#
# Written by Russ Allbery <eagle@eyrie.org>
# Copyright 2013, 2014
# The Board of Trustees of the Leland Stanford Junior University
#
# Permission is hereby granted, free of charge, to any person obtaining a
( run in 0.764 second using v1.01-cache-2.11-cpan-49f99fa48dc )