Free perl interface livingston portmaster software for linux

RAS::PortMaster.pm is a Perl Interface to Livingston PortMaster 2.

SYNOPSIS

RAS::PortMaster is a PERL 5 module for interfacing with a Livingston PortMaster remote access server. Using this module, one can very easily construct programs to find a particular user in a bank of PMs, disconnect users, get usage statistics, or execute arbitrary commands on a PM.

GnuPG::Interface is a Perl interface to GnuPG.

SYNOPSIS

# A simple example
use IO::Handle;
use GnuPG::Interface;

# settting up the situation
my $gnupg = GnuPG::Interface->new();
$gnupg->options->hash_init( armor => 1,
homedir => /home/foobar );

# Note you can set the recipients even if you arent encrypting!
$gnupg->options->push_recipients( ftobin@cpan.org );
$gnupg->options->meta_interactive( 0 );

# how we create some handles to interact with GnuPG
my $input = IO::Handle->new();
my $output = IO::Handle->new();
my $handles = GnuPG::Handles->new( stdin => $input,
stdout => $output );

# Now well go about encrypting with the options already set
my @plaintext = ( foobar );
my $pid = $gnupg->encrypt( handles => $handles );

# Now we write to the input of GnuPG
print $input @plaintext;
close $input;

# now we read the output
my @ciphertext = ;
close $output;

waitpid $pid, 0;

GnuPG::Interface and its associated modules are designed to provide an object-oriented method for interacting with GnuPG, being able to perform functions such as but not limited to encrypting, signing, decryption, verification, and key-listing parsing.

How Data Member Accessor Methods are Created

Each module in the GnuPG::Interface bundle relies on Class::MethodMaker to generate the get/set methods used to set the objects data members. This is very important to realize. This means that any data member which is a list has special methods assigned to it for pushing, popping, and clearing the list.

Understanding Bidirectional Communication

It is also imperative to realize that this package uses interprocess communication methods similar to those used in IPC::Open3 and "Bidirectional Communication with Another Process" in perlipc, and that users of this package need to understand how to use this method because this package does not abstract these methods for the user greatly. This package is not designed to abstract this away entirely (partly for security purposes), but rather to simply help create proper, clean calls to GnuPG, and to implement key-listing parsing. Please see "Bidirectional Communication with Another Process" in perlipc to learn how to deal with these methods.

Using this package to do message processing generally invovlves creating a GnuPG::Interface object, creating a GnuPG::Handles object, setting some options in its options data member, and then calling a method which invokes GnuPG, such as clearsign. One then interacts with with the handles appropriately, as described in "Bidirectional Communication with Another Process" in perlipc.

perlrpcgen is a Perl module that can generate Perl interfaces from ONC RPC interface definitions.

SYNOPSIS

perlrpcgen [--makefile] [--all] [--client] [--server] [--data] [--constants] [--module module] [--typemap typemap] [--fork] [--perl perl] [--cc cc] [--rpclibs rpclibs] rpcfile.x

perlrpcgen builds a set of Perl extensions and a server shell from an ONC RPC interface definition. For an interface Foo, perlrpcgen creates modules Foo::Client, Foo::Data, and Foo::Constants. Foo::Client contains routines for creating a Foo client and making remote procedure calls via the client. Foo::Data contains routines for creating and manipulating the data structures defined in the Foo interface. Foo::Constants contains functions to retrieve the constants defined in the Foo interface.

OPTIONS

The option parsing uses Getopt::Long, so you can abbreviate option names.

--makefile

Generates a top-level Makefile which will build all the pieces. Include all the other options you want so theyll be propagated to the Makefile.

--all

Implies --client, --server, --data, and --constants. This is usually what you want.

--client

Generates Foo::Client module.

--server

Generates Foo/server/foo_svc.

--data

Generates Foo::Data module.

--constants

Generates Foo::Constants module.

--module module

Sets the basename of the modules. If not given, the name defaults to the basename of the interface file.

