Free web 0.51 software for linux

Deskweb applies the iconography and usability of a common Windows desktop system to Web applications.

Deskweb is familiar and user-friendly and lets users easily learn how to exploit all of the softwares features.

It can be used in various ways, such as a content management system, a company groupware, a wiki, or more.

web-cp is a full-featured, open source web hosting control panel written in PHP and released under the GPL. It consists of 4 control panels: personal, domain, reseller, and server.
The personal control panel allows users to update their personal information, change their password and set their spam control settings. The domain control panel allows domain owners to add new users, aliases, subdomains, domain pointers and databases.
The resellers control panel allows resellers to add or modify their domain accounts. The server control panel allows the server administrator to add or modify resellers, edit VirtualHost and DNS templates, restart services and monitor server usage.
Scripting, shell access, SSI, databases, mail, domains, etc are all controlled from a top-down approach. Web-CP.net is a continuation of the development of web://cp with its ultimate goal being a 1.0 release.
Main features:
- Skinnable
- Security
- Flexibility
- Configurable Levels of Access
- Seperate Front-end and Back-end processes (security)
- Task Automation
- Advanced Management

JMP is a profiler for java that can be used to trace objects usage and method timings. JMP uses the JVMPI interface to gather statistics and interact with the JVM. JMP project uses the GTK+ interface to show the status.
JMP normally uses one window to show the classes in memory. Each class has summary information for number of instances and total bytes of used memory for all the instances.
JMP can perform heap analysis and has the ability to show which objects own (have references to) all the objects of a specified class. This is a great way to find memory leaks.
JMP also shows method timings and calls in another window. Several columns show time taken in the method, number of calls to each method, time taken in methods called.
JMP collects information about which method are called and from where, this information is used to build call graphs.
JMP interacts with the normal java threads and also uses one extra thread for GTK+ with a timer to systematically update the stats.
JMP is written in C, it is designed for speed.
Enhancements:
- A few crash bugs were fixed.
- Some compilation problems on FreeBSD and Solaris were fixed.

Ingperl module allows Perl access to Ingres databases for old ingperl scripts.

SYNOPSIS

&sql(...);
&sql_exec(...);
@values = &sql_fetch;
&sql_close;

@types = &sql_types;
@ingtypes = &sql_ingtypes;
@lengths = &sql_lengths;
@nullable = &sql_nullable;
@names = &sql_names;

$sql_version
$sql_error
$sql_sqlcode
$sql_rowcount
$sql_readonly
$sql_showerrors
$sql_debug

@row1 = &sql_eval_row1(select ...);
@col1 = &sql_eval_col1(select ...);

Ingperl is an extension to Perl which allows access to Ingres databases.
The functions that make up the interface are described in the following sections.
All functions return false or undefined (in the Perl sense) to indicate failure.

ipaudit-web logs network activity, maintains traffic summaries, and presents Web-accessible graphs and reports. ipaudit-web logs network activity, maintains traffic summaries, and presents Web-accessible graphs and reports. It is useful for identifying heavy bandwidth users, DoS attacks, and scans, etc.
IPAudit can be intsalled in a distribution-specific binary package, or can be compiled from source. To compile IPAudit, you first need the pcap packet library installed. You can download and compile the " classic " source code from LBNL Network Research Group or you can download a newer version of the pcap library from tcpdump.org.
IPAUDIT can be used to monitor network activity for a variety of purposes. It has proved useful for monitoring intrusion detection, bandwidth consumption and denial of service attacks.
We run it in shifts. Every 30 minutes launch an new instance of IPAUDIT in the background and kill the previous instance. Before the previous instance dies it writes a file describing the network activity for the past 30 minutes. Perl scripts then parse this file and make a Web viewable report. It currently monitors a 45MB link averaging at about 1/3 capacity on a Pentium II/333 running Linux 2.2.13. Average CPU usage is at about 10%, and peaks at around %20 on the half hour.
IPAUDIT can also be used with IPAUIT-WEB, and collection of cron and web-cgi scripts for gathering data and making reports (NOTE: The separate IPAUDIT-WEB distruction not yet available. You can however obtain web-cgi scripts from ipaudit-0.93b4.tgz).
Enhancements:
- corrected for packet double count / double write when packets travels between two monitored interfaces.
- added -M option to turn off correction for multiple devices.

B::Graph is a Perl compiler backend to produce graphs of OP trees.

SYNOPSIS

perl -MO=Graph,-text prog.pl >graph.txt

perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg

perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps

This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).

OPTIONS

Like any other compiler backend, this module needs to be invoked using the O module to run correctly:

perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";

Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.

Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):

-text, -vcg, -dot

Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).

-addrs, -no_addrs

Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.

-compile_order, -run_order

The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.

-SVs, -no_SVs

If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.

-ellipses, -rhombs

The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).

-stashes, -no_stashes

The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.

-fileGVs, -no_fileGVs

Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.

-SEQs, -no_SEQs

As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).

-types, -no_types

B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.

-float, -no_float

Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.

-targlinks, -no_targlinks

Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.

MplayerBuddy is a media bookmarking application designed to keep track of the user’s place when watching videos. The application uses mplayer as its back-end media player, is written in C# using the gtksharp toolkit, is designed to run with mono on Linux and is excellent for people with very short attention spans who constantly start and stop several videos like myself.