Free tmpdir software for linux

pam_mktemp is a PAM module which may be used with a PAM-aware login service to provide per-user private directories under /tmp as a part of account management or PAM session.
When an interactive (shell) session is started, a directory is created and the environment variables TMPDIR and TMP are set to the name of the directory.
Youre allowed to do whatever you like with this software (including re-distribution in source and/or binary form, with or without modification), provided that credit is given where it is due and any modified versions are marked as such. Theres absolutely no warranty.
Enhancements:
- A workaround for building pam_mktemp on systems with Linux 2.6.x kernel headers has been added.

PAR::WebStart is a Perl implementation of Javas WebStart.

SYNOPSIS

my $file = hello.pnlp;
my $ws = PAR::WebStart->new(file => $file);
$ws->fetch_pars() or die $ws->{ERROR};

my $tmpdir = $ws->{tmpdir};
chdir($tmpdir) or die qq{Cannot chdir to "$tmpdir": $!});

my @args = @{$ws->run_command()};
die qq{Failed to get WebStart args: $ws->{ERROR}}) unless (@args);
system(@args) == 0 or die qq{Execution of system(@args) failed: $?};

This a Perl version of Javas WebStart technology; see http://java.sun.com/j2se/1.4.2/docs/guide/jws/developersguide/overview.html for details.

PAR-WebStart is a helper application associated with a browser. When a user clicks on a link that points to a PNLP [PAR Network Launch Protocol] launch file (a special XML file), it causes the browser to launch PAR-WebStart, which then automatically downloads, caches, and runs the specified PAR-based application.