--typemap typemap

Uses the given typemap during stub generation. This option can be specified many times. perlrpcgen generates a typemap for the data structures in the interface, but you also need the main Perl typemap.

--fork

Munges the server shell code so that it forks for each request. You probably dont want to do this (its better to prefork several processes when you start the server and let them fight over accept() calls).

--perl perl

Sets the Perl binary against which extensions should be built. Defaults to the Perl you used to install perlrpcgen.

--cc cc

Sets the C compiler to use. Defaults to the compiler used when building Perl.

--rpclibs rpclibs

Sets the RPC libraries to link against. Defaults to -lnsl -lrpcsvc.

ObjStore::Internals is a Perl module with a few notes on the implementation.

SYNOPSIS

You dont have to understand anything about the technical implementation. Just know that:

ObjectStore is outrageously powerful; sophisticated; and even over-engineered.

The perl interface is optimized to be fun and easy. Since ObjectStore is also blindingly fast, you can happily leave relational databases to collect dust on the bookshelf where they belong.

So basically, you dont have to understand anything to a greater depth. Its not necessary. Youve arrived. You will be successful. However, more detail follows. If you like to turn things inside-out, read on!


Perl & C++ APIs: Whats The Difference?

Most stuff should be roughly the same. The few exceptions have generally arisen because there was a perl way to make the interface more programmer friendly.

Transactions are perlified.

Some static methods sit directly under ObjStore:: instead of under their own classes. (Easier to import.)

Databases are always blessed according to your pleasure.
lookup, open, is_open, and lock_timeout are augmented with multi-color, pop-tart style interfaces.

Why not just store perl data with the usual perl structures?

CHANGE CONTROL

As perl evolves, new data layouts are introduced. These changes must not cause database compatibility problems.

BINARY COMPATIBILITY

Perl doesnt have to worry about binary compatibility between platforms. Databases do. In addition, databases impose a number of restrictions on persistent data layout that would be onerous and sub-optimal if adopted by perl.

MEMORY USAGE

Perl often trades memory for speed. This is the wrong trade for a database. Memory usage is much more of a concern when data sets can be as large or larger than ten million megabytes. A few percent difference in compactness can be quite noticable.

Audio::Mad::Stream is a Perl interface to mad_stream structure.

SYPNOSIS

my $stream = new Audio::Mad::Stream ($options);
$stream->buffer($scalar);

my $remain = substr($scalar, $stream->next_frame);
my $position = $stream->this_frame;

$stream->skip($position + 400);
$stream->sync();

$options = $stream->options();
$options |= MAD_OPTION_IGNORECRC;
$stream->options($options);

unless ($stream->err_ok()) {
print "error code was: " . $stream->error() . "n";
}

This package provides an interface to the underlying mad_stream structure used in the decoder library. Almost all of the methods from the library are implemented, and work on regualar perl data types.

Bio::Factory::SequenceFactoryI is a Perl interface that allows for generic building of sequences in factories which create sequences (like SeqIO).

SYNOPSIS

# do not use this object directly it is an interface # get a Bio::Factory::SequenceFactoryI object like
use Bio::Seq::SeqFactory;
my $seqbuilder = new Bio::Seq::SeqFactory(type => Bio::PrimarySeq);

my $seq = $seqbuilder->create(-seq => ACTGAT,
-display_id => exampleseq);

print "seq is a ", ref($seq), "n";

A generic way to build Sequence objects via a pluggable factory. This reduces the amount of code that looks like
if( $type eq Bio::PrimarySeq ) { ... }
elsif( $type eq Bio::Seq::RichSeq ) { ... }

Teamspeak is a Perl interface to administrate Teamspeak-Server.

SYNOPSIS

use Teamspeak;
my $t = Teamspeak->new(
timeout => ,
port => ,
host =>
);

You can connect to a Teamspeak-Server in four different Connection-Types: 1. Telnet 2. MySQL or MySQL::Lite 3. Web-Frontend 4. Teamspeak-Client is using UDP

