Free 1.1.2 software for linux

LAT stands for LDAP Administration Tool. The tool allows you to browse LDAP-based directories and add/edit/delete entries contained within. LAT can store profiles for quick access to different servers.
There are also different views available such as Users, Groups and Hosts which allow you to easily manage objects without having to deal with the intricacies of LDAP.
Main features:
- User, Group Computer and user-defined views
- Directory browser
- Schema browser
- LDIF imports and exports
- Samba and Active Directory support
- Mass-edit support
- Integration with GNOME

pmem software displays memory information of running processes. To do this, pmem reads the memory information that are provided by the /proc file systems. Therefore, pmem does not work on operating systems that do not maintain this files system.

To install pmem just untar the source package and run make. This will create the binary pmem-1.1.2. Run configure, make and finally make install to install the binary in /urs/local. You can also set another installation directory by calling configure with the option --prefix=/foo/bar.

Summary of the installation process:

1. tar xzf pmem-version.tar.gz
2. cd pmem-version
3. ./configure [--prefix=...]
3. make
4. make install

Usage:

pmem must be called with one or more process ids of the processes for which the memory usage should be display. By default pmem displays the resident memory of the process in bytes. But the behaviour of pmem can be influenced by the following arguments:

-z displays the size
-s displays the shared memory
-k displays the memory usage in kilobytes
-m displays the memory usage in megabytes
-d displays all memory information available
-l log memory usage of given pids
-i log interval in milliseconds [default: 100]
-g write a gnuplot command file into plot.gnu
-h displays the help
-v displays the version
On success pmem returns with the exit code 0, otherwise 1.

Example:

To log the memory usage of a process and create a gnuplot file out of the data:

./pmem -l pids -i 100 -g data >data
gnuplot plot.gnu (creates the graph plot).