Launch4j project is a cross-platform tool for wrapping Java applications distributed as jars in lightweight Windows native executables.
The executable can be configured to search for a certain JRE version or use a bundled one, and its possible to set runtime options, like the initial/max heap size.
The wrapper also provides better user experience through an application icon, a native pre-JRE splash screen, a custom process name, and a Java download page in case the appropriate JRE cannot be found.
Main features:
- Launch4j wraps jars in Windows native executables and allows to run them like a regular Windows program. Its possible to wrap applications on Linux!
- Doesnt extract the jar from the executable.
- Custom application icon with multiple resolutions and color depths.
- Native pre-JRE splash screen in BMP format shown until the Java application starts.
- Process name as the executable filename to easily identify your application.
- Works with a bundled JRE or searches for newest JRE / SDK in given range.
- Opens Java download page if an appropriate Java version cannot be found.
- Supports GUI and console apps.
- Passes command line arguments, also supports constant arguments.
- Allows to set the initial/max heap size.
- JVM options: set system properties, tweak the garbage collection...
- Option to change current directory to the executable location.
- Custom version information shown by Windows Explorer.
- GUI and command line interface.
- Build integration through an Ant task.
- Lightweight: 21 KB!
- Its free and may be used for commercial purposes.
- Includes a sample application and Ant script that automates the build process from Java sources to native executable.
- The wrapped program works on all Windows platforms (98/Me/NT/2K/Xp), launch4j works on NT/2K/Xp, Linux (developed and tested on FC2)
Whats New in 2.1.5 Stable Release:
- Changed the Java download site to http://java.com/download.
- Now its possible to use absolute and relative paths to specify the embedded JRE.
Enhancements:
- Enhanced GUI.
- Redesigned error reporting.
- Added custom error messages.
- Added support website feature.
- Added PWD and OLDPWD special variables and access to the registry.
- Runtime ini file extension changed to .l4j.ini, added comments (#).
- FR #1427811 Initial process priority.
- FR #1547339 Added VarFileInfo structure to Version Info (Stephan Laertz).
- FR #1584295 Updated documentation for --l4j-debug.
- Fixed and config conversion bug (found by Dafe Simonek).
- Fixed the Ant task exception reporting bug, added tmpdir and bindir attributes.
- Fixed bug #1563415 Problem with launching application when ini file exists (found by mojomax).
- Fixed bug #1527619 Console header wildcard expansion (found by erikjv).
- Fixed bug #1544167 NPE when dontwrap and only classpath given (found by Hendrik Schreiber).
- Fixed bug #1584264 Dropdown boxes get mixed up (found by Larsen).

File::CounterFile is a persistent counter class.

SYNOPSIS

use File::CounterFile;
$c = File::CounterFile->new("COUNTER", "aa00");

$id = $c->inc;
open(F, ">F$id");

This module implements a persistent counter class. Each counter is represented by a separate file in the file system. File locking is applied, so multiple processes can attempt to access a counter simultaneously without risk of counter destruction.

You give the file name as the first parameter to the object constructor (new). The file is created if it does not exist.

If the file name does not start with "/" or ".", then it is interpreted as a file relative to $File::CounterFile::DEFAULT_DIR. The default value for this variable is initialized from the environment variable TMPDIR, or /usr/tmp if no environment variable is defined. You may want to assign a different value to this variable before creating counters.

If you pass a second parameter to the constructor, it sets the initial value for a new counter. This parameter only takes effect when the file is created (i.e. it does not exist before the call).

When you call the inc() method, you increment the counter value by one. When you call dec(), the counter value is decremented. In both cases the new value is returned. The dec() method only works for numerical counters (digits only).
You can peek at the value of the counter (without incrementing it) by using the value() method.

The counter can be locked and unlocked with the lock() and unlock() methods. Incrementing and value retrieval are faster when the counter is locked, because we do not have to update the counter file all the time. You can query whether the counter is locked with the locked() method.

There is also an operator overloading interface to the File::CounterFile object. This means that you can use the ++ operator for incrementing and the -- operator for decrementing the counter, and you can interpolate counters directly into strings.

B::LexInfo is a Perl module that shows information about subroutine lexical variables.

SYNOPSIS

use B::ShowLex ();
my $lexi = B::ShowLex->new;

Perl stores lexical variable names and values inside a padlist within the subroutine. Certain lexicals will maintain certain attributes after the the variable "goes out of scope". For example, when a scalar is assigned a string value, this value remains after the variable has gone out of scope, but is overridden the next time it is assigned to. Lexical Arrays and Hashes will retain their storage space for the maximum number of entries stored at any given point in time.

This module provides methods to record this information, which can be dumped out as-is or to compare two "snapshots". The information learned from these snapshots can be valuable in a number of ways.

METHODSM

new

Create a new B::LexInfo object:

my $lexi = B::LexInfo->new;

cvlexinfo

Create a padlist snapshot from a single subroutine:

my $info = $lexi->cvlexinfo(Foo::bar);

stash_cvlexinfo

Create a list of padlist snapshots for each subroutine in the given package:

my $info = $lexi->stash_cvlexinfo(Foo);

dumper

Return a reference to a stringified padlist snapshot:

print ${ $lexi->dumper($info) }

diff

Compare two padlist snapshots and return the difference:

my $before = $lexi->stash_cvlexinfo(__PACKAGE__);
... let some code run
my $after = $lexi->stash_cvlexinfo(__PACKAGE__);

my $diff = B::LexInfo->diff($before, $after);
print $$diff;

NOTE: This function relies on the diff -u command. You might need to configure $B::LexInfo::TmpDir and/or $B::LexInfo::DiffCmd to values other than the defaults in LexInfo.pm.

cvrundiff

Take a padlist snapshot of a subroutine, run the subroutine with the given arguments, take another snapshot and return a diff of the snapshots.

my $diff = $lexi->cvrundiff(Foo::bar, "arg1", $arg2);
print $$diff;

Complete example:

package Foo;
use B::LexInfo ();

sub bar {
my($string) = @_;
}

my $lexi = B::LexInfo->new;
my $diff = $lexi->cvrundiff(Foo::bar, "a string");
print $$diff;

Produces:

--- /tmp/B_LexInfo_1848.before Mon Jun 28 19:48:41 1999
+++ /tmp/B_LexInfo_1848.after Mon Jun 28 19:48:41 1999
@@ -2,8 +2,10 @@
{
Foo::bar => {
$string => {
- TYPE => NULL,
- NULL => 0x80efd58
+ TYPE => PV,
+ LEN => 9,
+ PV => a string,
+ CUR => 8
},
__SPECIAL__1 => {
TYPE => NULL,

Java::SJ::Config is a Perl module that represents SJ Configuration File.

It uses XML::XPath to parse configuration files and generates objects to represent the directives.

Unless youre working on the module what you really want to know is what directives are allowed and their meaning. Youre in luck, its below.

VARIABLES

The following variables and their relevant defaults are used by the system. These defaults have been chosen to make it as easy as possible to install SJ on a fairly standard UNIX system and have logs, and directories in places that you would expect to find them.

The full paths that will be used if every default is in effect is also shown below.
dir.base - default /usr/local - full /usr/local

The base directory for the system. This directory is used in conjunction with defaults to find directories if they have not been defined elsewhere.
dir.lib - default ${dir.base}/lib/sj - full /usr/local/lib/sj

The directory to find jar files in.
dir.pid - default ${dir.base}/var/run - full /usr/local/var/run

The directory to store PID files in.
dir.log - default ${dir.base}/var/log/sj - full /usr/local/var/log/sj

The directory to store log files in
dir.script - default ${dir.base}/var/sj/script - full /usr/local/var/sj/script

The directory to store generated script files in.
dir.tmp - default &File::Spec::Functions::tmpdir - full N/A (depends on system)

The directory to store temporary files in.
app.name - no default

The name of the application
app.class - no default

The class file for the application
vm.default - Defined by whichever VM has default=true attribute

The default VM tag to use if none supplied by the application