Every Connection-Type can only use a part of all available Methods.

Locale::TextDomain is a Perl Interface to Uniforum Message Translation.

SYNOPSIS

use Locale::TextDomain (my-package, @locale_dirs);

use Locale::TextDomain qw (my-package);

my $translated = __"Hello World!n";

my $alt = $__{"Hello World!n"};

my $alt2 = $__->{"Hello World!n"};

my @list = (N__"Hello", N__"World");

my @plurals = (N__ ("One world", "{num} worlds"),
N__ ("1 file", "%d files"));

my $question = __x ("Error reading file {file}: {err}",
file => $file, err => $!);

printf (__n ("one file read",
"%d files read",
$num_files),
$num_files);

print __nx ("one file read", "{num} files read", $num_files,
num => $num_files);

The module Locale::TextDomain(3pm) provides a high-level interface to Perl message translation.

Textdomains

When your request a translation for a given string, the system used in libintl-perl follows a standard strategy to find a suitable message catalog containing the translation: Unless you explicitely define a name for the message catalog, libintl-perl will assume that your catalog is called messages (unless you have changed the default value to something else via Locale::Messages(3pm), method textdomain()).
You might think that his default strategy leaves room for optimization and you are right. It would be a lot smarter if multiple software packages, all with their individual message catalogs, could be installed on one system, and it should also be possible that third-party components of your software (like Perl modules) can load their message catalogs, too, without interfering with yours.

The solution is clear, you have to assign a unique name to your message database, and you have to specify that name at run-time. That unique name is the so-called textdomain of your software package. The name is actually arbitrary but you should follow these best-practice guidelines to ensure maximum interoperability:

File System Safety

In practice, textdomains get mapped into file names, and you should therefore make sure that the textdomain you choose is a valid filename on every system that will run your software.

Case-sensitivity

Textdomains are always case-sensitive (i. e. Package and PACKAGE are not the same). However, since the message catalogs will be stored on file systems, that may or may not distinguish case when looking up file names, you should avoid potential conflicts here.

Textdomain Should Match CPAN Name

If your software is listed as a module on CPAN, you should simply choose the name on CPANS as your textdomain. The textdomain for libintl-perl is hence libintl-perl. But please replace all periods (.) in your package name with an underscore because ...

Internet Domain Names as a Fallback

... if your software is not a module listed on CPAN, as a last resort you should use the Java(tm) package scheme, i. e. choose an internet domain that you are owner of (or ask the owner of an internet domain) and concatenate your preferred textdomain with the reversed internet domain. Example: Your company runs the web-site www.foobar.org and is the owner of the domain foobar.org. The textdomain for your companys software barfoos should hence be org.foobar.barfoos.

If your software is likely to be installed in different versions on the same system, it is probably a good idea to append some version information to your textdomain.
Other systems are less strict with the naming scheme for textdomains but the phenomena known as Perl is actually a plethora of small, specialized modules and it is probably wisest to postulate some namespace model in order to avoid chaos.

Binding textdomains to directories

Once the system knows the textdomain of the message that you want to get translated into the users language, it still has to find the correct message catalog. By default, libintl-perl will look up the string in the translation database found in the directories /usr/share/locale and /usr/local/share/locale (in that order).

It is neither guaranteed that these directories exist on the target machine, nor can you be sure that the installation routine has write access to these locations. You can therefore instruct libintl-perl to search other directories prior to the default directories. Specifying a differnt search directory is called binding a textdomain to a directory.

Locale::TextDomain extends the default strategy by a Perl specific approach. Unless told otherwise, it will look for a directory LocaleData in every component found in the standard include path @INC and check for a database containing the message for your textdomain there. Example: If the path /usr/lib/perl/5.8.0/site_perl is in your @INC, you can install your translation files in /usr/lib/perl/5.8.0/site_perl/LocaleData, and they will be found at run-time.