Free sun solaris sparc software for linux

Sun::Solaris::Task is a Perl interface to Tasks.

SYNOPSIS

use Sun::Solaris::Task qw(:ALL);
my $taskid = gettaskid();

This module provides wrappers for the gettaskid(2) and settaskid(2) system calls.

Constants

TASK_NORMAL, TASK_FINAL.

Functions

settaskid($project, $flags)

The $project parameter must be a valid project ID and the $flags parameter must be TASK_NORMAL or TASK_FINAL. The parameters are passed through directly to the underlying settaskid() system call. The new task ID is returned if the call succeeds. On failure -1 is returned.

gettaskid()

This function returns the numeric task ID of the calling process, or undef if the underlying gettaskid() system call is unsuccessful.

Exports

By default nothing is exported from this module. The following tags can be used to selectively import constants and functions defined in this module:

:SYSCALLS settaskid() and gettaskid()

:CONSTANTS TASK_NORMAL and TASK_FINAL

:ALL :SYSCALLS and :CONSTANTS

Sun::Solaris::Privilege is a Perl interface to Privileges.

SYNOPSIS

use Sun::Solaris::Privilege qw(:ALL);

This module provides wrappers for the Privilege-related system and library calls. Also provided are constants from the various Privilege-related headers and dynamically generated constants for all the privileges and privilege sets.

Functions

getppriv($which)

This function returns the process privilege set specified by $which.

setppriv($op, $which, $set)

This function modified the privilege set specified by $which in the as specified by the $op and $set arguments. If $op is PRIV_ON the privileges in $set are added to the set specified; if $op is PRIV_OFF, the privileges in $set are removed from the set specified; if $op is PRIV_SET, the specified set is made equal to $set.

getpflags($flag)

Returns the value associated with process $flag or undef on error. Possible values for $flag are PRIV_AWARE and PRIV_DEBUG.

setppflags($flag, $val)

Sets the process flag $flag to $val.

priv_fillset()

This returns a new privilege set with all privileges set.

priv_emptyset()

This returns a new empty privilege set.

priv_isemptyset($set)

This function returns whether $set is empty or not.

priv_isfullset($set)

This function returns whether $set is full or not.

priv_isequalset($a, $b)

This function returns whether sets $a and $b are equal.

priv_issubset($a, $b)

This function returns whether set $a is a subset of $b.

priv_ismember($set, $priv)

This function returns whether $priv is a member of $set.

priv_ineffect($priv)

This function returned whether $priv is in the process effective set.

priv_intersect($a, $b)

This function returns a new privilege set which is the intersection of $a and $b

priv_union($a, $b)

This function returns a new privilege set which is the union of $a and $b

priv_inverse($a)

This function returns a new privilege set which is the inverse of $a.

priv_addset($set, $priv)

This functon adds the privilege $priv to $set.

priv_copyset($a)

This function returns a copy of the privilege set $a.

priv_delset($set, $priv)

This function remove the privilege $priv from $set.

Solaris::Kstat is a Perl module to access Solaris Kstats from Perl.

SYNOPSIS

use Solaris::Kstat;
my $kstat = Solaris::Kstat->new();
my ($usr1, $sys1, $wio1, $idle1) =
@{$kstat->{cpu_stat}{0}{cpu_stat0}}{qw(user kernel wait idle)};
print("usr sys wio idlen");
while (1)
{
sleep 5;
if ($kstat->update()) { print("Configuration changedn"); }
my ($usr2, $sys2, $wio2, $idle2) =
@{$kstat->{cpu_stat}{0}{cpu_stat0}}{qw(user kernel wait idle)};
printf(" %.2d %.2d %.2d %.2dn",
($usr2 - $usr1) / 5, ($sys2 - $sys1) / 5,
($wio2 - $wio1) / 5, ($idle2 - $idle1) / 5);
$usr1 = $usr2; $sys1 = $sys2; $wio1 = $wio2; $idle1 = $idle2;
}