DBFW is a PHP-based database framework for rapid application development and rapid prototyping.
DBFW project allows the creation of almost complete Web/database-based applications in no more than few hours, as well as faster development cycles.
It uses automatic DB schema discovery with XML configuration files to automatically implement a basic user interface that can be extended through the use of ad-hoc PHP code.
This framework aims to provide the developer with a tool that can be used first to iron out the database structure through as many iterations as required, but without forcing the developer to rewrite everything at every iteration.
It provides many features aimed to reduce this round-trip in the requirement and specification analisys phase, thanks to its ability to provide an auto-updating and working prototype of the user interface that can be used to access data from the DB under construction.
Main features:
- autodetection of the entire DB schema. The framework engine will retrieve all required informations from the DB itself (like all user visible tables, foreign keys, column types, and so on). It will cache the discovered infos in a file under the directory cache/ of the application. If you change the schema, the tables, add/remove columns and so on, you will just need to remove the cache file and the framework will redo the discovery process.
- XML-based User Interface specification. The user interface of the application is specified through a set of XML files, which will contain the templates for the application forms and browsers as well as the application menus, the reports and so on....
- automatic handling of CRUD functionality. By default, it is able to provide support for creation, read, update and delete of records from all your tables.
- automatic handling of Foreign Keys. The framework knows all foreign keys defined among tables, and it will allow its automatic handling whenever you will say so. The automatic handling means navigable html links during the browsing of records from a given table as well as search or select widgets in the editing forms.
- multi database support. The framework uses a driver based interface for DB access, which means that new databases backend may be added later, by simply creating the related driver. The framework currently supports the following DB:
- PostgreSQL 7.3.X and later (The 8.X needs more tests, thought)
- MySQL 4.1.X and later (Check the driver specifications for known limitations)
- Oracle 9i and later (it should work, even if it hasnt been used by few years)
- The framework uses the PEAR library for DB access, so the its internal driver will add only the functionality required by the discovery process and few others not directly provided by the PEAR driver.
- simple creation of Reports. You can create a Report (or a group of Reports) simply by specifying the SQL query which generate the data and by choose the output, be it a textual one using a template, or a graphical one, using the GD library or a SVG generator. It supports the following output formats: HTML, PDF (still under development, thought), TSV (tab Separated Values) and XLS (Excel Spreadsheets);
- DHTML forms: hierarchical forms are implemented using DHTML so they are handled by the web client for the most part, avoiding unnecessary round-trips. (It should work with almost all recently web browsers).
- form nesting. This allows you to create nested forms for editing of related sets of records. All modifications to the set will be committed as a unique transaction, so they will fail or success as a whole.
- form validation and error handling: all forms will be validated before their use, and all errors will be notified to the user. The framework uses the exernal JavaScript library overlib to handle tooltips as well as error notifications ( you may find more info at http://www.bosrup.com/web/overlib/ )
- support for record history. You may create two additional columns in your tables (a start-of-validity one and a end-of-validity one), tell the framework of them and then it will handle all modifications as storicized modifications (i.e. the records will not be really deleted, just marked as expired).
- integrated support for PDF generation, through the external library html2ps based on FPDF
- javascript calendar for web client date handling (a really wonderful JavaScript library. Check it out at http://students.infoiasi.ro/~mishoo/site/calendar.epl
- dynamically generated menus: you can generate menus dinamically using SQL queries.
- internationalization: it supports full internationalization for both framework and applications using Gettext. They may be handled separately, so you can maintain your application messages indipendently from those of the framework.
- privileges: the framework will respect all privileges defined on the DB tables, as well as it will enforce additional privileges, like record based ones (yes, really record based... I need to document how they work, though... )
- automatic generation of user documentation: (Work In Progress) Since the application behaviour is specified for the most part in the XML configuration files, its possible to process those files to generate automatically the core of the User Documentation. Of course, it still need to be completed and edited by hand, but this time you may concentrate on its content. BTW, the generated document will be in DocBook XML format.
- support for pop-up based details views.
- many more feature, like the handlers (PHP code which can be hooked to specific engine events like the decode event or the post_retrieve and so on), triggers (to allow the use of special triggers on DB that doesnt support triggers that access the tables under modifications, like Oracle and MySQL), foreign key and browser filtering, order-by handling, externally linked pages, and so on...
Enhancements:
- A new online help subsystem, a code cleanup, more work on the documentation, more support for data exports, and many bugfixes.

DiffJ is a commandline application that compares Java files based on content, not whitespace, comments, or reordering of types, methods, or fields.
Its output is based on the Unix program diff, and it also has a "brief" output format for a concise summary of what changed. It can work on directories recursively, looking for matching filenames, like "diff -r dir0 dir1".
DiffJ is primarily for developers refactoring and reformatting Java code, for which most difference tools tend to produce misleading results regarding the type and extent of changes.
Enhancements:
- The difference comparator of functions (methods and constructors) has been fixed, and the default Java source is now 1.5.

LowCal is a lightweight Web-based calendar of events.
These instructions assume you have root access to the machine youre installing on. If you dont, youre not likely to be able to install new apache modules without help (and permission) from a system administrator.
You need to actually install the code to the appropriate directories. Running install.pl in the directory where you unpacked the tarball will do this. By default, the LowCal module itself will install under /usr/local/lib/site_perl and command-line utilities will be installed in /usr/local/bin. If these locations are not appropriate for your system, edit the values of $module_dir and/or $util_dir near the top of the script before running it.
Enhancements:
- Cleaned up handling of day-of-month past end-of-month (PR#7)

SVNKit is a pure Java Subversion (SVN) client library. This means that users of the library (i.e. Java applications) do not have to include svn native binaries or javahl bindings to work with subversion repositories.
SVNKit project is not only a 100% Java replacement for javahl bindings, but also a library that provides a high level of control over subversion repository operations.
Main features:
- No external binaries or libraries are needed to work with Subversion repository.
- SVNKit supports http, https, svn and svn+ssh connection protocols.
- Subversion 1.4.2 and file protocol support.
- Low level API allows effective direct Subversion repository access.
- SVNKit is compatible with applications that already use native javahl bindings.
Enhancements:
- An interactive password prompt was added to the command line client.
- System-wide configuration file support was added and bugs were fixed.

Sencap is a simple ENCAP software manager. Encapping is a method of installing software from source tarballs into private trees (bin, lib, man, share) and symlinking them to the system tree (e.g. /usr/local).

Uninstallation of encapped software is quick, reliable and easy. Encapping is best used to augment the default package manager, not to replace it.

Installation

These are generic installation instructions.

The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.

Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).

If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release. If at some point `config.cache contains results you dont want to keep, you may remove or edit it.

The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute
`configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is
also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.