Free module homes software for linux

Module::Versions is a Perl module to handle versions of loaded modules with flexible result interface.

SYNOPSIS

use Module::Versions;

# Simple Interface
list Module::Versions; # prints formatted results to STDOUT
Module::Versions->list; # prints formatted results to STDOUT

# Shortcuts
$vers = get Module::Versions; # retrieves loaded modules

$vers = Module::Versions->get; # retrieves loaded modules

$array = Module::Versions->ARRAY; # returns array with version infos
$hash = Module::Versions->HASH; # returns hash with version infos

$list = Module::Versions->SCALAR; # returns text list with version infos
$csv = Module::Versions->CSV; # returns csv list with version infos
$xml = Module::Versions->XML; # returns xml struct with version infos
$xsd = Module::Versions->XSD; # returns xml schema of version infos
$dtd = Module::Versions->DTD; # returns DTD of version infos

# Individual Parameters
$vers = Module::Versions # retrieves mods and vars as defined
->new($mods,$vars)
->get($criteria);

$vers->list($fd,$mask); # prints formatted results to file
$vers->list($fd,$preform); # prints preformatted results to file
$vers->list($fd,&cb); # prints serialied results as handled
# in callback routine
$vers->data(&cb); # returns transformed results as
# defined in callback routine
# Individual formatted output
list Module::Versions(*LOG, %5d %1s %-20s %10s %-16s);
# prints individually formatted
# results to LOG
list Module::Versions(*DBIMPORT, %s|%s|%s);
# prints individually formatted
# results to Database Import file

list Module::Versions(*FD, SCALAR);# prints text list results to file
list Module::Versions(*FD, CSV); # prints csv list results to file
list Module::Versions(*FD, XML); # prints xml struct results to file
list Module::Versions(*FD, XSD); # prints xml schema to file
list Module::Versions(*FD, DTD); # prints DTD to file

list Module::Versions(*FD, ARRAY); # prints serialized results to file
list Module::Versions(*FD, HASH); # prints serialized results to file

Module::Versions->list(*LOG); # prints formatted results to LOG

# Pretty Compact
Module::Versions->list # prints formatted results on STDOUT
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*XSD,XSD) # prints xml schema to XSD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions->list # prints formatted results on STDOUT
->list(*DTD,DTD) # prints DTD to DTD file
->list(*XML,XML); # prints xml struct results to XML file

Module::Versions handles versions of loaded modules with a flexible result interface. The main goal is to get as much version informations as possible about a module or module list with a simple call interface and an absolutely flexible result interface. Module::Versions handles *loaded* and *loadable* modules.

The motivation for writing this module was the need for better support facilities to get informations about the used modules and versions in the productivity environment. Module::Versions allows shipping applications basically with something like a -version option (See Getopt::Long) but with expanded functions.

Module::Versions tries to read the loaded/loadable modules $VERSION. For extended purposes any private project version variables can be fetched ($_VERSION, $version, $REV, etc.).

Module::Versions has a flexible result interface to satisfy different needs: results can be lists and data structures with different formats - pre-formed ARRAY, HASH, SCALAR, CSV, XML/XSD/DTD and a full flexible user callback interface.
It is for example very simple to print a good formatted version list to the console and save a version.xml file (in conjunction with an xsd-schema) at the same time with an absolutely minimum of coding (SYNOPSIS, Pretty Compact) .
Module::Versions tries to load version.pm to support Perl 5.10.0s $VERSION formatting.

Sybase module for Python project provides a Python interface to the Sybase relational database system. The Sybase package supports all of the Python Database API, version 2.0 with extensions.
Enhancements:
- This release works with Python 2.5, Sybase 15, and 64-bit clients.
- It can also use native Python datetime types.
- The infamous bug "This routine cannot be called because another command structure has results pending."
- that appears in various cases has been corrected.
- Various bugs have been corrected.

Module::Install is a standalone, extensible Perl module installer.

SYNOPSIS

In your Makefile.PL: (Recommended Usage)
# Load the Module::Install bundled in ./inc/
use inc::Module::Install;

# Define metadata
name Your-Module;
all_from lib/Your/Module.pm;

# Specific dependencies
requires Carp => 0;
requires File::Spec => 0.80;
build_requires Test::More => 0.42;
recommends Your::OtherModule => 0.01;

no_index directory => demos;

install_script bin/myscript;

auto_install;
WriteAll;

Quickly upgrade a legacy ExtUtil::MakeMaker installer:

# Drop-in replacement to ExtUtils::MakeMaker
use inc::Module::Install;
WriteMakefile( ... );

A dummy Build.PL so we can work with Module::Build as well:

# Dear Distribution Packager. This use of require is intentional.
# Module::Install detects Build.PL usage and acts accordingly.
require Makefile.PL;

Module::Install is a package for writing installers for CPAN (or CPAN-like) distributions that are clean, simple, minimalist, act in a strictly correct manner with both the ExtUtils::MakeMaker and Module::Build build systems, and will run on any Perl installation version 5.004 or newer.

The intent is to make it as easy as possible for CPAN authors (and especially for first-time CPAN authors) to have installers that follow all the best practices for distribution installation, but involve as much DWIM (Do What I Mean) as possible when writing them.

Module::MakefilePL::Parse is a Perl module to parse required modules from Makefile.PL.

SYNOPSIS

use Module::MakefilePL::Parse;

open $fh, Makefile.PL;

$parser = Module::MakefilePL::Parse->new( join("", ) );

$info = $parser->required;