This module provides a tied hash interface to the Solaris kstats library. The kstats library allows you to get access to all the stats used by sar, iostat, vmstat etc, plus a lot of others that arent accessible through the usual utilities.
Solaris categorises statistics using a 3-part key - module, instance and name. For example, the root disk stats can be found under sd.0.sd0, and the cpu statistics can be found under cpu_stat.0.cpu_stat0, as in the above example. The method Solaris::Kstats-new()> creates a new 3-layer tree of perl hashes with exactly the same structure - i.e. the stats for disk 0 can be accessed as $ks-{sd}{0}{sd0}>. The bottom (4th) layer is a tied hash used to hold the individual statistics values for a particular system resource.

Creating a Solaris::Kstat object doesnt actually read all the possible statistics in, as this would be horribly slow and inefficient. Instead it creates a 3-layer structure as described above, and only reads in the individual statistics as you reference them. For example, accessing $ks-{sd}{0}{sd0}{reads} will read in all the statistics for sd0, including writes, bytes read/written, service times etc. Once you have accessed a bottom level statitics value, calling $ks->update() will automatically update all the individual values of any statistics that you have accessed.

Note that there are two values per bottom-level hash that can be read without causing the full set of statistics to be read from the kernel. These are "class" which is the kstat class of the statistics and "crtime" which is the time that the kstat was created. See kstat(3K) for full details of these fields.

Solaris::MapDev Perl module contains a map between instance numbers and device names.

SYNOPSIS

use Solaris::MapDev qw(inst_to_dev dev_to_inst);
my $disk = inst_to_dev("sd0");
my $nfs = inst_to_dev("nfs123");
my $inst = dev_to_inst("c0t0d0s0");
mapdev_data_files(path_to_inst => "/copy/of/a/path_to_inst",
mnttab => "/copy/of/a/mnttab",
dev_ls => { "/dev/rdsk" => "ls-lR/of/dev_dsk",
"/dev/rmt" => "ls-lR/of/dev_rmt" });
my $tape = inst_to_dev("st1");

This module maps both ways between device instance names (e.g. sd0) and /dev entries (e.g. c0t0d0). Vanilla SCSI disks, SSA disks, A1000, A3000, A3500 and A5000 disks are all catered for, as are tape devices and NFS mounts.

FUNCTIONS

inst_to_dev($inst)

Return the device name name given the instance name

dev_to_inst($dev)

Return the instance name given the device name

get_inst_names

Return a sorted list of all the instance names

get_dev_names

Return a sorted list of all the device names

mapdev_data_files

This tells mapdev to use data held in copies of the real datafiles, rather than the current "live" files on the system. This is useful for example when examining explorer output. A list of key-value pairs is expected as the arguments. Valid keys-value pairs are:

path_to_inst => "/copy/of/a/path_to_inst",

A valid path_to_inst file. This is mandatory.

mnttab => "/copy/of/a/mnttab",

A valid /etc/mnttab file. This is optional - if not
specified, no information on NFS devices will be displayed.

dev_ls => { "/dir/path" => "/ls-lR/of/dir/path",
... });

A hash containing path/datafile pairs. The paths should
be one of /dev/rdsk, /dev/osa/rdsk, /dev/osa/dev/rdsk or
/dev/rmt. The datafiles should be the output of a "ls -l"
of the specified directory. A single file containing a
recursive "ls -Rl" of /dev is also acceptable.

mapdev_system_files

This tells mapdev to revert to using the current "live" datafiles on the system - see "mapdev_data_files()"

Solaris::Disk::SVM::Graph is a Perl module for graph your Solaris Volume Manager configurations.

SYNOPSIS

my $graph = Solaris::Disk::SVM::Graph->new(
sourcedir => path/to/dir, # path to SVM config files,
# see Solaris::Disk::SVM for details
fontname => fontname,
fontsize => fontsize,
);