The purpose of this module is to determine the required modules for older CPAN distributions which do not have META.yml files but use Makefile.PL and ExtUtils::MakeMaker or Module::Install.

Presumably newer style Makefile.PL files which use Module::Install or Module::Build already have META.yml files in their distributions.

Methods

new

$parser = new Modile::MakefilePL::Parse( $script );

Parses a Makefile.PL script and returns an object. Returns undef if there is a problem.

required

$info = $parser->required;

Returns a hash reference containing the prerequisite modules. This is either the the PREREQ_PM key, or a combination of prerequisites specified in requires and build_requires calls in the Makefile.PL script (depending on the "install_type").

install_type

$module = $parser->install_type;

Returns the module used for installation.

CAVEATS

This module does evaluate a portion of the code, so there is a security issue. However, it only evaluates the definition of the PREREQ_PM key in calls to WriteMakefile, which should be more difficult to embed malware in.
Do not run this module on untrusted scripts.

pam_mount is a Pluggable Authentication Module that can mount volumes for a user session.
This module is aimed at environments with SMB (Samba or Windows NT) or NCP (Netware or Mars-NWE) servers that Unix users wish to access transparently. It facilitates access to private volumes of these types well.
The module also supports mounting home directories using loopback encrypted filesystems. The module was originally written for use on the GNU/Linux operating system but has since been modified to work on several flavors of BSD.
- Every user can access his own volumes
- The user needs to type the password just once (at login)
- The mounting process is transparent to the users
- There is no need to keep the login passwords in any additional file
- The volumes are unmounted upon logout, so it saves system resources, avoiding the need of listing every every possibly useful remote volume in /etc/fstab or in an automount/supermount config file. This is also necessary for securing encrypted filesystems.
pam_mount "understands" SMB, NCP, and any type of filesystem that can be mounted using the standard mount command. If someone has a particular need for a different filesystem, feel free to ask me to include it and send me patches.
If you intend to use pam_mount to protect volumes on your computer using an encrypted filesystem system, please know that there are many other issues you need to consider in order to protect your data.
For example, you probably want to disable or encrypt your swap partition (the cryptoswap can help you do this). Dont assume a system is secure without carefully considering potential threats.
Enhancements:
- pam_mount now uses an XML config file, which also has a few new variables and options.
- Support for truecrypt was added.

Universal Module Player or UModPlayer, is a audio module "tool-chain", providing you functions to work with modules like playing, exporting, getting information, and more.
Universal Module Player works in UNIX-like platforms, including Linux, Mac OS X, FreeBSD, Solaris...
It uses the Custom LibModPlug audio library, an improved version of the well-known LibModPlug library, supporting more than 20 formats and giving you high playing quality. It uses LibSDL to handle multiplatform sound support.
Main features:
- You can play the supported formats and seek to any order in the song. You have pause, timer, display, and other standard features.
- You can view the pattern notes while playing.
- You can specify noise reduction, megabass, surround, reverb sound options specifying the grade and the delay of most of the options.
- You can create, save and edit playlists to play a selection of modules.
- You can read and export to a file the song builtin message, the song instrument names and the song sample names.
- Each user of your UNIX box can save all the sound options.
- And much more!
Supported Formats
Supported file formats on both Little Endian (Intel x86, etc.) and Big Endian (PowerPC, SPARC, MIPS, Motorola 68000, etc.) platforms:
Impulse Tracker (IT), Scream Tracker (STM), Scream Tracker 3 (S3M), Extended Modules (XM), Amiga Modules (MOD), OktaMED (MED), Oktalyzer (OKT), Unreal Modules (UMX), Composer 669 (669), DigiBooster Pro Modules (DBM), PolyTracker (PTM), and Farandole (FAR)
Additional file formats supported only on Little Endian platforms (support for Big Endian is on development):
MultiTracker Modules (MTM), AFM, AMS, DMF, DSM, DigiTracker (MDL), MadTracker 2.0 (MT2), PSM, ULT
Exporting Formats
You can export or convert any of the above formats to the following file types:
Impulse Tracker (IT)
WAVE Audio File (WAV)
Audio Interchange File Format (AIFF)
Raw Pulse Code Modulation (PCM)
Enhancements:
- Buffer length fixes.
- Playlist commands were a pain. Now we use the first letter of the command name. Also, pressing ENTER does not quit, the user has to explicitly specify to quit pressing q
- Hopefully fixed AIFF exporting bug.
- New section in the README about LibAo configuration, and some misc. rearrangements.

PAM Lockout Module is a PAM module is used to lockout users or groups from access to the machine. The module only supports authentication queries and the command line arguments are used to pass the users and groups.

A sample usage is for locking root out from remote access.

--------------- /etc/pam.d/sshd ---------
#%PAM-1.0
auth requisite /lib/security/pam_lockout.so user=root
auth required /lib/security/pam_stack.so service=system-auth
auth required /lib/security/pam_nologin.so
account required /lib/security/pam_stack.so service=system-auth
password required /lib/security/pam_stack.so service=system-auth
session required /lib/security/pam_stack.so service=system-auth
-----------------------------------------

The arguments to the module are in the form of user= or group=. There MUST NOT be any spaces in the arguments for the module to work.

I placed the module at the head of the stack to prevent other PAM modules from being accessed by the locked out users. In order for the user or group lockout to work the username or group name should be available via the getpwnam(3) or getgrnam(3) functions.

User comarisions are done using the pw_uid field in the passwd structure. So any user with and id of zero would be locked out in the above example. Group comparisions are done via string compares of the inbound user and the names returned by getgrnam(3).