$graph->output(); # output the whole SVM config to svm.png

# output whole configuration
$graph->output(
output => /path/to/image.svg,
# format deduced from file name, if format
# is not present
format => png, # or anything accepted by GraphViz,
# extension will be appended to output filename
);

# output one device
$graph->output( objects => d10 ); # d10 object with sub-devices to d10.png

# output many devices on same graph
$graph->output( objects => [ d10, d11 ] );

# output one device specifying output file name & format
$graph->output(
objects => d10
output => /path/to/image.svg,
format => png,
);

Sun Java Platform Enterprise Edition (Java EE) is the industry standard for developing portable, robust, scalable, and secure server-side Java applications.

Building on the solid foundation of Java SE, Java EE provides Web services, component model, management, and communications APIs that make it the industry standard for implementing enterprise class service-oriented architecture (SOA) and Web 2.0 applications.

The Sun Java Desktop System is a secure, comprehensive, and affordable enterprise desktop software solution that combines the best of open source innovation with significant contributions from Sun.
Initially provided with a Linux OS, Java Desktop System is now also integrated with the Solaris 10 Operating System. As a result, Sun customers have the option of deploying the same desktop environment on Sun workstations, Sun Ray thin clients, as well as a broad range of non-Sun notebook and desktop systems with standard x86-based architectures.
Main features:
End user features:
- Automated software updates and patching, including dependency checking/analysis to ensure systems are secure and up-to-date.
- Local and remote management capabilities provide update scheduling and activity log access.
- Interoperability with centralized software management tools.
- Desktop applications are tightly integrated allowing for drag and drop and copy/paste of text, graphics and other elements between applications.
- Universal printer selection of available printers on network, including printers available on Windows networks.
- Single point of entry for directory and file management and networked computers.
- Direct access to content in data and files by single-click application launch for files contained in email, web pages and file manager.
- Intuitive, easy to use, single install mechanism which ensures users can quickly get productive.
- Easy to learn and use, especially for traditional MS Windows users. Featuring:
- Familiar desktop themes for file management and desktop configuration
- Standard keyboard short cut conventions
- Direct access to files and servers using the "Documents" and "Network Places" directories
- Familiar access to networked computers from single "Network Places" directory
- Full product documentation including Quick Start User Guide and other reference documentation.
- Includes selection of great productivity tools including office suite, browser, email/calendar, instant messaging, project management, drawing and video conferencing applications.
- Multimedia-ready with essential video and audio players plus a sound recorder. Featuring Java Media Player with support for MP3 playback and a CD Player.
- Users can access data stored in office productivity files of Microsoft users and printers connected to existing Windows networks.
- Full interoperability with Microsoft Office files.
- Interoperability with POP3, LDAP, SMTP mail servers.
Administrator features:
- Java Desktop System Configuration Manager allows system administrators to define groups of users and the policies for access rights and settings.
- Fine grained control of employee access rights and privileges.
- Remote image deployment to manage a defined set of packages or system images for rapid setup and provisioning of desktops and deploy on multiple systems simultaneously.
- Centralized package management enabling volume software push, patching, updating multiple desktops.
- Software dependency checking and analysis to identify patch and package dependencies and deploy correct set of software.
- Inventory collection of desktop details, OS, hardware profiles and more.
- Performance Monitoring of deployed desktop environments.
- Use a collection of interconnected computers as a unified computing resource.
- Ability for administrator to view and interact with users desktop display to help, guide and troubleshoot.
Developer features:
- Java Studio Standard is a powerful yet intuitive Integrated Development Environment (IDE) for Java, providing a comprehensive set of features and functionality.
- NetBeans IDE 3.6 delivers tightly integrated deployment and debugging of web applications on Apache Tomcat 5 and the Sun Java System Application Server, Platform Edition 8.
- J2SE hosts the Linux GTK+ look and feel support in JFC/Swing enables Java applets and applications to be written so they look just like native Linux apps on JDS.